1 /*
2 * Clutter.
3 *
4 * An OpenGL based 'interactive canvas' library.
5 *
6 * Copyright (C) 2009 Intel Corp.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
20 *
21 * Author: Emmanuele Bassi <ebassi@linux.intel.com>
22 */
23
24 /**
25 * SECTION:clutter-device-manager
26 * @short_description: Maintains the list of input devices
27 *
28 * #ClutterDeviceManager is a singleton object, owned by Clutter, which
29 * maintains the list of #ClutterInputDevice<!-- -->s.
30 *
31 * Depending on the backend used by Clutter it is possible to use the
32 * #ClutterDeviceManager::device-added and
33 * #ClutterDeviceManager::device-removed to monitor addition and removal
34 * of devices.
35 *
36 * #ClutterDeviceManager is available since Clutter 1.2
37 */
38
39 #ifdef HAVE_CONFIG_H
40 #include "clutter-build-config.h"
41 #endif
42
43 #include "clutter-backend-private.h"
44 #include "clutter-debug.h"
45 #include "clutter-device-manager-private.h"
46 #include "clutter-enum-types.h"
47 #include "clutter-marshal.h"
48 #include "clutter-private.h"
49 #include "clutter-stage-private.h"
50 #include "clutter-virtual-input-device.h"
51 #include "clutter-input-device-tool.h"
52
53 struct _ClutterDeviceManagerPrivate
54 {
55 /* back-pointer to the backend */
56 ClutterBackend *backend;
57
58 /* Keyboard a11y */
59 ClutterKbdA11ySettings kbd_a11y_settings;
60 };
61
62 enum
63 {
64 PROP_0,
65
66 PROP_BACKEND,
67
68 PROP_LAST
69 };
70
71 static GParamSpec *obj_props[PROP_LAST];
72
73 enum
74 {
75 DEVICE_ADDED,
76 DEVICE_REMOVED,
77 TOOL_CHANGED,
78 KBD_A11Y_MASK_CHANGED,
79 KBD_A11Y_FLAGS_CHANGED,
80
81 LAST_SIGNAL
82 };
83
84 static guint manager_signals[LAST_SIGNAL] = { 0, };
85
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(ClutterDeviceManager,clutter_device_manager,G_TYPE_OBJECT)86 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterDeviceManager,
87 clutter_device_manager,
88 G_TYPE_OBJECT)
89
90 G_DEFINE_INTERFACE (ClutterEventExtender,
91 clutter_event_extender,
92 CLUTTER_TYPE_DEVICE_MANAGER)
93
94 static void
95 clutter_event_extender_default_init (ClutterEventExtenderInterface *iface)
96 {
97 }
98
99 static void
clutter_device_manager_set_property(GObject * gobject,guint prop_id,const GValue * value,GParamSpec * pspec)100 clutter_device_manager_set_property (GObject *gobject,
101 guint prop_id,
102 const GValue *value,
103 GParamSpec *pspec)
104 {
105 ClutterDeviceManagerPrivate *priv = CLUTTER_DEVICE_MANAGER (gobject)->priv;
106
107 switch (prop_id)
108 {
109 case PROP_BACKEND:
110 priv->backend = g_value_get_object (value);
111 break;
112
113 default:
114 G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
115 }
116 }
117
118 static void
clutter_device_manager_get_property(GObject * gobject,guint prop_id,GValue * value,GParamSpec * pspec)119 clutter_device_manager_get_property (GObject *gobject,
120 guint prop_id,
121 GValue *value,
122 GParamSpec *pspec)
123 {
124 ClutterDeviceManagerPrivate *priv = CLUTTER_DEVICE_MANAGER (gobject)->priv;
125
126 switch (prop_id)
127 {
128 case PROP_BACKEND:
129 g_value_set_object (value, priv->backend);
130 break;
131
132 default:
133 G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
134 }
135 }
136
137 static void
clutter_device_manager_class_init(ClutterDeviceManagerClass * klass)138 clutter_device_manager_class_init (ClutterDeviceManagerClass *klass)
139 {
140 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
141
142 obj_props[PROP_BACKEND] =
143 g_param_spec_object ("backend",
144 P_("Backend"),
145 P_("The ClutterBackend of the device manager"),
146 CLUTTER_TYPE_BACKEND,
147 CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
148
149 gobject_class->set_property = clutter_device_manager_set_property;
150 gobject_class->get_property = clutter_device_manager_get_property;
151 g_object_class_install_properties (gobject_class,
152 PROP_LAST,
153 obj_props);
154
155 /**
156 * ClutterDeviceManager::device-added:
157 * @manager: the #ClutterDeviceManager that emitted the signal
158 * @device: the newly added #ClutterInputDevice
159 *
160 * The ::device-added signal is emitted each time a device has been
161 * added to the #ClutterDeviceManager
162 *
163 * Since: 1.2
164 */
165 manager_signals[DEVICE_ADDED] =
166 g_signal_new (I_("device-added"),
167 G_TYPE_FROM_CLASS (klass),
168 G_SIGNAL_RUN_LAST,
169 0,
170 NULL, NULL,
171 _clutter_marshal_VOID__OBJECT,
172 G_TYPE_NONE, 1,
173 CLUTTER_TYPE_INPUT_DEVICE);
174
175 /**
176 * ClutterDeviceManager::device-removed:
177 * @manager: the #ClutterDeviceManager that emitted the signal
178 * @device: the removed #ClutterInputDevice
179 *
180 * The ::device-removed signal is emitted each time a device has been
181 * removed from the #ClutterDeviceManager
182 *
183 * Since: 1.2
184 */
185 manager_signals[DEVICE_REMOVED] =
186 g_signal_new (I_("device-removed"),
187 G_TYPE_FROM_CLASS (klass),
188 G_SIGNAL_RUN_LAST,
189 0,
190 NULL, NULL,
191 _clutter_marshal_VOID__OBJECT,
192 G_TYPE_NONE, 1,
193 CLUTTER_TYPE_INPUT_DEVICE);
194
195 manager_signals[TOOL_CHANGED] =
196 g_signal_new (I_("tool-changed"),
197 G_TYPE_FROM_CLASS (klass),
198 G_SIGNAL_RUN_LAST,
199 0, NULL, NULL,
200 _clutter_marshal_VOID__OBJECT_OBJECT,
201 G_TYPE_NONE, 2,
202 CLUTTER_TYPE_INPUT_DEVICE,
203 CLUTTER_TYPE_INPUT_DEVICE_TOOL);
204
205 /**
206 * ClutterDeviceManager::kbd-a11y-mods-state-changed:
207 * @manager: the #ClutterDeviceManager that emitted the signal
208 * @latched_mask: the latched modifier mask from stickykeys
209 * @locked_mask: the locked modifier mask from stickykeys
210 *
211 * The ::kbd-a11y-mods-state-changed signal is emitted each time either the
212 * latched modifiers mask or locked modifiers mask are changed as the
213 * result of keyboard accessibilty's sticky keys operations.
214 */
215 manager_signals[KBD_A11Y_MASK_CHANGED] =
216 g_signal_new (I_("kbd-a11y-mods-state-changed"),
217 G_TYPE_FROM_CLASS (klass),
218 G_SIGNAL_RUN_LAST,
219 0, NULL, NULL,
220 _clutter_marshal_VOID__UINT_UINT,
221 G_TYPE_NONE, 2,
222 G_TYPE_UINT,
223 G_TYPE_UINT);
224
225 /**
226 * ClutterDeviceManager::kbd-a11y-flags-changed:
227 * @manager: the #ClutterDeviceManager that emitted the signal
228 * @settings_flags: the new ClutterKeyboardA11yFlags configuration
229 * @changed_mask: the ClutterKeyboardA11yFlags changed
230 *
231 * The ::kbd-a11y-flags-changed signal is emitted each time the
232 * ClutterKeyboardA11yFlags configuration is changed as the result of
233 * keyboard accessibilty operations.
234 */
235 manager_signals[KBD_A11Y_FLAGS_CHANGED] =
236 g_signal_new (I_("kbd-a11y-flags-changed"),
237 G_TYPE_FROM_CLASS (klass),
238 G_SIGNAL_RUN_LAST,
239 0, NULL, NULL,
240 _clutter_marshal_VOID__UINT_UINT,
241 G_TYPE_NONE, 2,
242 G_TYPE_UINT,
243 G_TYPE_UINT);
244 }
245
246 static void
clutter_device_manager_init(ClutterDeviceManager * self)247 clutter_device_manager_init (ClutterDeviceManager *self)
248 {
249 self->priv = clutter_device_manager_get_instance_private (self);
250 }
251
252 /**
253 * clutter_device_manager_get_default:
254 *
255 * Retrieves the device manager singleton
256 *
257 * Return value: (transfer none): the #ClutterDeviceManager singleton.
258 * The returned instance is owned by Clutter and it should not be
259 * modified or freed
260 *
261 * Since: 1.2
262 */
263 ClutterDeviceManager *
clutter_device_manager_get_default(void)264 clutter_device_manager_get_default (void)
265 {
266 ClutterBackend *backend = clutter_get_default_backend ();
267
268 return backend->device_manager;
269 }
270
271 /**
272 * clutter_device_manager_list_devices:
273 * @device_manager: a #ClutterDeviceManager
274 *
275 * Lists all currently registered input devices
276 *
277 * Return value: (transfer container) (element-type Clutter.InputDevice):
278 * a newly allocated list of #ClutterInputDevice objects. Use
279 * g_slist_free() to deallocate it when done
280 *
281 * Since: 1.2
282 */
283 GSList *
clutter_device_manager_list_devices(ClutterDeviceManager * device_manager)284 clutter_device_manager_list_devices (ClutterDeviceManager *device_manager)
285 {
286 const GSList *devices;
287
288 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
289
290 devices = clutter_device_manager_peek_devices (device_manager);
291
292 return g_slist_copy ((GSList *) devices);
293 }
294
295 /**
296 * clutter_device_manager_peek_devices:
297 * @device_manager: a #ClutterDeviceManager
298 *
299 * Lists all currently registered input devices
300 *
301 * Return value: (transfer none) (element-type Clutter.InputDevice):
302 * a pointer to the internal list of #ClutterInputDevice objects. The
303 * returned list is owned by the #ClutterDeviceManager and should never
304 * be modified or freed
305 *
306 * Since: 1.2
307 */
308 const GSList *
clutter_device_manager_peek_devices(ClutterDeviceManager * device_manager)309 clutter_device_manager_peek_devices (ClutterDeviceManager *device_manager)
310 {
311 ClutterDeviceManagerClass *manager_class;
312
313 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
314
315 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
316 return manager_class->get_devices (device_manager);
317 }
318
319 /**
320 * clutter_device_manager_get_device:
321 * @device_manager: a #ClutterDeviceManager
322 * @device_id: the integer id of a device
323 *
324 * Retrieves the #ClutterInputDevice with the given @device_id
325 *
326 * Return value: (transfer none): a #ClutterInputDevice or %NULL. The
327 * returned device is owned by the #ClutterDeviceManager and should
328 * never be modified or freed
329 *
330 * Since: 1.2
331 */
332 ClutterInputDevice *
clutter_device_manager_get_device(ClutterDeviceManager * device_manager,gint device_id)333 clutter_device_manager_get_device (ClutterDeviceManager *device_manager,
334 gint device_id)
335 {
336 ClutterDeviceManagerClass *manager_class;
337
338 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
339
340 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
341 return manager_class->get_device (device_manager, device_id);
342 }
343
344 /**
345 * clutter_device_manager_get_core_device:
346 * @device_manager: a #ClutterDeviceManager
347 * @device_type: the type of the core device
348 *
349 * Retrieves the core #ClutterInputDevice of type @device_type
350 *
351 * Core devices are devices created automatically by the default
352 * Clutter backend
353 *
354 * Return value: (transfer none): a #ClutterInputDevice or %NULL. The
355 * returned device is owned by the #ClutterDeviceManager and should
356 * not be modified or freed
357 *
358 * Since: 1.2
359 */
360 ClutterInputDevice *
clutter_device_manager_get_core_device(ClutterDeviceManager * device_manager,ClutterInputDeviceType device_type)361 clutter_device_manager_get_core_device (ClutterDeviceManager *device_manager,
362 ClutterInputDeviceType device_type)
363 {
364 ClutterDeviceManagerClass *manager_class;
365
366 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
367
368 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
369 return manager_class->get_core_device (device_manager, device_type);
370 }
371
372 void
_clutter_device_manager_select_stage_events(ClutterDeviceManager * device_manager,ClutterStage * stage)373 _clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manager,
374 ClutterStage *stage)
375 {
376 ClutterDeviceManagerClass *manager_class;
377
378 g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
379
380 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
381 if (manager_class->select_stage_events)
382 manager_class->select_stage_events (device_manager, stage);
383 }
384
385 /*
386 * _clutter_device_manager_add_device:
387 * @device_manager: a #ClutterDeviceManager
388 * @device: a #ClutterInputDevice
389 *
390 * Adds @device to the list of #ClutterInputDevice<!-- -->s maintained
391 * by @device_manager
392 *
393 * The reference count of @device is not increased
394 *
395 * The #ClutterDeviceManager::device-added signal is emitted after
396 * adding @device to the list
397 */
398 void
_clutter_device_manager_add_device(ClutterDeviceManager * device_manager,ClutterInputDevice * device)399 _clutter_device_manager_add_device (ClutterDeviceManager *device_manager,
400 ClutterInputDevice *device)
401 {
402 ClutterDeviceManagerClass *manager_class;
403
404 g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
405
406 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
407 g_assert (manager_class->add_device != NULL);
408
409 manager_class->add_device (device_manager, device);
410
411 g_signal_emit (device_manager, manager_signals[DEVICE_ADDED], 0, device);
412 }
413
414 /*
415 * _clutter_device_manager_remove_device:
416 * @device_manager: a #ClutterDeviceManager
417 * @device: a #ClutterInputDevice
418 *
419 * Removes @device from the list of #ClutterInputDevice<!-- -->s
420 * maintained by @device_manager
421 *
422 * The reference count of @device is not decreased
423 *
424 * The #ClutterDeviceManager::device-removed signal is emitted after
425 * removing @device from the list
426 */
427 void
_clutter_device_manager_remove_device(ClutterDeviceManager * device_manager,ClutterInputDevice * device)428 _clutter_device_manager_remove_device (ClutterDeviceManager *device_manager,
429 ClutterInputDevice *device)
430 {
431 ClutterDeviceManagerClass *manager_class;
432
433 g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
434
435 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
436 g_assert (manager_class->remove_device != NULL);
437
438 /* The subclass remove_device() method will likely unref it but we
439 have to keep it alive during the signal emission. */
440 g_object_ref (device);
441
442 manager_class->remove_device (device_manager, device);
443 g_signal_emit (device_manager, manager_signals[DEVICE_REMOVED], 0, device);
444
445 g_object_unref (device);
446 }
447
448 /*
449 * _clutter_device_manager_update_devices:
450 * @device_manager: a #ClutterDeviceManager
451 *
452 * Updates every #ClutterInputDevice handled by @device_manager
453 * by performing a pick paint at the coordinates of each pointer
454 * device
455 */
456 void
_clutter_device_manager_update_devices(ClutterDeviceManager * device_manager)457 _clutter_device_manager_update_devices (ClutterDeviceManager *device_manager)
458 {
459 const GSList *d;
460
461 for (d = clutter_device_manager_peek_devices (device_manager);
462 d != NULL;
463 d = d->next)
464 {
465 ClutterInputDevice *device = d->data;
466 ClutterInputDeviceType device_type;
467
468 /* we only care about pointer devices */
469 device_type = clutter_input_device_get_device_type (device);
470 if (device_type != CLUTTER_POINTER_DEVICE)
471 continue;
472
473 /* out of stage */
474 if (device->stage == NULL)
475 continue;
476
477 /* the user disabled motion events delivery on actors for
478 * the stage the device is on; we don't perform any picking
479 * since the source of the events will always be set to be
480 * the stage
481 */
482 if (!clutter_stage_get_motion_events_enabled (device->stage))
483 continue;
484
485 _clutter_input_device_update (device, NULL, TRUE);
486 }
487 }
488
489 ClutterBackend *
_clutter_device_manager_get_backend(ClutterDeviceManager * manager)490 _clutter_device_manager_get_backend (ClutterDeviceManager *manager)
491 {
492 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (manager), NULL);
493
494 return manager->priv->backend;
495 }
496
497 /**
498 * clutter_device_manager_create_virtual_device:
499 * @device_manager: a #ClutterDeviceManager
500 * @device_type: the type of the virtual device
501 *
502 * Creates a virtual input device.
503 *
504 * Returns: (transfer full): a newly created virtual device
505 **/
506 ClutterVirtualInputDevice *
clutter_device_manager_create_virtual_device(ClutterDeviceManager * device_manager,ClutterInputDeviceType device_type)507 clutter_device_manager_create_virtual_device (ClutterDeviceManager *device_manager,
508 ClutterInputDeviceType device_type)
509 {
510 ClutterDeviceManagerClass *manager_class;
511
512 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager), NULL);
513
514 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
515 return manager_class->create_virtual_device (device_manager,
516 device_type);
517 }
518
519 /**
520 * clutter_device_manager_supported_virtua_device_types: (skip)
521 */
522 ClutterVirtualDeviceType
clutter_device_manager_get_supported_virtual_device_types(ClutterDeviceManager * device_manager)523 clutter_device_manager_get_supported_virtual_device_types (ClutterDeviceManager *device_manager)
524 {
525 ClutterDeviceManagerClass *manager_class;
526
527 g_return_val_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager),
528 CLUTTER_VIRTUAL_DEVICE_TYPE_NONE);
529
530 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
531 return manager_class->get_supported_virtual_device_types (device_manager);
532 }
533
534 void
_clutter_device_manager_compress_motion(ClutterDeviceManager * device_manager,ClutterEvent * event,const ClutterEvent * to_discard)535 _clutter_device_manager_compress_motion (ClutterDeviceManager *device_manager,
536 ClutterEvent *event,
537 const ClutterEvent *to_discard)
538 {
539 ClutterDeviceManagerClass *manager_class;
540
541 g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
542
543
544 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
545 if (!manager_class->compress_motion)
546 return;
547
548 manager_class->compress_motion (device_manager, event, to_discard);
549 }
550
551 static gboolean
are_kbd_a11y_settings_equal(ClutterKbdA11ySettings * a,ClutterKbdA11ySettings * b)552 are_kbd_a11y_settings_equal (ClutterKbdA11ySettings *a,
553 ClutterKbdA11ySettings *b)
554 {
555 return (a->controls == b->controls &&
556 a->slowkeys_delay == b->slowkeys_delay &&
557 a->debounce_delay == b->debounce_delay &&
558 a->timeout_delay == b->timeout_delay &&
559 a->mousekeys_init_delay == b->mousekeys_init_delay &&
560 a->mousekeys_max_speed == b->mousekeys_max_speed &&
561 a->mousekeys_accel_time == b->mousekeys_accel_time);
562 }
563
564 void
clutter_device_manager_set_kbd_a11y_settings(ClutterDeviceManager * device_manager,ClutterKbdA11ySettings * settings)565 clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager *device_manager,
566 ClutterKbdA11ySettings *settings)
567 {
568 ClutterDeviceManagerClass *manager_class;
569
570 g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
571
572 if (are_kbd_a11y_settings_equal (&device_manager->priv->kbd_a11y_settings, settings))
573 return;
574
575 device_manager->priv->kbd_a11y_settings = *settings;
576
577 manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager);
578 if (manager_class->apply_kbd_a11y_settings)
579 manager_class->apply_kbd_a11y_settings (device_manager, settings);
580 }
581
582 void
clutter_device_manager_get_kbd_a11y_settings(ClutterDeviceManager * device_manager,ClutterKbdA11ySettings * settings)583 clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager *device_manager,
584 ClutterKbdA11ySettings *settings)
585 {
586 g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager));
587
588 *settings = device_manager->priv->kbd_a11y_settings;
589 }
590