atspi/atspi-registry.c

   1
   2 /*
   3  * AT-SPI - Assistive Technology Service Provider Interface
   4  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   5  *
   6  * Copyright 2001, 2002 Sun Microsystems Inc.,
   7  * Copyright 2001, 2002 Ximian, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 /* atspi_registry.c: Global functions wrapping the registry */
  26
  27 #include "atspi-private.h"
  28
  29 typedef struct
  30 {
  31   AtspiDeviceListener *listener;
  32   GArray             *key_set;
  33   AtspiKeyMaskType         modmask;
  34   AtspiKeyEventMask        event_types;
  35   gint sync_type;
  36 } DeviceListenerEntry;
  37
  38 static GList *device_listeners;
  39
  40 /**
  41  * atspi_get_desktop_count:
  42  *
  43  * Gets the number of virtual desktops.
  44  * NOTE: multiple virtual desktops are not implemented yet; as a
  45  * consequence, this function always returns 1.
  46  *
  47  * Returns: a #gint indicating the number of active virtual desktops.
  48  **/
  49 gint
  50 atspi_get_desktop_count ()
  51 {
  52   return 1;
  53 }
  54
  55 /**
  56  * atspi_get_desktop:
  57  * @i: a #gint indicating which of the accessible desktops is to be returned.
  58  *
  59  * Gets the virtual desktop indicated by index @i.
  60  * NOTE: currently multiple virtual desktops are not implemented;
  61  * as a consequence, any @i value different from 0 will not return a
  62  * virtual desktop - instead it will return NULL.
  63  *
  64  * Returns: (transfer full): a pointer to the @i-th virtual desktop's
  65  * #AtspiAccessible representation.
  66  **/
  67 AtspiAccessible*
  68 atspi_get_desktop (gint i)
  69 {
  70   if (i != 0) return NULL;
  71   return _atspi_ref_accessible (atspi_bus_registry, atspi_path_root);
  72 }
  73
  74 /**
  75  * atspi_get_desktop_list:
  76  *
  77  * Gets the list of virtual desktops.  On return, @list will point
  78  *     to a newly-created, NULL terminated array of virtual desktop
  79  *     pointers.
  80  *     It is the responsibility of the caller to free this array when
  81  *     it is no longer needed.
  82  * NOTE: currently multiple virtual desktops are not implemented;
  83  * this implementation always returns a #Garray with a single
  84  * #AtspiAccessible desktop.
  85  *
  86  * Returns: (element-type AtspiAccessible*) (transfer full): a #GArray of
  87  * desktops.
  88  **/
  89 GArray *
  90 atspi_get_desktop_list ()
  91 {
  92   GArray *array = g_array_new (TRUE, TRUE, sizeof (AtspiAccessible *));
  93   AtspiAccessible *desktop;
  94
  95   desktop = _atspi_ref_accessible (atspi_bus_registry, atspi_path_root);
  96   if (array)
  97     g_array_index (array, AtspiAccessible *, 0) = desktop;
  98   return array;
  99 }
 100
 101 static gboolean
 102 notify_keystroke_listener (DeviceListenerEntry *e)
 103 {
 104   gchar *path = _atspi_device_listener_get_path (e->listener);
 105   dbus_uint32_t d_modmask = e->modmask;
 106   dbus_uint32_t d_event_types = e->event_types;
 107   AtspiEventListenerMode     listener_mode;
 108   gboolean                          retval = FALSE;
 109   DBusError d_error;
 110
 111   listener_mode.synchronous =
 112           (dbus_bool_t) ((e->sync_type & ATSPI_KEYLISTENER_SYNCHRONOUS)!=0);
 113   listener_mode.preemptive =
 114           (dbus_bool_t) ((e->sync_type & ATSPI_KEYLISTENER_CANCONSUME)!=0);
 115   listener_mode.global =
 116           (dbus_bool_t) ((e->sync_type & ATSPI_KEYLISTENER_ALL_WINDOWS)!=0);
 117
 118   dbus_error_init (&d_error);
 119   dbind_method_call_reentrant (_atspi_bus(), atspi_bus_registry,
 120                                atspi_path_dec, atspi_interface_dec,
 121                                "RegisterKeystrokeListener", &d_error,
 122                                "oa(iisi)uu(bbb)=>b", path, e->key_set,
 123                                d_modmask, d_event_types, &listener_mode,
 124                                &retval);
 125   if (dbus_error_is_set (&d_error))
 126     {
 127       g_warning ("RegisterKeystrokeListener failed: %s", d_error.message);
 128       dbus_error_free (&d_error);
 129     }
 130
 131   g_free (path);
 132
 133   return retval;
 134 }
 135
 136 static void
 137 device_listener_entry_free (DeviceListenerEntry *e)
 138 {
 139   g_array_free (e->key_set, TRUE);
 140   g_free (e);
 141 }
 142
 143 static void
 144 unregister_listener (gpointer data, GObject *object)
 145 {
 146   GList *l;
 147   AtspiDeviceListener *listener = ATSPI_DEVICE_LISTENER (object);
 148
 149   for (l = device_listeners; l;)
 150     {
 151       DeviceListenerEntry *e = l->data;
 152       if (e->listener == listener)
 153         {
 154           GList *next = l->next;
 155           device_listener_entry_free (e);
 156           device_listeners = g_list_delete_link (device_listeners, l);
 157           l = next;
 158         }
 159       else
 160         l = l->next;
 161     }
 162 }
 163
 164 /**
 165  * atspi_register_keystroke_listener:
 166  * @listener:  a pointer to the #AtspiDeviceListener for which
 167  *             keystroke events are requested.
 168  * @key_set: (element-type AtspiKeyDefinition) (allow-none): a pointer to the
 169  *        #AtspiKeyDefinition array indicating which keystroke events are
 170  *        requested, or NULL
 171  *        to indicate that all keycodes and keyvals for the specified
 172  *        modifier set are to be included.
 173  * @modmask:   an #AtspiKeyMaskType mask indicating which
 174  *             key event modifiers must be set in combination with @keys,
 175  *             events will only be reported for key events for which all
 176  *             modifiers in @modmask are set.  If you wish to listen for
 177  *             events with multiple modifier combinations, you must call
 178  *             #atspi_register_keystroke_listener once for each
 179  *             combination.
 180  * @event_types: an #AtspiKeyMaskType mask indicating which
 181  *             types of key events are requested (%ATSPI_KEY_PRESSED etc.).
 182  * @sync_type: an #AtspiKeyListenerSyncType parameter indicating
 183  *             the behavior of the notification/listener transaction.
 184  * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL
 185  *
 186  * Registers a listener for keystroke events, either pre-emptively for
 187  *             all windows (%ATSPI_KEYLISTENER_ALL_WINDOWS),
 188  *             non-preemptively (%ATSPI_KEYLISTENER_NOSYNC), or
 189  *             pre-emptively at the toolkit level (%ATSPI_KEYLISTENER_CANCONSUME).
 190  *             If ALL_WINDOWS or CANCONSUME are used, the event is consumed
 191  *             upon receipt if one of @listener's callbacks returns %TRUE
 192  *             (other sync_type values may be available in the future).
 193  *
 194  * Returns: %TRUE if successful, otherwise %FALSE.
 195  **/
 196 gboolean
 197 atspi_register_keystroke_listener (AtspiDeviceListener  *listener,
 198                                          GArray             *key_set,
 199                                          AtspiKeyMaskType         modmask,
 200                                          AtspiKeyEventMask        event_types,
 201                                          AtspiKeyListenerSyncType sync_type,
 202                                          GError **error)
 203 {
 204   DeviceListenerEntry *e;
 205
 206   g_return_val_if_fail (listener != NULL, FALSE);
 207
 208   e = g_new0 (DeviceListenerEntry, 1);
 209   e->listener = listener;
 210   e->modmask = modmask;
 211   e->event_types = event_types;
 212   e->sync_type = sync_type;
 213   if (key_set)
 214     {
 215       gint i;
 216       e->key_set = g_array_sized_new (FALSE, TRUE, sizeof (AtspiKeyDefinition),
 217                                       key_set->len);
 218       e->key_set->len = key_set->len;
 219       for (i = 0; i < key_set->len; i++)
 220         {
 221           AtspiKeyDefinition *kd =  ((AtspiKeyDefinition *) key_set->data) + i;
 222           AtspiKeyDefinition *d_kd =  ((AtspiKeyDefinition *) e->key_set->data) + i;
 223           d_kd->keycode = kd->keycode;
 224           d_kd->keysym = kd->keysym;
 225           if (kd->keystring)
 226             {
 227               d_kd->keystring = kd->keystring;
 228             }
 229           else
 230             {
 231               d_kd->keystring = "";
 232             }
 233         }
 234     }
 235   else
 236     {
 237       e->key_set = g_array_sized_new (FALSE, TRUE, sizeof (AtspiKeyDefinition), 0);
 238     }
 239
 240   g_object_weak_ref (G_OBJECT (listener), unregister_listener, NULL);
 241   device_listeners = g_list_prepend (device_listeners, e);
 242   return notify_keystroke_listener (e);
 243 }
 244
 245 /**
 246  * atspi_deregister_keystroke_listener:
 247  * @listener: a pointer to the #AtspiDeviceListener for which
 248  *            keystroke events are requested.
 249  * @key_set: (element-type AtspiKeyDefinition) (allow-none): a pointer to the
 250  *        #AtspiKeyDefinition array indicating which keystroke events are
 251  *        requested, or %NULL
 252  *        to indicate that all keycodes and keyvals for the specified
 253  *        modifier set are to be included.
 254  * @modmask:  the key modifier mask for which this listener is to be
 255  *            'deregistered' (of type #AtspiKeyMaskType).
 256  * @event_types: an #AtspiKeyMaskType mask indicating which
 257  *             types of key events were requested (%ATSPI_KEY_PRESSED, etc.).
 258  * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL
 259  *
 260  * Removes a keystroke event listener from the registry's listener queue,
 261  *            ceasing notification of events with modifiers matching @modmask.
 262  *
 263  * Returns: %TRUE if successful, otherwise %FALSE.
 264  **/
 265 gboolean
 266 atspi_deregister_keystroke_listener (AtspiDeviceListener *listener,
 267                                      GArray              *key_set,
 268                                      AtspiKeyMaskType     modmask,
 269                                      AtspiKeyEventMask    event_types,
 270                                      GError             **error)
 271 {
 272   GArray *d_key_set;
 273   gchar *path = _atspi_device_listener_get_path (listener);
 274   gint i;
 275   dbus_uint32_t d_modmask = modmask;
 276   dbus_uint32_t d_event_types = event_types;
 277   DBusError d_error;
 278   GList *l;
 279
 280   dbus_error_init (&d_error);
 281   if (!listener)
 282     {
 283       return FALSE;
 284     }
 285
 286   /* copy the keyval filter values from the C api into the DBind KeySet */
 287   if (key_set)
 288     {
 289       d_key_set = g_array_sized_new (FALSE, TRUE, sizeof (AtspiKeyDefinition), key_set->len);
 290       d_key_set->len = key_set->len;
 291       for (i = 0; i < key_set->len; ++i)
 292         {
 293           AtspiKeyDefinition *kd =  ((AtspiKeyDefinition *) key_set->data) + i;
 294           AtspiKeyDefinition *d_kd =  ((AtspiKeyDefinition *) d_key_set->data) + i;
 295           d_kd->keycode = kd->keycode;
 296           d_kd->keysym = kd->keysym;
 297           if (kd->keystring)
 298             {
 299               d_kd->keystring = kd->keystring;
 300             }
 301           else
 302             {
 303               d_kd->keystring = "";
 304             }
 305         }
 306     }
 307   else
 308     {
 309       d_key_set = g_array_sized_new (FALSE, TRUE, sizeof (AtspiKeyDefinition), 0);
 310     }
 311
 312   dbind_method_call_reentrant (_atspi_bus(), atspi_bus_registry,
 313                                atspi_path_dec, atspi_interface_dec,
 314                                "DeregisterKeystrokeListener", &d_error,
 315                                "oa(iisi)uu", path, d_key_set, d_modmask,
 316                                d_event_types);
 317   if (dbus_error_is_set (&d_error))
 318     {
 319       g_warning ("DeregisterKeystrokeListener failed: %s", d_error.message);
 320       dbus_error_free (&d_error);
 321     }
 322
 323   unregister_listener (listener, NULL);
 324   for (l = device_listeners; l;)
 325     {
 326       /* TODO: This code is all wrong / doesn't match what is in
 327  *       deviceeventcontroller.c. It would be nice to deprecate these methods
 328  *       in favor of methods that return an ID for the registration that can
 329  *       be passed to a deregister function, for instance. */
 330       DeviceListenerEntry *e = l->data;
 331       if (e->modmask == modmask && e->event_types == event_types)
 332         {
 333           GList *next = l->next;
 334           device_listener_entry_free (e);
 335           device_listeners = g_list_delete_link (device_listeners, l);
 336           l = next;
 337         }
 338       else
 339         l = l->next;
 340     }
 341   g_array_free (d_key_set, TRUE);
 342   g_free (path);
 343   return TRUE;
 344 }
 345
 346 /**
 347  * atspi_register_device_event_listener:
 348  * @listener:  a pointer to the #AtspiDeviceListener which requests
 349  *             the events.
 350  * @event_types: an #AtspiDeviceEventMask mask indicating which
 351  *             types of key events are requested (%ATSPI_KEY_PRESSED, etc.).
 352  * @filter: (allow-none): Unused parameter.
 353  * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL
 354  *
 355  * Registers a listener for device events, for instance button events.
 356  *
 357  * Returns: %TRUE if successful, otherwise %FALSE.
 358  **/
 359 gboolean
 360 atspi_register_device_event_listener (AtspiDeviceListener  *listener,
 361                                  AtspiDeviceEventMask  event_types,
 362                                  void                      *filter, GError **error)
 363 {
 364   gboolean                          retval = FALSE;
 365   dbus_uint32_t d_event_types = event_types;
 366   gchar *path = _atspi_device_listener_get_path (listener);
 367   DBusError d_error;
 368
 369   dbus_error_init (&d_error);
 370   if (!listener)
 371     {
 372       return retval;
 373     }
 374
 375     dbind_method_call_reentrant (_atspi_bus(), atspi_bus_registry, atspi_path_dec, atspi_interface_dec, "RegisterDeviceEventListener", &d_error, "ou=>b", path, d_event_types, &retval);
 376     if (dbus_error_is_set (&d_error))
 377       {
 378         g_warning ("RegisterDeviceEventListener failed: %s", d_error.message);
 379         dbus_error_free (&d_error);
 380       }
 381
 382   g_free (path);
 383   return retval;
 384 }
 385
 386 /**
 387  * atspi_deregister_device_event_listener:
 388  * @listener: a pointer to the #AtspiDeviceListener for which
 389  *            device events are requested.
 390  * @filter: (allow-none): Unused parameter.
 391  * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL
 392  *
 393  * Removes a device event listener from the registry's listener queue,
 394  *            ceasing notification of events of the specified type.
 395  *
 396  * Returns: %TRUE if successful, otherwise %FALSE.
 397  **/
 398 gboolean
 399 atspi_deregister_device_event_listener (AtspiDeviceListener *listener,
 400                                    void                     *filter, GError **error)
 401 {
 402   dbus_uint32_t event_types = 0;
 403   gchar *path = _atspi_device_listener_get_path (listener);
 404   DBusError d_error;
 405
 406   dbus_error_init (&d_error);
 407
 408   if (!listener)
 409     {
 410       return FALSE;
 411     }
 412
 413   event_types |= (1 << ATSPI_BUTTON_PRESSED_EVENT);
 414   event_types |= (1 << ATSPI_BUTTON_RELEASED_EVENT);
 415
 416   dbind_method_call_reentrant (_atspi_bus(), atspi_bus_registry, atspi_path_dec, atspi_interface_dec, "DeregisterDeviceEventListener", &d_error, "ou", path, event_types);
 417   if (dbus_error_is_set (&d_error))
 418     {
 419       g_warning ("DeregisterDeviceEventListener failed: %s", d_error.message);
 420       dbus_error_free (&d_error);
 421     }
 422
 423   g_free (path);
 424   return TRUE;
 425 }
 426
 427 /**
 428  * atspi_generate_keyboard_event:
 429  * @keyval: a #gint indicating the keycode or keysym or modifier mask of the
 430  *           key event being synthesized.
 431  * @keystring: (allow-none): an (optional) UTF-8 string which, if
 432  *           @synth_type is %ATSPI_KEY_STRING, indicates a 'composed'
 433  *           keyboard input string being synthesized; this type of
 434  *           keyboard event synthesis does not emulate hardware
 435  *           keypresses but injects the string as though a composing
 436  *           input method (such as XIM) were used.
 437  * @synth_type: an #AtspiKeySynthType flag indicating whether @keyval
 438  *           is to be interpreted as a keysym rather than a keycode
 439  *           (%ATSPI_KEY_SYM) or a string (%ATSPI_KEY_STRING) or a modifier
 440  *           mask (%ATSPI_KEY_LOCKMODIFIERS and %ATSPI_KEY_UNLOCKMODIFIERS), or
 441  *           whether to synthesize %ATSPI_KEY_PRESS,
 442  *           %ATSPI_KEY_RELEASE, or both (%ATSPI_KEY_PRESSRELEASE).
 443  * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL
 444  *
 445  * Synthesizes a keyboard event (as if a hardware keyboard event occurred in the
 446  * current UI context).
 447  *
 448  * Returns: %TRUE if successful, otherwise %FALSE.
 449  **/
 450 gboolean
 451 atspi_generate_keyboard_event (glong keyval,
 452                            const gchar *keystring,
 453                            AtspiKeySynthType synth_type, GError **error)
 454 {
 455   dbus_uint32_t d_synth_type = synth_type;
 456   dbus_int32_t d_keyval = keyval;
 457   DBusError d_error;
 458
 459   dbus_error_init (&d_error);
 460   if (!keystring)
 461     keystring = "";
 462   dbind_method_call_reentrant (_atspi_bus(), atspi_bus_registry, atspi_path_dec, atspi_interface_dec, "GenerateKeyboardEvent", &d_error, "isu", d_keyval, keystring, d_synth_type);
 463   if (dbus_error_is_set (&d_error))
 464     {
 465       g_warning ("GenerateKeyboardEvent failed: %s", d_error.message);
 466       dbus_error_free (&d_error);
 467     }
 468
 469   return TRUE;
 470 }
 471
 472 /**
 473  * atspi_generate_mouse_event:
 474  * @x: a #glong indicating the screen x coordinate of the mouse event.
 475  * @y: a #glong indicating the screen y coordinate of the mouse event.
 476  * @name: a string indicating which mouse event to be synthesized
 477  *        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
 478  * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL
 479  *
 480  * Synthesizes a mouse event at a specific screen coordinate.
 481  * Most AT clients should use the #AccessibleAction interface when
 482  * tempted to generate mouse events, rather than this method.
 483  * Event names: b1p = button 1 press; b2r = button 2 release;
 484  *              b3c = button 3 click; b2d = button 2 double-click;
 485  *              abs = absolute motion; rel = relative motion.
 486  *
 487  * Returns: %TRUE if successful, otherwise %FALSE.
 488  **/
 489 gboolean
 490 atspi_generate_mouse_event (glong x, glong y, const gchar *name, GError **error)
 491 {
 492   dbus_int32_t d_x = x, d_y = y;
 493   DBusError d_error;
 494
 495   dbus_error_init (&d_error);
 496   dbind_method_call_reentrant (_atspi_bus(), atspi_bus_registry,
 497                                atspi_path_dec, atspi_interface_dec,
 498                                "GenerateMouseEvent", &d_error, "iis",
 499                                d_x, d_y, name);
 500   if (dbus_error_is_set (&d_error))
 501     {
 502       g_warning ("GenerateMouseEvent failed: %s", d_error.message);
 503       dbus_error_free (&d_error);
 504     }
 505
 506   return TRUE;
 507 }
 508
 509 AtspiKeyDefinition *
 510 atspi_key_definition_copy (AtspiKeyDefinition *src)
 511 {
 512   AtspiKeyDefinition *dst;
 513
 514   dst = g_new0 (AtspiKeyDefinition, 1);
 515   dst->keycode = src->keycode;
 516   dst->keysym = src->keysym;
 517   if (src->keystring)
 518     dst->keystring = g_strdup (src->keystring);
 519   dst->unused = src->unused;
 520   return dst;
 521 }
 522
 523 void
 524 atspi_key_definition_free (AtspiKeyDefinition *kd)
 525 {
 526   if (kd->keystring)
 527     g_free (kd->keystring);
 528   g_free (kd);
 529 }
 530
 531 void
 532 _atspi_reregister_device_listeners ()
 533 {
 534   GList *l;
 535   DeviceListenerEntry *e;
 536
 537   for (l = device_listeners; l; l = l->next)
 538     {
 539       e = l->data;
 540       notify_keystroke_listener (e);
 541     }
 542 }
 543 G_DEFINE_BOXED_TYPE (AtspiKeyDefinition, atspi_key_definition, atspi_key_definition_copy, atspi_key_definition_free)