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-plugin"
5 : :
6 : : #include "config.h"
7 : :
8 : : #include <glib/gi18n.h>
9 : : #include <gio/gio.h>
10 : : #include <json-glib/json-glib.h>
11 : : #include <valent.h>
12 : :
13 : : #include "valent-mousepad-device.h"
14 : : #include "valent-mousepad-keydef.h"
15 : : #include "valent-mousepad-plugin.h"
16 : :
17 : :
18 : : struct _ValentMousepadPlugin
19 : : {
20 : : ValentDevicePlugin parent_instance;
21 : :
22 : : ValentInput *input;
23 : : ValentMousepadDevice *adapter;
24 : :
25 : : unsigned int local_state : 1;
26 : : unsigned int remote_state : 1;
27 : : };
28 : :
29 : : static void valent_mousepad_plugin_send_echo (ValentMousepadPlugin *self,
30 : : JsonNode *packet);
31 : :
32 [ + + + - ]: 80 : G_DEFINE_FINAL_TYPE (ValentMousepadPlugin, valent_mousepad_plugin, VALENT_TYPE_DEVICE_PLUGIN)
33 : :
34 : :
35 : : static KeyModifierType
36 : 4 : event_to_mask (JsonObject *body)
37 : : {
38 : 4 : KeyModifierType mask = 0;
39 : :
40 [ + + ]: 4 : if (json_object_get_boolean_member_with_default (body, "alt", FALSE))
41 : 1 : mask |= KEYMOD_ALT_MASK;
42 : :
43 [ + + ]: 4 : if (json_object_get_boolean_member_with_default (body, "ctrl", FALSE))
44 : 1 : mask |= KEYMOD_CONTROL_MASK;
45 : :
46 [ + + ]: 4 : if (json_object_get_boolean_member_with_default (body, "shift", FALSE))
47 : 1 : mask |= KEYMOD_SHIFT_MASK;
48 : :
49 [ + + ]: 4 : if (json_object_get_boolean_member_with_default (body, "super", FALSE))
50 : 1 : mask |= KEYMOD_SUPER_MASK;
51 : :
52 : 4 : return mask;
53 : : }
54 : :
55 : : static inline void
56 : 2 : keyboard_mask (ValentInput *input,
57 : : unsigned int mask,
58 : : gboolean lock)
59 : : {
60 [ + - ]: 2 : if (mask & KEYMOD_ALT_MASK)
61 : 2 : valent_input_keyboard_keysym (input, KEYSYM_Alt_L, lock);
62 : :
63 [ + - ]: 2 : if (mask & KEYMOD_CONTROL_MASK)
64 : 2 : valent_input_keyboard_keysym (input, KEYSYM_Control_L, lock);
65 : :
66 [ + - ]: 2 : if (mask & KEYMOD_SHIFT_MASK)
67 : 2 : valent_input_keyboard_keysym (input, KEYSYM_Shift_L, lock);
68 : :
69 [ + - ]: 2 : if (mask & KEYMOD_SUPER_MASK)
70 : 2 : valent_input_keyboard_keysym (input, KEYSYM_Super_L, lock);
71 : 2 : }
72 : :
73 : : /*
74 : : * Packet Handlers
75 : : */
76 : : static void
77 : 12 : valent_mousepad_plugin_handle_mousepad_request (ValentMousepadPlugin *self,
78 : : JsonNode *packet)
79 : : {
80 : 12 : JsonObject *body;
81 : 12 : const char *key;
82 : 12 : int64_t keycode;
83 : :
84 [ + - ]: 12 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
85 [ - + ]: 12 : g_assert (VALENT_IS_PACKET (packet));
86 : :
87 : 12 : body = valent_packet_get_body (packet);
88 : :
89 : : /* Pointer movement */
90 [ + + - + ]: 12 : if (json_object_has_member (body, "dx") || json_object_has_member (body, "dy"))
91 : : {
92 : 2 : double dx, dy;
93 : :
94 : 2 : dx = json_object_get_double_member_with_default (body, "dx", 0.0);
95 : 2 : dy = json_object_get_double_member_with_default (body, "dy", 0.0);
96 : :
97 [ + + ]: 2 : if (valent_packet_check_field (packet, "scroll"))
98 : 1 : valent_input_pointer_axis (self->input, dx, dy);
99 : : else
100 : 1 : valent_input_pointer_motion (self->input, dx, dy);
101 : : }
102 : :
103 : : /* Keyboard Event */
104 [ + + ]: 10 : else if (valent_packet_get_string (packet, "key", &key))
105 : : {
106 : 3 : KeyModifierType mask;
107 : 3 : const char *next;
108 : 3 : gunichar codepoint;
109 : :
110 : : /* Lock modifiers */
111 [ + + ]: 3 : if ((mask = event_to_mask (body)) != 0)
112 : 1 : keyboard_mask (self->input, mask, TRUE);
113 : :
114 : : /* Input each keysym */
115 : 3 : next = key;
116 : :
117 [ + + ]: 9 : while ((codepoint = g_utf8_get_char (next)) != 0)
118 : : {
119 : 6 : uint32_t keysym;
120 : :
121 : 6 : keysym = valent_input_unicode_to_keysym (codepoint);
122 : 6 : valent_input_keyboard_keysym (self->input, keysym, TRUE);
123 : 6 : valent_input_keyboard_keysym (self->input, keysym, FALSE);
124 : :
125 : 6 : next = g_utf8_next_char (next);
126 : : }
127 : :
128 : : /* Unlock modifiers */
129 [ + + ]: 3 : if (mask != 0)
130 : 1 : keyboard_mask (self->input, mask, FALSE);
131 : :
132 : : /* Send ack, if requested */
133 [ - + ]: 3 : if (valent_packet_check_field (packet, "sendAck"))
134 : 0 : valent_mousepad_plugin_send_echo (self, packet);
135 : : }
136 [ + + ]: 7 : else if (valent_packet_get_int (packet, "specialKey", &keycode))
137 : : {
138 : 1 : KeyModifierType mask;
139 : 1 : uint32_t keysym;
140 : :
141 [ - + ]: 1 : if ((keysym = valent_mousepad_keycode_to_keysym (keycode)) == 0)
142 : : {
143 : 0 : g_debug ("%s(): expected \"specialKey\" field holding a keycode",
144 : : G_STRFUNC);
145 : 0 : return;
146 : : }
147 : :
148 : : /* Lock modifiers */
149 [ - + ]: 1 : if ((mask = event_to_mask (body)) != 0)
150 : 0 : keyboard_mask (self->input, mask, TRUE);
151 : :
152 : : /* Input each keysym */
153 : 1 : valent_input_keyboard_keysym (self->input, keysym, TRUE);
154 : 1 : valent_input_keyboard_keysym (self->input, keysym, FALSE);
155 : :
156 : : /* Unlock modifiers */
157 [ - + ]: 1 : if (mask != 0)
158 : 0 : keyboard_mask (self->input, mask, FALSE);
159 : :
160 : : /* Send ack, if requested */
161 [ - + ]: 1 : if (valent_packet_check_field (packet, "sendAck"))
162 : 0 : valent_mousepad_plugin_send_echo (self, packet);
163 : : }
164 : :
165 [ + + ]: 6 : else if (valent_packet_check_field (packet, "singleclick"))
166 : : {
167 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, TRUE);
168 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, FALSE);
169 : : }
170 : :
171 [ + + ]: 5 : else if (valent_packet_check_field (packet, "doubleclick"))
172 : : {
173 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, TRUE);
174 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, FALSE);
175 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, TRUE);
176 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, FALSE);
177 : : }
178 : :
179 [ + + ]: 4 : else if (valent_packet_check_field (packet, "middleclick"))
180 : : {
181 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_MIDDLE, TRUE);
182 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_MIDDLE, FALSE);
183 : : }
184 : :
185 [ + + ]: 3 : else if (valent_packet_check_field (packet, "rightclick"))
186 : : {
187 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_SECONDARY, TRUE);
188 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_SECONDARY, FALSE);
189 : : }
190 : :
191 [ + + ]: 2 : else if (valent_packet_check_field (packet, "singlehold"))
192 : : {
193 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, TRUE);
194 : : }
195 : :
196 : : /* Not used by kdeconnect-android, hold is released with a regular click */
197 [ + - ]: 1 : else if (valent_packet_check_field (packet, "singlerelease"))
198 : : {
199 : 1 : valent_input_pointer_button (self->input, VALENT_POINTER_PRIMARY, FALSE);
200 : : }
201 : :
202 : : else
203 : : {
204 : 0 : g_debug ("%s: unknown input", G_STRFUNC);
205 : : }
206 : : }
207 : :
208 : : static void
209 : 1 : valent_mousepad_plugin_handle_mousepad_echo (ValentMousepadPlugin *self,
210 : : JsonNode *packet)
211 : : {
212 [ + - ]: 1 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
213 [ - + ]: 1 : g_assert (VALENT_IS_PACKET (packet));
214 : :
215 : 1 : VALENT_NOTE ("Not implemented");
216 : 1 : }
217 : :
218 : : static void
219 : 2 : valent_mousepad_plugin_handle_mousepad_keyboardstate (ValentMousepadPlugin *self,
220 : : JsonNode *packet)
221 : : {
222 : 2 : gboolean state;
223 : :
224 [ + - ]: 2 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
225 [ - + ]: 2 : g_assert (VALENT_IS_PACKET (packet));
226 : :
227 : : /* Update the remote keyboard state */
228 [ - + ]: 2 : if (!valent_packet_get_boolean (packet, "state", &state))
229 : : {
230 : 0 : g_debug ("%s(): expected \"state\" field holding a boolean",
231 : : G_STRFUNC);
232 : 0 : return;
233 : : }
234 : :
235 [ + - ]: 2 : if (self->remote_state != state)
236 : : {
237 : 2 : GAction *action;
238 : :
239 : 2 : self->remote_state = state;
240 : 2 : action = g_action_map_lookup_action (G_ACTION_MAP (self), "event");
241 : 2 : g_simple_action_set_enabled (G_SIMPLE_ACTION (action), self->remote_state);
242 : :
243 [ + - + - ]: 2 : if (self->remote_state && self->adapter == NULL)
244 : 2 : {
245 : 2 : ValentDevice *device = NULL;
246 : :
247 : 2 : device = valent_resource_get_source (VALENT_RESOURCE (self));
248 : 2 : self->adapter = valent_mousepad_device_new (device);
249 : 2 : valent_component_export_adapter (VALENT_COMPONENT (self->input),
250 : : VALENT_EXTENSION (self->adapter));
251 : : }
252 [ # # # # ]: 0 : else if (!self->remote_state && self->adapter != NULL)
253 : : {
254 : 0 : valent_component_unexport_adapter (VALENT_COMPONENT (self->input),
255 : : VALENT_EXTENSION (self->adapter));
256 [ - - ]: 2 : g_clear_object (&self->adapter);
257 : : }
258 : : }
259 : : }
260 : :
261 : : /*
262 : : * Packet Providers
263 : : */
264 : : static void
265 : 3 : valent_mousepad_plugin_mousepad_request_keyboard (ValentMousepadPlugin *self,
266 : : uint32_t keysym,
267 : : KeyModifierType mask)
268 : : {
269 : 3 : g_autoptr (JsonBuilder) builder = NULL;
270 [ - - - + ]: 3 : g_autoptr (JsonNode) packet = NULL;
271 : 3 : uint32_t special_key = 0;
272 : :
273 [ + - ]: 3 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
274 : :
275 : 3 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
276 : :
277 [ + + ]: 3 : if ((special_key = valent_mousepad_keysym_to_keycode (keysym)) != 0)
278 : : {
279 : 1 : json_builder_set_member_name (builder, "specialKey");
280 : 1 : json_builder_add_int_value (builder, special_key);
281 : : }
282 : : else
283 : : {
284 [ - - ]: 2 : g_autoptr (GError) error = NULL;
285 [ - - - + ]: 2 : g_autofree char *key = NULL;
286 : 2 : gunichar wc;
287 : :
288 : 2 : wc = valent_input_keysym_to_unicode (keysym);
289 : 2 : key = g_ucs4_to_utf8 (&wc, 1, NULL, NULL, &error);
290 : :
291 [ - + ]: 2 : if (key == NULL)
292 : : {
293 : 0 : g_warning ("Converting %u to string: %s", keysym, error->message);
294 : 0 : return;
295 : : }
296 : :
297 : 2 : json_builder_set_member_name (builder, "key");
298 : 2 : json_builder_add_string_value (builder, key);
299 : : }
300 : :
301 [ + + ]: 3 : if (mask & KEYMOD_ALT_MASK)
302 : : {
303 : 1 : json_builder_set_member_name (builder, "alt");
304 : 1 : json_builder_add_boolean_value (builder, TRUE);
305 : : }
306 : :
307 [ + + ]: 3 : if (mask & KEYMOD_CONTROL_MASK)
308 : : {
309 : 1 : json_builder_set_member_name (builder, "ctrl");
310 : 1 : json_builder_add_boolean_value (builder, TRUE);
311 : : }
312 : :
313 [ + + ]: 3 : if (mask & KEYMOD_SHIFT_MASK)
314 : : {
315 : 1 : json_builder_set_member_name (builder, "shift");
316 : 1 : json_builder_add_boolean_value (builder, TRUE);
317 : : }
318 : :
319 [ + + ]: 3 : if (mask & KEYMOD_SUPER_MASK)
320 : : {
321 : 1 : json_builder_set_member_name (builder, "super");
322 : 1 : json_builder_add_boolean_value (builder, TRUE);
323 : : }
324 : :
325 : 3 : packet = valent_packet_end (&builder);
326 : :
327 [ + - ]: 3 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
328 : : }
329 : :
330 : : static void
331 : 2 : valent_mousepad_plugin_mousepad_request_pointer (ValentMousepadPlugin *self,
332 : : double dx,
333 : : double dy,
334 : : gboolean axis)
335 : : {
336 : 4 : g_autoptr (JsonBuilder) builder = NULL;
337 [ - + ]: 2 : g_autoptr (JsonNode) packet = NULL;
338 : :
339 [ + - ]: 2 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
340 : :
341 : 2 : valent_packet_init (&builder, "kdeconnect.mousepad.request");
342 : :
343 : 2 : json_builder_set_member_name (builder, "dx");
344 : 2 : json_builder_add_double_value (builder, dx);
345 : 2 : json_builder_set_member_name (builder, "dy");
346 : 2 : json_builder_add_double_value (builder, dy);
347 : :
348 [ + + ]: 2 : if (axis)
349 : : {
350 : 1 : json_builder_set_member_name (builder, "scroll");
351 : 1 : json_builder_add_boolean_value (builder, TRUE);
352 : : }
353 : :
354 : 2 : packet = valent_packet_end (&builder);
355 : :
356 [ + - ]: 2 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
357 : 2 : }
358 : :
359 : : static void
360 : 0 : valent_mousepad_plugin_send_echo (ValentMousepadPlugin *self,
361 : : JsonNode *packet)
362 : : {
363 : 0 : g_autoptr (JsonBuilder) builder = NULL;
364 [ # # ]: 0 : g_autoptr (JsonNode) response = NULL;
365 : 0 : JsonObjectIter iter;
366 : 0 : const char *name;
367 : 0 : JsonNode *node;
368 : :
369 [ # # ]: 0 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
370 : :
371 : 0 : valent_packet_init (&builder, "kdeconnect.mousepad.echo");
372 : :
373 : 0 : json_object_iter_init (&iter, valent_packet_get_body (packet));
374 : :
375 [ # # ]: 0 : while (json_object_iter_next (&iter, &name, &node))
376 : : {
377 [ # # ]: 0 : if (g_strcmp0 (name, "sendAck") == 0)
378 : 0 : continue;
379 : :
380 : 0 : json_builder_set_member_name (builder, name);
381 : 0 : json_builder_add_value (builder, json_node_ref (node));
382 : : }
383 : :
384 : 0 : json_builder_set_member_name (builder, "isAck");
385 : 0 : json_builder_add_boolean_value (builder, TRUE);
386 : :
387 : 0 : response = valent_packet_end (&builder);
388 : :
389 [ # # ]: 0 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), response);
390 : 0 : }
391 : :
392 : : static void
393 : 5 : valent_mousepad_plugin_mousepad_keyboardstate (ValentMousepadPlugin *self)
394 : : {
395 : 5 : g_autoptr (JsonBuilder) builder = NULL;
396 [ - - - + ]: 5 : g_autoptr (JsonNode) packet = NULL;
397 : :
398 [ + - - - ]: 5 : g_return_if_fail (VALENT_IS_MOUSEPAD_PLUGIN (self));
399 : :
400 : 5 : valent_packet_init (&builder, "kdeconnect.mousepad.keyboardstate");
401 : 5 : json_builder_set_member_name (builder, "state");
402 : 5 : json_builder_add_boolean_value (builder, TRUE);
403 : 5 : packet = valent_packet_end (&builder);
404 : :
405 [ + - ]: 5 : valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
406 : : }
407 : :
408 : : /*
409 : : * GActions
410 : : */
411 : : static void
412 : 16 : valent_mousepad_plugin_toggle_actions (ValentMousepadPlugin *self,
413 : : gboolean available)
414 : : {
415 : 16 : GAction *action;
416 : :
417 [ + - ]: 16 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
418 : :
419 : 16 : action = g_action_map_lookup_action (G_ACTION_MAP (self), "event");
420 [ + + ]: 32 : g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
421 [ + - ]: 5 : available && self->remote_state);
422 : 16 : }
423 : :
424 : : static void
425 : 5 : mousepad_event_action (GSimpleAction *action,
426 : : GVariant *parameter,
427 : : gpointer user_data)
428 : : {
429 : 5 : ValentMousepadPlugin *self = VALENT_MOUSEPAD_PLUGIN (user_data);
430 : 5 : GVariantDict dict;
431 : 5 : double dx, dy;
432 : 5 : uint32_t keysym;
433 : :
434 [ + - ]: 5 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
435 [ - + ]: 5 : g_return_if_fail (self->remote_state);
436 : :
437 : 5 : g_variant_dict_init (&dict, parameter);
438 : :
439 [ + + + - ]: 7 : if (g_variant_dict_lookup (&dict, "dx", "d", &dx) &&
440 : 2 : g_variant_dict_lookup (&dict, "dy", "d", &dy))
441 : 2 : {
442 : 2 : gboolean scroll = FALSE;
443 : :
444 : 2 : g_variant_dict_lookup (&dict, "scroll", "b", &scroll);
445 : 2 : valent_mousepad_plugin_mousepad_request_pointer (self, dx, dy, scroll);
446 : : }
447 [ + - ]: 3 : else if (g_variant_dict_lookup (&dict, "keysym", "u", &keysym))
448 : : {
449 : 3 : KeyModifierType mask = 0;
450 : :
451 : 3 : g_variant_dict_lookup (&dict, "mask", "u", &mask);
452 : 3 : valent_mousepad_plugin_mousepad_request_keyboard (self, keysym, mask);
453 : : }
454 : : else
455 : 0 : g_warning ("%s(): unknown event type", G_STRFUNC);
456 : :
457 : 5 : g_variant_dict_clear (&dict);
458 : : }
459 : :
460 : : static const GActionEntry actions[] = {
461 : : {"event", mousepad_event_action, "a{sv}", NULL, NULL}
462 : : };
463 : :
464 : : /*
465 : : * ValentDevicePlugin
466 : : */
467 : : static void
468 : 16 : valent_mousepad_plugin_update_state (ValentDevicePlugin *plugin,
469 : : ValentDeviceState state)
470 : : {
471 : 16 : ValentMousepadPlugin *self = VALENT_MOUSEPAD_PLUGIN (plugin);
472 : 16 : gboolean available;
473 : :
474 [ + - ]: 16 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
475 : :
476 : 16 : available = (state & VALENT_DEVICE_STATE_CONNECTED) != 0 &&
477 : : (state & VALENT_DEVICE_STATE_PAIRED) != 0;
478 : :
479 [ + + ]: 16 : if (available)
480 : 5 : valent_mousepad_plugin_mousepad_keyboardstate (self);
481 : : else
482 : 11 : self->remote_state = FALSE;
483 : :
484 [ + - + + ]: 16 : if (!self->remote_state && self->adapter != NULL)
485 : : {
486 : 2 : valent_component_unexport_adapter (VALENT_COMPONENT (self->input),
487 : : VALENT_EXTENSION (self->adapter));
488 [ + - ]: 2 : g_clear_object (&self->adapter);
489 : : }
490 : :
491 : 16 : valent_mousepad_plugin_toggle_actions (self, available);
492 : 16 : }
493 : :
494 : : static void
495 : 15 : valent_mousepad_plugin_handle_packet (ValentDevicePlugin *plugin,
496 : : const char *type,
497 : : JsonNode *packet)
498 : : {
499 : 15 : ValentMousepadPlugin *self = VALENT_MOUSEPAD_PLUGIN (plugin);
500 : :
501 [ + - ]: 15 : g_assert (VALENT_IS_MOUSEPAD_PLUGIN (self));
502 [ - + ]: 15 : g_assert (type != NULL);
503 [ - + ]: 15 : g_assert (VALENT_IS_PACKET (packet));
504 : :
505 : : /* A request to simulate input */
506 [ + + ]: 15 : if (g_str_equal (type, "kdeconnect.mousepad.request"))
507 : 12 : valent_mousepad_plugin_handle_mousepad_request (self, packet);
508 : :
509 : : /* A confirmation of input we requested */
510 [ + + ]: 3 : else if (g_str_equal (type, "kdeconnect.mousepad.echo"))
511 : 1 : valent_mousepad_plugin_handle_mousepad_echo (self, packet);
512 : :
513 : : /* The remote keyboard is ready/not ready for input */
514 [ + - ]: 2 : else if (g_str_equal (type, "kdeconnect.mousepad.keyboardstate"))
515 : 2 : valent_mousepad_plugin_handle_mousepad_keyboardstate (self, packet);
516 : :
517 : : else
518 : 0 : g_assert_not_reached ();
519 : 15 : }
520 : :
521 : : /*
522 : : * ValentObject
523 : : */
524 : : static void
525 : 10 : valent_mousepad_plugin_destroy (ValentObject *object)
526 : : {
527 : 10 : ValentMousepadPlugin *self = VALENT_MOUSEPAD_PLUGIN (object);
528 : 10 : ValentComponent *component = NULL;
529 : :
530 [ - + ]: 10 : if (self->adapter != NULL)
531 : : {
532 : 0 : component = VALENT_COMPONENT (valent_input_get_default ());
533 : 0 : valent_component_unexport_adapter (component, VALENT_EXTENSION (self->adapter));
534 : 0 : valent_object_destroy (VALENT_OBJECT (self->adapter));
535 [ # # ]: 0 : g_clear_object (&self->adapter);
536 : : }
537 : :
538 : 10 : VALENT_OBJECT_CLASS (valent_mousepad_plugin_parent_class)->destroy (object);
539 : 10 : }
540 : :
541 : : /*
542 : : * GObject
543 : : */
544 : : static void
545 : 5 : valent_mousepad_plugin_constructed (GObject *object)
546 : : {
547 : 5 : ValentDevicePlugin *plugin = VALENT_DEVICE_PLUGIN (object);
548 : :
549 : 5 : g_action_map_add_action_entries (G_ACTION_MAP (plugin),
550 : : actions,
551 : : G_N_ELEMENTS (actions),
552 : : plugin);
553 : :
554 : 5 : G_OBJECT_CLASS (valent_mousepad_plugin_parent_class)->constructed (object);
555 : 5 : }
556 : :
557 : : static void
558 : 1 : valent_mousepad_plugin_class_init (ValentMousepadPluginClass *klass)
559 : : {
560 : 1 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
561 : 1 : ValentObjectClass *vobject_class = VALENT_OBJECT_CLASS (klass);
562 : 1 : ValentDevicePluginClass *plugin_class = VALENT_DEVICE_PLUGIN_CLASS (klass);
563 : :
564 : 1 : object_class->constructed = valent_mousepad_plugin_constructed;
565 : :
566 : 1 : vobject_class->destroy = valent_mousepad_plugin_destroy;
567 : :
568 : 1 : plugin_class->handle_packet = valent_mousepad_plugin_handle_packet;
569 : 1 : plugin_class->update_state = valent_mousepad_plugin_update_state;
570 : : }
571 : :
572 : : static void
573 : 5 : valent_mousepad_plugin_init (ValentMousepadPlugin *self)
574 : : {
575 : 5 : self->input = valent_input_get_default ();
576 : 5 : }
577 : :
|
