Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-3.0-or-later
2 : : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
3 : :
4 : : #define G_LOG_DOMAIN "valent-mousepad-device"
5 : :
6 : : #include "config.h"
7 : :
8 : : #include <gio/gio.h>
9 : : #include <valent.h>
10 : :
11 : : #include "valent-mousepad-device.h"
12 : : #include "valent-mousepad-keydef.h"
13 : :
14 : : #define DEFAULT_DOUBLE_CLICK_TIME (400)
15 : : #define DEFAULT_LONG_PRESS_TIME (500)
16 : :
17 : :
18 : : struct _ValentMousepadDevice
19 : : {
20 : : ValentInputAdapter parent_instance;
21 : :
22 : : ValentDevice *device;
23 : : #if 0
24 : : // TODO: use libportal
25 : : GtkSettings *settings;
26 : : #endif
27 : :
28 : : /* keyboard */
29 : : GArray *keyboard_keys;
30 : : KeyModifierType keyboard_modifiers;
31 : : unsigned int keyboard_flush_id;
32 : :
33 : : /* pointer */
34 : : unsigned int pointer_button;
35 : : unsigned int pointer_presses;
36 : : unsigned int pointer_releases;
37 : : unsigned int pointer_doubleclick_id;
38 : : unsigned int pointer_longpress_id;
39 : :
40 : : int double_click_time;
41 : : int long_press_time;
42 : : };
43 : :
44 [ + + + - ]: 6 : G_DEFINE_FINAL_TYPE (ValentMousepadDevice, valent_mousepad_device, VALENT_TYPE_INPUT_ADAPTER)
45 : :
46 : :
47 : : /*
48 : : * Keyboard
49 : : */
50 : : static gboolean
51 : 0 : valent_mousepad_device_keyboard_flush (gpointer data)
52 : : {
53 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (data);
54 : 0 : g_autoptr (JsonBuilder) builder = NULL;
55 [ # # ]: 0 : g_autoptr (JsonNode) packet = NULL;
56 [ # # ]: 0 : g_autoptr (GString) key = NULL;
57 : 0 : uint32_t special_key = 0;
58 : 0 : unsigned int n_handled = 0;
59 : :
60 [ # # ]: 0 : if (self->keyboard_keys->len == 0)
61 : : {
62 : 0 : self->keyboard_flush_id = 0;
63 : 0 : return G_SOURCE_REMOVE;
64 : : }
65 : :
66 [ # # ]: 0 : for (unsigned int len = self->keyboard_keys->len; n_handled < len; n_handled++)
67 : : {
68 : 0 : uint32_t *keysym = &g_array_index (self->keyboard_keys, uint32_t, n_handled);
69 : :
70 [ # # ]: 0 : if ((special_key = valent_mousepad_keysym_to_keycode (*keysym)) != 0)
71 : : {
72 : : /* If there are keys to be sent, they need to be sent first */
73 [ # # ]: 0 : if (key != NULL)
74 : 0 : special_key = 0;
75 : :
76 : : /* Otherwise, we need to send the current key and modifiers */
77 : 0 : n_handled++;
78 : 0 : break;
79 : : }
80 : : else
81 : : {
82 : 0 : gunichar wc = valent_input_keysym_to_unicode (*keysym);
83 : :
84 [ # # ]: 0 : if (wc == 0)
85 : : {
86 : 0 : g_debug ("%s(): failed to convert keysym \"%u\" to unicode",
87 : : G_STRFUNC, *keysym);
88 : 0 : continue;
89 : : }
90 : :
91 [ # # ]: 0 : if (key == NULL)
92 : 0 : key = g_string_new (NULL);
93 : :
94 : 0 : g_string_append_unichar (key, wc);
95 : : }
96 : : }
97 : 0 : g_array_remove_range (self->keyboard_keys, 0, n_handled);
98 : :
99 : : /* Build the packet */
100 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
101 : :
102 [ # # ]: 0 : if (key != NULL)
103 : : {
104 : 0 : json_builder_set_member_name (builder, "key");
105 : 0 : json_builder_add_string_value (builder, key->str);
106 : : }
107 [ # # ]: 0 : else if (special_key != 0)
108 : : {
109 : 0 : json_builder_set_member_name (builder, "specialKey");
110 : 0 : json_builder_add_int_value (builder, special_key);
111 : : }
112 : :
113 : : /* Check our supported modifiers */
114 [ # # ]: 0 : if ((self->keyboard_modifiers & KEYMOD_ALT_MASK) != 0)
115 : : {
116 : 0 : json_builder_set_member_name (builder, "alt");
117 : 0 : json_builder_add_boolean_value (builder, TRUE);
118 : : }
119 : :
120 [ # # ]: 0 : if ((self->keyboard_modifiers & KEYMOD_CONTROL_MASK) != 0)
121 : : {
122 : 0 : json_builder_set_member_name (builder, "ctrl");
123 : 0 : json_builder_add_boolean_value (builder, TRUE);
124 : : }
125 : :
126 [ # # ]: 0 : if ((self->keyboard_modifiers & KEYMOD_SHIFT_MASK) != 0)
127 : : {
128 : 0 : json_builder_set_member_name (builder, "shift");
129 : 0 : json_builder_add_boolean_value (builder, TRUE);
130 : : }
131 : :
132 [ # # ]: 0 : if ((self->keyboard_modifiers & KEYMOD_SUPER_MASK) != 0)
133 : : {
134 : 0 : json_builder_set_member_name (builder, "super");
135 : 0 : json_builder_add_boolean_value (builder, TRUE);
136 : : }
137 : :
138 : : /* Request acknowledgment of the event (disabled until it can be received) */
139 : : #if 0
140 : : json_builder_set_member_name (builder, "sendAck");
141 : : json_builder_add_boolean_value (builder, TRUE);
142 : : #endif
143 : :
144 : 0 : packet = valent_packet_end (&builder);
145 : 0 : valent_device_send_packet (self->device, packet, NULL, NULL, NULL);
146 : :
147 : : /* Clear the source if there's nothing left queued */
148 [ # # ]: 0 : if (self->keyboard_keys->len == 0)
149 : : {
150 : 0 : self->keyboard_flush_id = 0;
151 : 0 : return G_SOURCE_REMOVE;
152 : : }
153 : :
154 : : return G_SOURCE_CONTINUE;
155 : : }
156 : :
157 : : static inline void
158 : 2 : valent_mousepad_device_keyboard_reset (ValentMousepadDevice *self)
159 : : {
160 [ + - ]: 2 : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
161 : :
162 : 2 : g_array_remove_range (self->keyboard_keys, 0, self->keyboard_keys->len);
163 [ - + ]: 2 : g_clear_handle_id (&self->keyboard_flush_id, g_source_remove);
164 : 2 : }
165 : :
166 : : /*
167 : : * Pointer
168 : : */
169 : : static inline gboolean
170 : 2 : valent_mousepad_device_pointer_reset (ValentMousepadDevice *self)
171 : : {
172 : 2 : self->pointer_button = 0;
173 : 2 : self->pointer_presses = 0;
174 : 2 : self->pointer_releases = 0;
175 [ - + ]: 2 : g_clear_handle_id (&self->pointer_doubleclick_id, g_source_remove);
176 [ - + ]: 2 : g_clear_handle_id (&self->pointer_longpress_id, g_source_remove);
177 : :
178 : 2 : return G_SOURCE_REMOVE;
179 : : }
180 : :
181 : : static inline gboolean
182 : 0 : valent_mousepad_device_pointer_flush (gpointer data)
183 : : {
184 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (data);
185 : 0 : g_autoptr (JsonBuilder) builder = NULL;
186 [ # # ]: 0 : g_autoptr (JsonNode) packet = NULL;
187 : :
188 [ # # ]: 0 : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
189 : :
190 : : /* Ignore unpaired releases */
191 [ # # ]: 0 : if (self->pointer_presses < self->pointer_releases)
192 : 0 : return valent_mousepad_device_pointer_reset (self);
193 : :
194 [ # # # # ]: 0 : if (self->pointer_presses == 1 && self->pointer_releases == 1)
195 : : {
196 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
197 : :
198 [ # # # # ]: 0 : switch (self->pointer_button)
199 : : {
200 : 0 : case VALENT_POINTER_PRIMARY:
201 : 0 : json_builder_set_member_name (builder, "singleclick");
202 : 0 : json_builder_add_boolean_value (builder, TRUE);
203 : 0 : break;
204 : :
205 : 0 : case VALENT_POINTER_MIDDLE:
206 : 0 : json_builder_set_member_name (builder, "middleclick");
207 : 0 : json_builder_add_boolean_value (builder, TRUE);
208 : 0 : break;
209 : :
210 : 0 : case VALENT_POINTER_SECONDARY:
211 : 0 : json_builder_set_member_name (builder, "rightclick");
212 : 0 : json_builder_add_boolean_value (builder, TRUE);
213 : 0 : break;
214 : :
215 : 0 : default:
216 : 0 : g_debug ("%s: unknown pointer button %u",
217 : : G_STRFUNC,
218 : : self->pointer_button);
219 : : }
220 : :
221 : 0 : packet = valent_packet_end (&builder);
222 : : }
223 [ # # ]: 0 : else if (self->pointer_button == VALENT_POINTER_PRIMARY && self->pointer_presses == 2)
224 : : {
225 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
226 : 0 : json_builder_set_member_name (builder, "doubleclick");
227 : 0 : json_builder_add_boolean_value (builder, TRUE);
228 : 0 : packet = valent_packet_end (&builder);
229 : : }
230 : :
231 [ # # ]: 0 : if (packet != NULL)
232 : : {
233 : 0 : valent_device_send_packet (self->device, packet, NULL, NULL, NULL);
234 : 0 : valent_mousepad_device_pointer_reset (self);
235 : : }
236 : :
237 : 0 : return G_SOURCE_REMOVE;
238 : : }
239 : :
240 : : static inline gboolean
241 : 0 : valent_mousepad_device_pointer_longpress (gpointer data)
242 : : {
243 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (data);
244 : 0 : g_autoptr (JsonBuilder) builder = NULL;
245 [ # # ]: 0 : g_autoptr (JsonNode) packet = NULL;
246 : :
247 [ # # ]: 0 : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
248 : :
249 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
250 : 0 : json_builder_set_member_name (builder, "singlehold");
251 : 0 : json_builder_add_boolean_value (builder, TRUE);
252 : 0 : packet = valent_packet_end (&builder);
253 : :
254 : 0 : valent_device_send_packet (self->device, packet, NULL, NULL, NULL);
255 : :
256 [ # # ]: 0 : return valent_mousepad_device_pointer_reset (self);
257 : : }
258 : :
259 : : #if 0
260 : : // TODO: use libportal
261 : : static void
262 : : on_pointer_settings_changed (GtkSettings *settings,
263 : : GParamSpec *pspec,
264 : : ValentMousepadDevice *self)
265 : : {
266 : : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
267 : :
268 : : g_object_get (settings,
269 : : "gtk-double-click-time", &self->double_click_time,
270 : : "gtk-long-press-time", &self->long_press_time,
271 : : NULL);
272 : : }
273 : : #endif
274 : :
275 : : /*
276 : : * ValentInputAdapter
277 : : */
278 : : static void
279 : 0 : valent_mousepad_device_keyboard_keysym (ValentInputAdapter *adapter,
280 : : uint32_t keysym,
281 : : gboolean state)
282 : : {
283 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (adapter);
284 : :
285 [ # # ]: 0 : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
286 [ # # ]: 0 : g_return_if_fail (keysym != 0);
287 : :
288 : : /* Track modifiers, but don't send anything */
289 [ # # ]: 0 : if (valent_input_keysym_to_modifier (keysym, state, &self->keyboard_modifiers))
290 : : return;
291 : :
292 : : // TODO: the KDE Connect protocol doesn't support press and release states
293 : : // for keyboard input, so only key presses are sent. A solution might
294 : : // involve matching presses and releases, or an extant convention.
295 [ # # ]: 0 : if (!state)
296 : : return;
297 : :
298 : 0 : g_array_append_val (self->keyboard_keys, keysym);
299 : :
300 : : /* If there are modifiers set, the key should be sent immediately */
301 [ # # ]: 0 : if ((self->keyboard_modifiers & KEYMOD_ANY_MASK) != 0)
302 : : {
303 : 0 : valent_mousepad_device_keyboard_flush (self);
304 : 0 : return;
305 : : }
306 : :
307 : : /* Flush in an idle callback, in case key presses can be sent as a string */
308 [ # # ]: 0 : if (self->keyboard_flush_id == 0)
309 : 0 : self->keyboard_flush_id = g_idle_add (valent_mousepad_device_keyboard_flush,
310 : : self);
311 : : }
312 : :
313 : : static void
314 : 0 : valent_mousepad_device_pointer_axis (ValentInputAdapter *adapter,
315 : : double dx,
316 : : double dy)
317 : : {
318 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (adapter);
319 : 0 : g_autoptr (JsonBuilder) builder = NULL;
320 [ # # ]: 0 : g_autoptr (JsonNode) packet = NULL;
321 : :
322 [ # # ]: 0 : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
323 : :
324 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
325 : 0 : json_builder_set_member_name (builder, "dx");
326 : 0 : json_builder_add_double_value (builder, dx);
327 : 0 : json_builder_set_member_name (builder, "dy");
328 : 0 : json_builder_add_double_value (builder, dy);
329 : 0 : json_builder_set_member_name (builder, "scroll");
330 : 0 : json_builder_add_boolean_value (builder, TRUE);
331 : 0 : packet = valent_packet_end (&builder);
332 : :
333 [ # # ]: 0 : valent_device_send_packet (self->device, packet, NULL, NULL, NULL);
334 : 0 : }
335 : :
336 : : static void
337 : 0 : valent_mousepad_device_pointer_button (ValentInputAdapter *adapter,
338 : : unsigned int button,
339 : : gboolean state)
340 : : {
341 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (adapter);
342 : :
343 [ # # ]: 0 : if (self->pointer_button != button)
344 : : {
345 : 0 : self->pointer_button = button;
346 : 0 : self->pointer_presses = 0;
347 : 0 : self->pointer_releases = 0;
348 : : }
349 : :
350 [ # # ]: 0 : if (state)
351 : : {
352 : 0 : self->pointer_presses += 1;
353 : :
354 : : /* Any button press removes the double click timer; the event will either
355 : : * be accepted or rejected based on the current button state. */
356 [ # # ]: 0 : g_clear_handle_id (&self->pointer_doubleclick_id, g_source_remove);
357 : : }
358 : : else
359 : : {
360 : 0 : self->pointer_releases += 1;
361 : : }
362 : :
363 : : /* Any button event removes the long press timer; the event is accepted if the
364 : : * timeout elapses with the primary button being the only button pressed. */
365 [ # # ]: 0 : g_clear_handle_id (&self->pointer_longpress_id, g_source_remove);
366 : :
367 : : /* Handle the first press and release for the primary button, to prevent
368 : : * flushing the double click state on the first release. */
369 [ # # ]: 0 : if (self->pointer_button == VALENT_POINTER_PRIMARY && self->pointer_presses == 1)
370 : : {
371 : : /* Double click and long press events both start with the press event */
372 [ # # ]: 0 : if (self->pointer_releases == 0)
373 : : {
374 : : // TODO: what if double-click time < long-press time?
375 : : /* If the timeout elapses, a "singleclick" packet will be sent */
376 : 0 : self->pointer_doubleclick_id =
377 : 0 : g_timeout_add (self->double_click_time,
378 : : valent_mousepad_device_pointer_flush,
379 : : self);
380 : 0 : g_source_set_name_by_id (self->pointer_doubleclick_id,
381 : : "valent_mousepad_device_pointer_flush");
382 : :
383 : : /* If the timeout elapses, a "singlehold" packet will be sent */
384 : 0 : self->pointer_longpress_id =
385 : 0 : g_timeout_add (self->long_press_time,
386 : : valent_mousepad_device_pointer_longpress,
387 : : self);
388 : 0 : g_source_set_name_by_id (self->pointer_longpress_id,
389 : : "valent_mousepad_device_pointer_longpress");
390 : : }
391 : : }
392 : : else
393 : : {
394 : 0 : valent_mousepad_device_pointer_flush (self);
395 : : }
396 : 0 : }
397 : :
398 : : static void
399 : 0 : valent_mousepad_device_pointer_motion (ValentInputAdapter *adapter,
400 : : double dx,
401 : : double dy)
402 : : {
403 : 0 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (adapter);
404 : 0 : g_autoptr (JsonBuilder) builder = NULL;
405 [ # # ]: 0 : g_autoptr (JsonNode) packet = NULL;
406 : :
407 [ # # ]: 0 : g_assert (VALENT_IS_MOUSEPAD_DEVICE (self));
408 : :
409 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
410 : 0 : json_builder_set_member_name (builder, "dx");
411 : 0 : json_builder_add_double_value (builder, dx);
412 : 0 : json_builder_set_member_name (builder, "dy");
413 : 0 : json_builder_add_double_value (builder, dy);
414 : 0 : packet = valent_packet_end (&builder);
415 : :
416 : 0 : valent_device_send_packet (self->device, packet, NULL, NULL, NULL);
417 [ # # ]: 0 : valent_mousepad_device_pointer_reset (self);
418 : 0 : }
419 : :
420 : : #if 0
421 : : static void
422 : : valent_mousepad_device_pointer_release (ValentInputRemote *self)
423 : : {
424 : : g_autoptr (JsonBuilder) builder = NULL;
425 : : g_autoptr (JsonNode) packet = NULL;
426 : :
427 : : valent_packet_init (&builder, "kdeconnect.mousepad.request");
428 : : json_builder_set_member_name (builder, "singlerelease");
429 : : json_builder_add_boolean_value (builder, TRUE);
430 : : packet = valent_packet_end (&builder);
431 : :
432 : : valent_device_send_packet (self->device, packet, NULL, NULL, NULL);
433 : : }
434 : : #endif
435 : :
436 : : static void
437 : 0 : on_device_state_changed (ValentDevice *device,
438 : : GParamSpec *pspec,
439 : : ValentMousepadDevice *self)
440 : : {
441 : : #if 0
442 : : ValentDeviceState state = VALENT_DEVICE_STATE_NONE;
443 : : gboolean available;
444 : :
445 : : state = valent_device_get_state (device);
446 : : available = (state & VALENT_DEVICE_STATE_CONNECTED) != 0 &&
447 : : (state & VALENT_DEVICE_STATE_PAIRED) != 0;
448 : : #endif
449 : 0 : }
450 : :
451 : : /*
452 : : * ValentObject
453 : : */
454 : : static void
455 : 2 : valent_mousepad_device_destroy (ValentObject *object)
456 : : {
457 : 2 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (object);
458 : :
459 : : #if 0
460 : : // TODO: use libportal
461 : : if (self->settings != NULL)
462 : : {
463 : : g_signal_handlers_disconnect_by_data (self->settings, self);
464 : : self->settings = NULL;
465 : : }
466 : : #endif
467 : :
468 : 2 : valent_mousepad_device_keyboard_reset (self);
469 : 2 : valent_mousepad_device_pointer_reset (self);
470 : :
471 : 2 : VALENT_OBJECT_CLASS (valent_mousepad_device_parent_class)->destroy (object);
472 : 2 : }
473 : :
474 : : /*
475 : : * GObject
476 : : */
477 : : static void
478 : 2 : valent_mousepad_device_constructed (GObject *object)
479 : : {
480 : 2 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (object);
481 : :
482 : 2 : G_OBJECT_CLASS (valent_mousepad_device_parent_class)->constructed (object);
483 : :
484 : 2 : self->device = valent_resource_get_source (VALENT_RESOURCE (self));
485 : 2 : g_signal_connect_object (self->device,
486 : : "notify::state",
487 : : G_CALLBACK (on_device_state_changed),
488 : : self,
489 : : G_CONNECT_DEFAULT);
490 : :
491 : : #if 0
492 : : // TODO: use libportal
493 : : if (gtk_is_initialized ())
494 : : {
495 : : self->settings = gtk_settings_get_default ();
496 : : g_signal_connect_object (self->settings,
497 : : "notify::gtk-double-click-time",
498 : : G_CALLBACK (on_pointer_settings_changed),
499 : : self, 0);
500 : : on_pointer_settings_changed (self->settings, NULL, self);
501 : : }
502 : : #endif
503 : 2 : }
504 : :
505 : : static void
506 : 2 : valent_mousepad_device_finalize (GObject *object)
507 : : {
508 : 2 : ValentMousepadDevice *self = VALENT_MOUSEPAD_DEVICE (object);
509 : :
510 [ + - ]: 2 : g_clear_pointer (&self->keyboard_keys, g_array_unref);
511 : :
512 : 2 : G_OBJECT_CLASS (valent_mousepad_device_parent_class)->finalize (object);
513 : 2 : }
514 : :
515 : : static void
516 : 1 : valent_mousepad_device_class_init (ValentMousepadDeviceClass *klass)
517 : : {
518 : 1 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
519 : 1 : ValentObjectClass *vobject_class = VALENT_OBJECT_CLASS (klass);
520 : 1 : ValentInputAdapterClass *input_class = VALENT_INPUT_ADAPTER_CLASS (klass);
521 : :
522 : 1 : object_class->constructed = valent_mousepad_device_constructed;
523 : 1 : object_class->finalize = valent_mousepad_device_finalize;
524 : :
525 : 1 : vobject_class->destroy = valent_mousepad_device_destroy;
526 : :
527 : 1 : input_class->keyboard_keysym = valent_mousepad_device_keyboard_keysym;
528 : 1 : input_class->pointer_axis = valent_mousepad_device_pointer_axis;
529 : 1 : input_class->pointer_button = valent_mousepad_device_pointer_button;
530 : 1 : input_class->pointer_motion = valent_mousepad_device_pointer_motion;
531 : : }
532 : :
533 : : static void
534 : 2 : valent_mousepad_device_init (ValentMousepadDevice *self)
535 : : {
536 : 2 : self->keyboard_keys = g_array_new (FALSE, FALSE, sizeof (uint32_t));
537 : 2 : self->double_click_time = DEFAULT_DOUBLE_CLICK_TIME;
538 : 2 : self->long_press_time = DEFAULT_LONG_PRESS_TIME;
539 : 2 : }
540 : :
541 : : /**
542 : : * valent_mousepad_device_new:
543 : : * @device: a `ValentDevice`
544 : : *
545 : : * Get the `ValentMousepadDevice` instance.
546 : : *
547 : : * Returns: (transfer full) (nullable): a `ValentMousepadDevice`
548 : : */
549 : : ValentMousepadDevice *
550 : 2 : valent_mousepad_device_new (ValentDevice *device)
551 : : {
552 : 4 : g_autoptr (ValentContext) context = NULL;
553 [ + - ]: 2 : g_autofree char *iri = NULL;
554 : :
555 [ + - ]: 2 : g_return_val_if_fail (VALENT_IS_DEVICE (device), NULL);
556 : :
557 : 2 : context = valent_context_new (valent_device_get_context (device),
558 : : "plugin",
559 : : "systemvolume");
560 : 2 : iri = tracker_sparql_escape_uri_printf ("urn:valent:mixer:%s",
561 : : valent_device_get_id (device));
562 : 2 : return g_object_new (VALENT_TYPE_MOUSEPAD_DEVICE,
563 : : "iri", iri,
564 : : "context", context,
565 : : "source", device,
566 : : "title", valent_device_get_name (device),
567 : : NULL);
568 : : }
569 : :
570 : : /**
571 : : * valent_media_player_update_packet:
572 : : * @player: a `ValentMousepadDevice`
573 : : * @packet: a KDE Connect packet
574 : : *
575 : : * A convenience method for updating the internal state of the player from a
576 : : * `kdeconnect.mousepad` packet.
577 : : */
578 : : void
579 : 0 : valent_mousepad_device_handle_packet (ValentMousepadDevice *player,
580 : : JsonNode *packet)
581 : : {
582 : 0 : }
|
