registryd/registry.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2008, 2010 Codethink Ltd.
   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 #include <config.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28
  29 #include "paths.h"
  30 #include "registry.h"
  31 #include "introspection.h"
  32
  33 typedef struct event_data event_data;
  34 struct event_data
  35 {
  36   gchar *bus_name;
  37   gchar **data;
  38 };
  39
  40 static void
  41 children_added_listener (DBusConnection * bus,
  42                          gint             index,
  43                          const gchar    * name,
  44                          const gchar    * path);
  45
  46 static void
  47 children_removed_listener (DBusConnection * bus,
  48                            gint             index,
  49                            const gchar    * name,
  50                            const gchar    * path);
  51
  52 /*---------------------------------------------------------------------------*/
  53
  54 typedef struct _SpiReference
  55 {
  56   gchar *name;
  57   gchar *path;
  58 } SpiReference;
  59
  60 static SpiReference *
  61 spi_reference_new (const gchar *name, const gchar *path)
  62 {
  63   SpiReference *ref;
  64
  65   ref = g_new0 (SpiReference, 1);
  66   ref->name = g_strdup (name);
  67   ref->path = g_strdup (path);
  68
  69   return ref;
  70 }
  71
  72 static void
  73 spi_reference_free (SpiReference *ref)
  74 {
  75   g_free (ref->name);
  76   g_free (ref->path);
  77   g_free (ref);
  78 }
  79
  80 /*---------------------------------------------------------------------------*/
  81
  82 G_DEFINE_TYPE(SpiRegistry, spi_registry, G_TYPE_OBJECT)
  83
  84 static void
  85 spi_registry_class_init (SpiRegistryClass *klass)
  86 {
  87   spi_registry_parent_class = g_type_class_ref (G_TYPE_OBJECT);
  88 }
  89
  90 static void
  91 spi_registry_init (SpiRegistry *registry)
  92 {
  93   registry->apps = g_ptr_array_new_with_free_func ((GDestroyNotify) spi_reference_free);
  94 }
  95
  96 /*---------------------------------------------------------------------------*/
  97
  98 static dbus_bool_t
  99 return_v_string (DBusMessageIter * iter, const gchar * str)
 100 {
 101   DBusMessageIter variant;
 102
 103   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "s",
 104                                     &variant))
 105     return FALSE;
 106     dbus_message_iter_append_basic (&variant, DBUS_TYPE_STRING, &str);
 107   dbus_message_iter_close_container (iter, &variant);
 108   return TRUE;
 109 }
 110
 111 static dbus_bool_t
 112 append_reference (DBusMessageIter * iter, const char * name, const char * path)
 113 {
 114   DBusMessageIter iter_struct;
 115
 116   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
 117                                     &iter_struct))
 118     return FALSE;
 119   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &name);
 120   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &path);
 121   dbus_message_iter_close_container (iter, &iter_struct);
 122   return TRUE;
 123 }
 124
 125 /*---------------------------------------------------------------------------*/
 126
 127 static gboolean
 128 compare_reference (SpiReference *one, SpiReference *two)
 129 {
 130   if (g_strcmp0 (one->name, two->name) == 0 &&
 131       g_strcmp0 (one->path, two->path) == 0)
 132     return TRUE;
 133   else
 134     return FALSE;
 135 }
 136
 137 static gboolean
 138 find_index_of_reference (GPtrArray *arr, const gchar *name, const gchar * path, guint *index)
 139 {
 140   SpiReference *ref;
 141   gboolean found = FALSE;
 142   guint i = 0;
 143
 144   ref = spi_reference_new (name, path);
 145
 146   for (i = 0; i < arr->len && found == FALSE; i++)
 147     {
 148       if (compare_reference (ref, g_ptr_array_index (arr, i)));
 149         {
 150           found = TRUE;
 151         }
 152     }
 153
 154   spi_reference_free (ref);
 155
 156   *index = i;
 157   return found;
 158 }
 159
 160 static void
 161 add_application (SpiRegistry *reg, DBusConnection *bus, const gchar *name, const gchar *path)
 162 {
 163   g_ptr_array_add (reg->apps, spi_reference_new (name, path));
 164   children_added_listener (bus, reg->apps->len - 1, name, path);
 165 }
 166
 167 static void
 168 set_id (SpiRegistry *reg, DBusConnection *bus, const gchar *name, const gchar *path)
 169 {
 170   DBusMessage *message;
 171   DBusMessageIter iter, iter_variant;
 172   const char *iface_application = "org.a11y.atspi.Application";
 173   const char *id = "Id";
 174
 175   message = dbus_message_new_method_call (name, path,
 176                                           DBUS_INTERFACE_PROPERTIES, "Set");
 177   if (!message)
 178     return;
 179   dbus_message_iter_init_append (message, &iter);
 180   dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &iface_application);
 181   dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &id);
 182   dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "i", &iter_variant);
 183   dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &reg->id);
 184   /* TODO: This will cause problems if we cycle through 2^31 ids */
 185   reg->id++;
 186   dbus_message_iter_close_container (&iter, &iter_variant);
 187   dbus_connection_send (bus, message, NULL);
 188   dbus_message_unref (message);
 189 }
 190
 191 static void
 192 remove_application (SpiRegistry *reg, DBusConnection *bus, guint index)
 193 {
 194   SpiReference *ref = g_ptr_array_index (reg->apps, index);
 195
 196   spi_remove_device_listeners (reg->dec, ref->name);
 197   children_removed_listener (bus, index, ref->name, ref->path);
 198   g_ptr_array_remove_index (reg->apps, index);
 199 }
 200
 201 static gboolean
 202 event_is_subtype (gchar **needle, gchar **haystack)
 203 {
 204   while (*haystack && **haystack)
 205     {
 206       if (g_strcmp0 (*needle, *haystack))
 207         return FALSE;
 208       needle++;
 209       haystack++;
 210     }
 211   return TRUE;
 212 }
 213
 214 static gboolean
 215 needs_mouse_poll (char **event)
 216 {
 217   if (g_strcmp0 (event [0], "Mouse") != 0)
 218     return FALSE;
 219   if (!event [1] || !event [1][0])
 220     return TRUE;
 221   return (g_strcmp0 (event [1], "Abs") == 0);
 222 }
 223
 224 static void
 225 remove_events (SpiRegistry *registry, const char *bus_name, const char *event)
 226 {
 227   gchar **remove_data;
 228   GList *list;
 229   gboolean mouse_found = FALSE;
 230   DBusMessage *signal;
 231
 232   remove_data = g_strsplit (event, ":", 3);
 233   if (!remove_data)
 234     {
 235       return;
 236     }
 237
 238   for (list = registry->events; list;)
 239     {
 240       event_data *evdata = list->data;
 241       list = list->next;
 242       if (!g_strcmp0 (evdata->bus_name, bus_name) &&
 243           event_is_subtype (evdata->data, remove_data))
 244         {
 245           g_strfreev (evdata->data);
 246           g_free (evdata->bus_name);
 247           g_free (evdata);
 248           registry->events = g_list_remove (registry->events, evdata);
 249         }
 250       else
 251         {
 252           if (needs_mouse_poll (evdata->data))
 253             mouse_found = TRUE;
 254         }
 255     }
 256
 257   if (!mouse_found)
 258     spi_device_event_controller_stop_poll_mouse ();
 259
 260   g_strfreev (remove_data);
 261
 262   signal = dbus_message_new_signal (SPI_DBUS_PATH_REGISTRY,
 263                                     SPI_DBUS_INTERFACE_REGISTRY,
 264                                     "EventListenerDeregistered");
 265   dbus_message_append_args (signal, DBUS_TYPE_STRING, &bus_name,
 266                             DBUS_TYPE_STRING, &event, DBUS_TYPE_INVALID);
 267   dbus_connection_send (registry->bus, signal, NULL);
 268   dbus_message_unref (signal);
 269 }
 270
 271 static void
 272 handle_disconnection (DBusConnection *bus, DBusMessage *message, void *user_data)
 273 {
 274   char *name, *old, *new;
 275   SpiRegistry *reg = SPI_REGISTRY (user_data);
 276
 277   if (dbus_message_get_args (message, NULL,
 278                              DBUS_TYPE_STRING, &name,
 279                              DBUS_TYPE_STRING, &old,
 280                              DBUS_TYPE_STRING, &new,
 281                              DBUS_TYPE_INVALID))
 282     {
 283       if (*old != '\0' && *new == '\0')
 284         {
 285           /* Remove all children with the application name the same as the disconnected application. */
 286           guint i;
 287           for (i = 0; i < reg->apps->len; i++)
 288             {
 289               SpiReference *ref  = g_ptr_array_index (reg->apps, i);
 290               if (!g_strcmp0 (old, ref->name))
 291                 {
 292                   remove_application (reg, bus, i);
 293                   i--;
 294                 }
 295             }
 296
 297           remove_events (reg, old, "");
 298         }
 299     }
 300 }
 301
 302 /*
 303  * Converts names of the form "active-descendant-changed" to
 304  *" ActiveDescendantChanged"
 305  */
 306 static gchar *
 307 ensure_proper_format (const char *name)
 308 {
 309   gchar *ret = (gchar *) g_malloc (strlen (name) * 2 + 2);
 310   gchar *p = ret;
 311   gboolean need_upper = TRUE;
 312
 313   if (!ret)
 314     return NULL;
 315   while (*name)
 316     {
 317       if (need_upper)
 318         {
 319           *p++ = toupper (*name);
 320           need_upper = FALSE;
 321         }
 322       else if (*name == '-')
 323         need_upper = TRUE;
 324       else if (*name == ':')
 325         {
 326           need_upper = TRUE;
 327           *p++ = *name;
 328         }
 329       else
 330         *p++ = *name;
 331       name++;
 332     }
 333   *p = '\0';
 334   return ret;
 335 }
 336
 337 static DBusHandlerResult
 338 signal_filter (DBusConnection *bus, DBusMessage *message, void *user_data)
 339 {
 340   guint res = DBUS_HANDLER_RESULT_HANDLED;
 341   const gint   type    = dbus_message_get_type (message);
 342   const char *iface = dbus_message_get_interface (message);
 343   const char *member = dbus_message_get_member (message);
 344
 345   if (type != DBUS_MESSAGE_TYPE_SIGNAL)
 346     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 347
 348   if (!g_strcmp0(iface, DBUS_INTERFACE_DBUS) &&
 349       !g_strcmp0(member, "NameOwnerChanged"))
 350       handle_disconnection (bus, message, user_data);
 351   else
 352       res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 353
 354   return res;
 355 }
 356
 357 /* org.at_spi.Socket interface */
 358 /*---------------------------------------------------------------------------*/
 359
 360 static DBusMessage*
 361 impl_Embed (DBusConnection *bus, DBusMessage *message, void *user_data)
 362 {
 363   SpiRegistry *reg = SPI_REGISTRY (user_data);
 364   DBusMessageIter iter, iter_struct;
 365   const gchar *app_name, *obj_path;
 366
 367   DBusMessage *reply = NULL;
 368   DBusMessageIter reply_iter;
 369
 370   dbus_message_iter_init (message, &iter);
 371   dbus_message_iter_recurse (&iter, &iter_struct);
 372   if (!(dbus_message_iter_get_arg_type (&iter_struct) == DBUS_TYPE_STRING))
 373         goto error;
 374   dbus_message_iter_get_basic (&iter_struct, &app_name);
 375   if (!app_name)
 376     app_name = dbus_message_get_sender (message);
 377   if (!dbus_message_iter_next (&iter_struct))
 378         goto error;
 379   if (!(dbus_message_iter_get_arg_type (&iter_struct) == DBUS_TYPE_OBJECT_PATH))
 380         goto error;
 381   dbus_message_iter_get_basic (&iter_struct, &obj_path);
 382
 383   add_application(reg, bus, app_name, obj_path);
 384
 385   set_id (reg, bus, app_name, obj_path);
 386
 387   reply = dbus_message_new_method_return (message);
 388   dbus_message_iter_init_append (reply, &reply_iter);
 389   append_reference (&reply_iter,
 390                     dbus_bus_get_unique_name (bus),
 391                     SPI_DBUS_PATH_ROOT);
 392
 393   return reply;
 394 error:
 395   return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Invalid arguments");
 396 }
 397
 398 static DBusMessage*
 399 impl_Unembed (DBusConnection *bus, DBusMessage *message, void *user_data)
 400 {
 401   SpiRegistry *reg = SPI_REGISTRY (user_data);
 402   DBusMessageIter iter, iter_struct;
 403   gchar *app_name, *obj_path;
 404   guint index;
 405
 406   dbus_message_iter_init (message, &iter);
 407   dbus_message_iter_recurse (&iter, &iter_struct);
 408   if (!(dbus_message_iter_get_arg_type (&iter_struct) == DBUS_TYPE_STRING))
 409         goto error;
 410   dbus_message_iter_get_basic (&iter_struct, &app_name);
 411   if (!dbus_message_iter_next (&iter_struct))
 412         goto error;
 413   if (!(dbus_message_iter_get_arg_type (&iter_struct) == DBUS_TYPE_OBJECT_PATH))
 414         goto error;
 415   dbus_message_iter_get_basic (&iter_struct, &obj_path);
 416
 417   if (find_index_of_reference (reg->apps, app_name, obj_path, &index))
 418       remove_application(reg, bus, index);
 419
 420   return NULL;
 421 error:
 422   return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Invalid arguments");
 423 }
 424
 425 /* org.at_spi.Component interface */
 426 /*---------------------------------------------------------------------------*/
 427
 428 static DBusMessage *
 429 impl_Contains (DBusConnection * bus, DBusMessage * message, void *user_data)
 430 {
 431   dbus_bool_t retval = FALSE;
 432   DBusMessage *reply;
 433
 434   reply = dbus_message_new_method_return (message);
 435   dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &retval,
 436                             DBUS_TYPE_INVALID);
 437   return reply;
 438 }
 439
 440 static DBusMessage *
 441 impl_GetAccessibleAtPoint (DBusConnection * bus, DBusMessage * message,
 442                            void *user_data)
 443 {
 444   DBusMessage *reply = NULL;
 445   DBusMessageIter iter;
 446
 447   reply = dbus_message_new_method_return (message);
 448   dbus_message_iter_init_append (reply, &iter);
 449   append_reference (&iter,
 450                     dbus_bus_get_unique_name (bus),
 451                     SPI_DBUS_PATH_NULL);
 452
 453   return reply;
 454 }
 455
 456 static DBusMessage *
 457 impl_GetExtents (DBusConnection * bus, DBusMessage * message, void *user_data)
 458 {
 459   dbus_int32_t x = 0, y = 0, width = 1024, height = 768;
 460   DBusMessage *reply;
 461   DBusMessageIter iter, iter_struct;
 462
 463   reply = dbus_message_new_method_return (message);
 464   dbus_message_iter_init_append (reply, &iter);
 465   dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL,
 466                                     &iter_struct);
 467     dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &x);
 468     dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &y);
 469     dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &width);
 470     dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &height);
 471   dbus_message_iter_close_container (&iter, &iter_struct);
 472   return reply;
 473 }
 474
 475 static DBusMessage *
 476 impl_GetPosition (DBusConnection * bus, DBusMessage * message,
 477                   void *user_data)
 478 {
 479   DBusMessage *reply;
 480   dbus_int32_t x = 0, y = 0;
 481
 482   reply = dbus_message_new_method_return (message);
 483   dbus_message_append_args (reply, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32,
 484                             &y, DBUS_TYPE_INVALID);
 485   return reply;
 486 }
 487
 488 static DBusMessage *
 489 impl_GetSize (DBusConnection * bus, DBusMessage * message, void *user_data)
 490 {
 491   /* TODO - Get the screen size */
 492   DBusMessage *reply;
 493   dbus_int32_t width = 1024, height = 768;
 494
 495   reply = dbus_message_new_method_return (message);
 496   dbus_message_append_args (reply, DBUS_TYPE_INT32, &width,
 497                             DBUS_TYPE_INT32, &height, DBUS_TYPE_INVALID);
 498   return reply;
 499 }
 500
 501 #define LAYER_WIDGET 3;
 502
 503 static DBusMessage *
 504 impl_GetLayer (DBusConnection * bus, DBusMessage * message, void *user_data)
 505 {
 506   DBusMessage *reply;
 507   dbus_uint32_t rv = LAYER_WIDGET;
 508
 509   reply = dbus_message_new_method_return (message);
 510   dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv,
 511                             DBUS_TYPE_INVALID);
 512   return reply;
 513 }
 514
 515 static DBusMessage *
 516 impl_GetMDIZOrder (DBusConnection * bus, DBusMessage * message,
 517                    void *user_data)
 518 {
 519   DBusMessage *reply;
 520   dbus_int16_t rv = 0;
 521
 522   reply = dbus_message_new_method_return (message);
 523   dbus_message_append_args (reply, DBUS_TYPE_INT16, &rv,
 524                             DBUS_TYPE_INVALID);
 525   return reply;
 526 }
 527
 528 static DBusMessage *
 529 impl_GrabFocus (DBusConnection * bus, DBusMessage * message, void *user_data)
 530 {
 531   DBusMessage *reply;
 532   dbus_bool_t retval = FALSE;
 533
 534   reply = dbus_message_new_method_return (message);
 535   dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &retval,
 536                             DBUS_TYPE_INVALID);
 537   return reply;
 538 }
 539
 540 static DBusMessage *
 541 impl_GetAlpha (DBusConnection * bus, DBusMessage * message, void *user_data)
 542 {
 543   double rv = 1.0;
 544   DBusMessage *reply;
 545
 546   reply = dbus_message_new_method_return (message);
 547   dbus_message_append_args (reply, DBUS_TYPE_DOUBLE, &rv,
 548                             DBUS_TYPE_INVALID);
 549   return reply;
 550 }
 551
 552 /* org.at_spi.Accessible interface */
 553 /*---------------------------------------------------------------------------*/
 554
 555 static dbus_bool_t
 556 impl_get_Name (DBusMessageIter * iter, void *user_data)
 557 {
 558   const gchar *name = "main";
 559   return return_v_string (iter, name);
 560 }
 561
 562 static dbus_bool_t
 563 impl_get_Description (DBusMessageIter * iter, void *user_data)
 564 {
 565   const gchar *description = "";
 566   return return_v_string (iter, description);
 567 }
 568
 569 static dbus_bool_t
 570 impl_get_Parent (DBusMessageIter * iter, void *user_data)
 571 {
 572   const gchar *name = "";
 573   DBusMessageIter iter_variant;
 574
 575   dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "(so)",
 576                                     &iter_variant);
 577   append_reference (&iter_variant,
 578                     name,
 579                     SPI_DBUS_PATH_NULL);
 580   dbus_message_iter_close_container (iter, &iter_variant);
 581   return TRUE;
 582 }
 583
 584 static dbus_bool_t
 585 impl_get_ChildCount (DBusMessageIter * iter, void *user_data)
 586 {
 587   SpiRegistry *reg = SPI_REGISTRY (user_data);
 588   dbus_int32_t rv = reg->apps->len;
 589   dbus_bool_t result;
 590   DBusMessageIter iter_variant;
 591
 592   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "i",
 593                                          &iter_variant))
 594     return FALSE;
 595   result = dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &rv);
 596   dbus_message_iter_close_container (iter, &iter_variant);
 597   return result;
 598 }
 599
 600 static dbus_bool_t
 601 impl_get_ToolkitName (DBusMessageIter * iter, void *user_data)
 602 {
 603   return return_v_string (iter, "at-spi-registry");
 604 }
 605
 606 static dbus_bool_t
 607 impl_get_ToolkitVersion (DBusMessageIter * iter, void *user_data)
 608 {
 609   return return_v_string (iter, "2.0");
 610 }
 611
 612 static DBusMessage *
 613 impl_GetChildAtIndex (DBusConnection * bus,
 614                       DBusMessage * message, void *user_data)
 615 {
 616   SpiRegistry *reg = SPI_REGISTRY (user_data);
 617   DBusMessage *reply;
 618   DBusMessageIter iter;
 619   DBusError error;
 620   SpiReference *ref;
 621   dbus_int32_t i;
 622
 623   dbus_error_init (&error);
 624   if (!dbus_message_get_args
 625        (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
 626     {
 627       return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Invalid arguments");
 628     }
 629
 630   reply = dbus_message_new_method_return (message);
 631   dbus_message_iter_init_append (reply, &iter);
 632
 633   if (i < 0 || i >= reg->apps->len)
 634     append_reference (&iter, SPI_DBUS_NAME_REGISTRY, SPI_DBUS_PATH_NULL);
 635   else
 636     {
 637       ref = g_ptr_array_index (reg->apps, i);
 638       append_reference (&iter, ref->name, ref->path);
 639     }
 640
 641   return reply;
 642 }
 643
 644 static DBusMessage *
 645 impl_GetChildren (DBusConnection * bus,
 646                   DBusMessage * message, void *user_data)
 647 {
 648   DBusMessage *reply = NULL;
 649   DBusMessageIter iter, iter_array;
 650   SpiRegistry *reg = SPI_REGISTRY (user_data);
 651   int i;
 652
 653   reply = dbus_message_new_method_return (message);
 654
 655   dbus_message_iter_init_append (reply, &iter);
 656   dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &iter_array);
 657   for (i=0; i < reg->apps->len; i++)
 658     {
 659       SpiReference *current = g_ptr_array_index (reg->apps, i);
 660       append_reference (&iter_array, current->name, current->path);
 661     }
 662   dbus_message_iter_close_container(&iter, &iter_array);
 663   return reply;
 664 }
 665
 666 static DBusMessage *
 667 impl_GetIndexInParent (DBusConnection * bus,
 668                        DBusMessage * message, void *user_data)
 669 {
 670   DBusMessage *reply;
 671   dbus_uint32_t rv = 0;
 672
 673   reply = dbus_message_new_method_return (message);
 674   dbus_message_append_args (reply, DBUS_TYPE_INT32, &rv, DBUS_TYPE_INVALID);
 675   return reply;
 676 }
 677
 678 static DBusMessage *
 679 impl_GetRelationSet (DBusConnection * bus,
 680                      DBusMessage * message, void *user_data)
 681 {
 682   DBusMessage *reply;
 683   DBusMessageIter iter, iter_array;
 684
 685   reply = dbus_message_new_method_return (message);
 686   dbus_message_iter_init_append (reply, &iter);
 687   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(ua(so))", &iter_array);
 688   dbus_message_iter_close_container (&iter, &iter_array);
 689
 690   return reply;
 691 }
 692
 693 static DBusMessage *
 694 impl_GetRole (DBusConnection * bus, DBusMessage * message, void * user_data)
 695 {
 696   DBusMessage *reply;
 697   dbus_uint32_t rv = 14;        /* TODO: Get DESKTOP_FRAME from somewhere */
 698
 699   reply = dbus_message_new_method_return (message);
 700   dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv, DBUS_TYPE_INVALID);
 701   return reply;
 702 }
 703
 704 static DBusMessage *
 705 impl_GetRoleName (DBusConnection * bus,
 706                   DBusMessage * message, void *user_data)
 707 {
 708   DBusMessage *reply;
 709   const char *role_name = "desktop frame";
 710
 711   reply = dbus_message_new_method_return (message);
 712   dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
 713                             DBUS_TYPE_INVALID);
 714   return reply;
 715 }
 716
 717 static DBusMessage *
 718 impl_GetLocalizedRoleName (DBusConnection * bus,
 719                            DBusMessage * message, void *user_data)
 720 {
 721   /* TODO - Localize this */
 722   DBusMessage *reply;
 723   const char *role_name = "desktop frame";
 724
 725   reply = dbus_message_new_method_return (message);
 726   dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
 727                             DBUS_TYPE_INVALID);
 728   return reply;
 729 }
 730
 731 static DBusMessage *
 732 impl_GetState (DBusConnection * bus, DBusMessage * message, void *user_data)
 733 {
 734   DBusMessage *reply = NULL;
 735   DBusMessageIter iter, iter_array;
 736
 737   dbus_uint32_t states[2] = {0, 0};
 738   guint count;
 739
 740   reply = dbus_message_new_method_return (message);
 741   dbus_message_iter_init_append (reply, &iter);
 742
 743   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "u", &iter_array);
 744   for (count = 0; count < 2; count++)
 745     {
 746       dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_UINT32,
 747                                       &states[count]);
 748     }
 749   dbus_message_iter_close_container (&iter, &iter_array);
 750   return reply;
 751 }
 752
 753 static DBusMessage *
 754 impl_GetAttributes (DBusConnection * bus,
 755                     DBusMessage * message, void *user_data)
 756 {
 757   DBusMessage *reply = NULL;
 758   DBusMessageIter iter, array;
 759
 760   reply = dbus_message_new_method_return (message);
 761   dbus_message_iter_init_append (reply, &iter);
 762   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{ss}", &array);
 763   dbus_message_iter_close_container (&iter, &array);
 764
 765   return reply;
 766 }
 767
 768 static DBusMessage *
 769 impl_GetApplication (DBusConnection * bus,
 770                      DBusMessage * message, void *user_data)
 771 {
 772   DBusMessage *reply = NULL;
 773   DBusMessageIter iter;
 774
 775   reply = dbus_message_new_method_return (message);
 776   dbus_message_iter_init_append (reply, &iter);
 777   append_reference (&iter,
 778                     dbus_bus_get_unique_name (bus),
 779                     SPI_DBUS_PATH_NULL);
 780
 781   return reply;
 782 }
 783
 784 static DBusMessage *
 785 impl_GetInterfaces (DBusConnection * bus,
 786                     DBusMessage * message, void *user_data)
 787 {
 788   DBusMessage *reply;
 789   DBusMessageIter iter, iter_array;
 790
 791   const char *acc = SPI_DBUS_INTERFACE_ACCESSIBLE;
 792   const char *com = SPI_DBUS_INTERFACE_COMPONENT;
 793
 794   reply = dbus_message_new_method_return (message);
 795
 796   dbus_message_iter_init_append (reply, &iter);
 797   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s",
 798                                     &iter_array);
 799     dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &acc);
 800     dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &com);
 801   dbus_message_iter_close_container (&iter, &iter_array);
 802
 803   return reply;
 804 }
 805
 806 static DBusMessage *
 807 impl_GetItems (DBusConnection * bus, DBusMessage * message, void *user_data)
 808 {
 809   DBusMessage *reply;
 810   DBusMessageIter iter, iter_array;
 811
 812   reply = dbus_message_new_method_return (message);
 813
 814   dbus_message_iter_init_append (reply, &iter);
 815   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
 816                                     "((so)(so)(so)a(so)assusau)", &iter_array);
 817   dbus_message_iter_close_container (&iter, &iter_array);
 818   return reply;
 819 }
 820
 821 /* I would rather these two be signals, but I'm not sure that dbus-python
 822  * supports emitting signals except for a service, so implementing as both
 823  * a method call and signal for now.
 824  */
 825 static DBusMessage *
 826 impl_register_event (DBusConnection *bus, DBusMessage *message, void *user_data)
 827 {
 828   SpiRegistry *registry = SPI_REGISTRY (user_data);
 829   const char *orig_name;
 830   gchar *name;
 831   event_data *evdata;
 832   gchar **data;
 833   DBusMessage *signal;
 834   const char *sender = dbus_message_get_sender (message);
 835
 836   if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &orig_name,
 837     DBUS_TYPE_INVALID))
 838     return NULL;
 839
 840   name = ensure_proper_format (orig_name);
 841
 842   evdata = (event_data *) g_malloc (sizeof (*evdata));
 843   if (!evdata)
 844     return NULL;
 845   data = g_strsplit (name, ":", 3);
 846   evdata->bus_name = g_strdup (sender);
 847   evdata->data = data;
 848   registry->events = g_list_append (registry->events, evdata);
 849
 850   if (needs_mouse_poll (evdata->data))
 851     {
 852       spi_device_event_controller_start_poll_mouse (registry);
 853     }
 854
 855   signal = dbus_message_new_signal (SPI_DBUS_PATH_REGISTRY,
 856                                     SPI_DBUS_INTERFACE_REGISTRY,
 857                                     "EventListenerRegistered");
 858   dbus_message_append_args (signal, DBUS_TYPE_STRING, &sender,
 859                             DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
 860   dbus_connection_send (bus, signal, NULL);
 861   dbus_message_unref (signal);
 862
 863   g_free (name);
 864   return dbus_message_new_method_return (message);
 865 }
 866
 867 static DBusMessage *
 868 impl_deregister_event (DBusConnection *bus, DBusMessage *message, void *user_data)
 869 {
 870   SpiRegistry *registry = SPI_REGISTRY (user_data);
 871   const char *orig_name;
 872   gchar *name;
 873   const char *sender = dbus_message_get_sender (message);
 874
 875   if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &orig_name,
 876     DBUS_TYPE_INVALID))
 877     return NULL;
 878   name = ensure_proper_format (orig_name);
 879
 880   remove_events (registry, sender, name);
 881
 882   g_free (name);
 883   return dbus_message_new_method_return (message);
 884 }
 885
 886 static DBusMessage *
 887 impl_get_registered_events (DBusConnection *bus, DBusMessage *message, void *user_data)
 888 {
 889   SpiRegistry *registry = SPI_REGISTRY (user_data);
 890   event_data *evdata;
 891   DBusMessage *reply;
 892   DBusMessageIter iter, iter_struct, iter_array;
 893   GList *list;
 894
 895   reply = dbus_message_new_method_return (message);
 896   if (!reply)
 897     return NULL;
 898
 899   dbus_message_iter_init_append (reply, &iter);
 900   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(ss)", &iter_array);
 901   for (list = registry->events; list; list = list->next)
 902     {
 903       gchar *str;
 904       evdata = list->data;
 905       str = g_strconcat (evdata->data [0],
 906                          ":", (evdata->data [1]? evdata->data [1]: ""),
 907                          ":", (evdata->data [1] && evdata->data [2]? evdata->data [2]: ""), NULL);
 908       dbus_message_iter_open_container (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct);
 909       dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &evdata->bus_name);
 910       dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &str);
 911       dbus_message_iter_close_container (&iter_array, &iter_struct);
 912       g_free (str);
 913     }
 914   dbus_message_iter_close_container (&iter, &iter_array);
 915   return reply;
 916 }
 917
 918 /*---------------------------------------------------------------------------*/
 919
 920 static void
 921 emit_Available (DBusConnection * bus)
 922 {
 923   DBusMessage *sig;
 924   DBusMessageIter iter;
 925
 926   sig = dbus_message_new_signal(SPI_DBUS_PATH_ROOT, SPI_DBUS_INTERFACE_SOCKET, "Available");
 927
 928   dbus_message_iter_init_append(sig, &iter);
 929   append_reference (&iter, SPI_DBUS_NAME_REGISTRY, SPI_DBUS_PATH_ROOT);
 930
 931   dbus_connection_send(bus, sig, NULL);
 932   dbus_message_unref(sig);
 933 }
 934
 935 /*---------------------------------------------------------------------------*/
 936
 937 static const char *introspection_header =
 938 "<?xml version=\"1.0\"?>\n";
 939
 940 static const char *introspection_node_element =
 941 "<node name=\"%s\">\n";
 942
 943 static const char *introspection_footer =
 944 "</node>";
 945
 946 static DBusMessage *
 947 impl_Introspect_root (DBusConnection * bus,
 948                  DBusMessage * message, void *user_data)
 949 {
 950   GString *output;
 951   gchar *final;
 952
 953   const gchar *pathstr = SPI_DBUS_PATH_ROOT;
 954
 955   DBusMessage *reply;
 956
 957   output = g_string_new(introspection_header);
 958
 959   g_string_append_printf(output, introspection_node_element, pathstr);
 960
 961   g_string_append (output, spi_org_a11y_atspi_Accessible);
 962   g_string_append (output, spi_org_a11y_atspi_Component);
 963
 964   g_string_append(output, introspection_footer);
 965   final = g_string_free(output, FALSE);
 966
 967   reply = dbus_message_new_method_return (message);
 968   dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
 969
 970   g_free(final);
 971   return reply;
 972 }
 973
 974 static DBusMessage *
 975 impl_Introspect_registry (DBusConnection * bus,
 976                  DBusMessage * message, void *user_data)
 977 {
 978   GString *output;
 979   gchar *final;
 980
 981   const gchar *pathstr = SPI_DBUS_PATH_REGISTRY;
 982
 983   DBusMessage *reply;
 984
 985   output = g_string_new(introspection_header);
 986
 987   g_string_append_printf(output, introspection_node_element, pathstr);
 988
 989   g_string_append (output, spi_org_a11y_atspi_Registry);
 990
 991   g_string_append(output, introspection_footer);
 992   final = g_string_free(output, FALSE);
 993
 994   reply = dbus_message_new_method_return (message);
 995   dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
 996
 997   g_free(final);
 998   return reply;
 999 }
1000
1001 /*---------------------------------------------------------------------------*/
1002
1003 /*
1004  * Emits an AT-SPI event.
1005  * AT-SPI events names are split into three parts:
1006  * class:major:minor
1007  * This is mapped onto D-Bus events as:
1008  * D-Bus Interface:Signal Name:Detail argument
1009  *
1010  * Marshals a basic type into the 'any_data' attribute of
1011  * the AT-SPI event.
1012  */
1013 static void
1014 emit_event (DBusConnection *bus,
1015             const char *klass,
1016             const char *major,
1017             const char *minor,
1018             dbus_int32_t detail1,
1019             dbus_int32_t detail2,
1020             const char *name,
1021             const char *path)
1022 {
1023   DBusMessage *sig;
1024   DBusMessageIter iter, iter_variant;
1025
1026   sig = dbus_message_new_signal(SPI_DBUS_PATH_ROOT, klass, major);
1027
1028   dbus_message_iter_init_append(sig, &iter);
1029
1030   dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &minor);
1031   dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &detail1);
1032   dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &detail2);
1033
1034   dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "(so)",
1035                                     &iter_variant);
1036     append_reference (&iter_variant, name, path);
1037   dbus_message_iter_close_container (&iter, &iter_variant);
1038
1039   append_reference (&iter,
1040                     dbus_bus_get_unique_name (bus),
1041                     SPI_DBUS_PATH_ROOT);
1042
1043   dbus_connection_send(bus, sig, NULL);
1044   dbus_message_unref(sig);
1045 }
1046
1047 /*---------------------------------------------------------------------------*/
1048
1049 /*
1050  * Children changed signal converter and forwarder.
1051  *
1052  * Klass (Interface) org.a11y.atspi.Event.Object
1053  * Major is the signal name.
1054  * Minor is 'add' or 'remove'
1055  * detail1 is the index.
1056  * detail2 is 0.
1057  * any_data is the child reference.
1058  */
1059
1060 static void
1061 children_added_listener (DBusConnection * bus,
1062                          gint             index,
1063                          const gchar    * name,
1064                          const gchar    * path)
1065 {
1066   emit_event (bus, SPI_DBUS_INTERFACE_EVENT_OBJECT, "ChildrenChanged", "add", index, 0,
1067               name, path);
1068 }
1069
1070 static void
1071 children_removed_listener (DBusConnection * bus,
1072                            gint             index,
1073                            const gchar    * name,
1074                            const gchar    * path)
1075 {
1076   emit_event (bus, SPI_DBUS_INTERFACE_EVENT_OBJECT, "ChildrenChanged", "remove", index, 0,
1077               name, path);
1078 }
1079
1080 /*---------------------------------------------------------------------------*/
1081
1082 static DBusHandlerResult
1083 handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
1084 {
1085   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1086
1087   const gchar *iface   = dbus_message_get_interface (message);
1088   const gchar *member  = dbus_message_get_member (message);
1089   const gint   type    = dbus_message_get_type (message);
1090
1091   DBusMessage *reply = NULL;
1092
1093   /* Check for basic reasons not to handle */
1094   if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
1095       member == NULL ||
1096       iface  == NULL)
1097       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1098
1099   if (!strcmp (iface, "org.freedesktop.DBus.Properties"))
1100     {
1101       if (!strcmp (member, "Get"))
1102         {
1103           const gchar *prop_iface;
1104           const gchar *prop_member;
1105           DBusError error;
1106
1107           dbus_error_init (&error);
1108           if (dbus_message_get_args (message,
1109                                      &error,
1110                                      DBUS_TYPE_STRING,
1111                                      &prop_iface,
1112                                      DBUS_TYPE_STRING,
1113                                      &prop_member,
1114                                      DBUS_TYPE_INVALID))
1115             {
1116               DBusMessageIter iter;
1117
1118               reply = dbus_message_new_method_return (message);
1119               dbus_message_iter_init_append (reply, &iter);
1120
1121
1122               if (!strcmp (prop_iface, SPI_DBUS_INTERFACE_ACCESSIBLE))
1123                 {
1124                   if      (!strcmp (prop_member, "Name"))
1125                     impl_get_Name (&iter, user_data);
1126                   else if (!strcmp (prop_member, "Description"))
1127                     impl_get_Description (&iter, user_data);
1128                   else if (!strcmp (prop_member, "Parent"))
1129                     impl_get_Parent (&iter, user_data);
1130                   else if (!strcmp (prop_member, "ChildCount"))
1131                     impl_get_ChildCount (&iter, user_data);
1132                   else
1133                     {
1134                       dbus_message_unref (reply);
1135                       reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
1136                     }
1137                 }
1138               else if (!strcmp (prop_iface, SPI_DBUS_INTERFACE_APPLICATION))
1139                 {
1140                   if (!strcmp (prop_member, "ToolkitName"))
1141                     impl_get_ToolkitName (&iter, user_data);
1142                   else if (!strcmp (prop_member, "ToolkitVersion"))
1143                     impl_get_ToolkitVersion (&iter, user_data);
1144                   else
1145                     {
1146                       dbus_message_unref (reply);
1147                       reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
1148                     }
1149                 }
1150               else
1151                 {
1152                   dbus_message_unref (reply);
1153                   reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
1154                 }
1155             }
1156           else
1157             {
1158               reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
1159             }
1160           result = DBUS_HANDLER_RESULT_HANDLED;
1161         }
1162       else if (!strcmp (member, "GetAll"))
1163         {
1164           result = DBUS_HANDLER_RESULT_HANDLED;
1165         }
1166     }
1167
1168   if (!strcmp (iface, SPI_DBUS_INTERFACE_ACCESSIBLE))
1169     {
1170       result = DBUS_HANDLER_RESULT_HANDLED;
1171       if      (!strcmp (member, "GetChildAtIndex"))
1172           reply = impl_GetChildAtIndex (bus, message, user_data);
1173       else if (!strcmp (member, "GetChildren"))
1174           reply = impl_GetChildren (bus, message, user_data);
1175       else if (!strcmp (member, "GetIndexInParent"))
1176           reply = impl_GetIndexInParent (bus, message, user_data);
1177       else if (!strcmp (member, "GetRelationSet"))
1178           reply = impl_GetRelationSet (bus, message, user_data);
1179       else if (!strcmp (member, "GetRole"))
1180           reply = impl_GetRole (bus, message, user_data);
1181       else if (!strcmp (member, "GetRoleName"))
1182           reply = impl_GetRoleName (bus, message, user_data);
1183       else if (!strcmp (member, "GetLocalizedRoleName"))
1184           reply = impl_GetLocalizedRoleName (bus, message, user_data);
1185       else if (!strcmp (member, "GetState"))
1186           reply = impl_GetState (bus, message, user_data);
1187       else if (!strcmp (member, "GetAttributes"))
1188           reply = impl_GetAttributes (bus, message, user_data);
1189       else if (!strcmp (member, "GetApplication"))
1190           reply = impl_GetApplication (bus, message, user_data);
1191       else if (!strcmp (member, "GetInterfaces"))
1192           reply = impl_GetInterfaces (bus, message, user_data);
1193       else
1194          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1195     }
1196
1197   if (!strcmp (iface, SPI_DBUS_INTERFACE_COMPONENT))
1198     {
1199       result = DBUS_HANDLER_RESULT_HANDLED;
1200       if      (!strcmp (member, "Contains"))
1201           reply = impl_Contains (bus, message, user_data);
1202       else if (!strcmp (member, "GetAccessibleAtPoint"))
1203           reply = impl_GetAccessibleAtPoint (bus, message, user_data);
1204       else if (!strcmp (member, "GetExtents"))
1205           reply = impl_GetExtents (bus, message, user_data);
1206       else if (!strcmp (member, "GetPosition"))
1207           reply = impl_GetPosition (bus, message, user_data);
1208       else if (!strcmp (member, "GetSize"))
1209           reply = impl_GetSize (bus, message, user_data);
1210       else if (!strcmp (member, "GetLayer"))
1211           reply = impl_GetLayer (bus, message, user_data);
1212       else if (!strcmp (member, "GetMDIZOrder"))
1213           reply = impl_GetMDIZOrder (bus, message, user_data);
1214       else if (!strcmp (member, "GrabFocus"))
1215           reply = impl_GrabFocus (bus, message, user_data);
1216       else if (!strcmp (member, "GetAlpha"))
1217           reply = impl_GetAlpha (bus, message, user_data);
1218       else
1219          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1220     }
1221
1222   if (!strcmp (iface, SPI_DBUS_INTERFACE_SOCKET))
1223     {
1224       result = DBUS_HANDLER_RESULT_HANDLED;
1225       if      (!strcmp (member, "Embed"))
1226           reply = impl_Embed (bus, message, user_data);
1227       else if (!strcmp (member, "Unembed"))
1228           reply = impl_Unembed (bus, message, user_data);
1229       else
1230           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1231     }
1232
1233   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
1234     {
1235       result = DBUS_HANDLER_RESULT_HANDLED;
1236       if      (!strcmp (member, "Introspect"))
1237           reply = impl_Introspect_root (bus, message, user_data);
1238       else
1239           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1240     }
1241
1242   if (result == DBUS_HANDLER_RESULT_HANDLED)
1243     {
1244       if (!reply)
1245         {
1246           reply = dbus_message_new_method_return (message);
1247         }
1248
1249       dbus_connection_send (bus, reply, NULL);
1250       dbus_message_unref (reply);
1251     }
1252 #if 0
1253   else
1254     {
1255       g_print ("Registry | Unhandled message : %s|%s\n", iface, member);
1256     }
1257 #endif
1258
1259   return result;
1260 }
1261
1262 static DBusHandlerResult
1263 handle_method_cache (DBusConnection *bus, DBusMessage *message, void *user_data)
1264 {
1265   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1266
1267   const gchar *iface   = dbus_message_get_interface (message);
1268   const gchar *member  = dbus_message_get_member (message);
1269   const gint   type    = dbus_message_get_type (message);
1270
1271   DBusMessage *reply = NULL;
1272
1273   /* Check for basic reasons not to handle */
1274   if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
1275       member == NULL ||
1276       iface  == NULL)
1277       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1278
1279   if (!strcmp (iface, SPI_DBUS_INTERFACE_CACHE))
1280     {
1281       result = DBUS_HANDLER_RESULT_HANDLED;
1282       if      (!strcmp (member, "GetItems"))
1283           reply = impl_GetItems (bus, message, user_data);
1284       else
1285          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1286     }
1287
1288   if (result == DBUS_HANDLER_RESULT_HANDLED)
1289     {
1290       if (!reply)
1291         {
1292           reply = dbus_message_new_method_return (message);
1293         }
1294
1295       dbus_connection_send (bus, reply, NULL);
1296       dbus_message_unref (reply);
1297     }
1298   return result;
1299 }
1300
1301 static DBusHandlerResult
1302 handle_method_registry (DBusConnection *bus, DBusMessage *message, void *user_data)
1303 {
1304   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1305
1306   const gchar *iface   = dbus_message_get_interface (message);
1307   const gchar *member  = dbus_message_get_member (message);
1308   const gint   type    = dbus_message_get_type (message);
1309
1310   DBusMessage *reply = NULL;
1311
1312   /* Check for basic reasons not to handle */
1313   if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
1314       member == NULL ||
1315       iface  == NULL)
1316       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1317
1318   if (!strcmp (iface, SPI_DBUS_INTERFACE_REGISTRY))
1319     {
1320       result = DBUS_HANDLER_RESULT_HANDLED;
1321       if (!strcmp(member, "RegisterEvent"))
1322       reply = impl_register_event (bus, message, user_data);
1323       else if (!strcmp(member, "DeregisterEvent"))
1324         reply = impl_deregister_event (bus, message, user_data);
1325       else if (!strcmp(member, "GetRegisteredEvents"))
1326         reply = impl_get_registered_events (bus, message, user_data);
1327       else
1328           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1329     }
1330
1331   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
1332     {
1333       result = DBUS_HANDLER_RESULT_HANDLED;
1334       if      (!strcmp (member, "Introspect"))
1335           reply = impl_Introspect_registry (bus, message, user_data);
1336       else
1337           result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1338     }
1339
1340   if (result == DBUS_HANDLER_RESULT_HANDLED)
1341     {
1342       if (!reply)
1343         {
1344           reply = dbus_message_new_method_return (message);
1345         }
1346
1347       dbus_connection_send (bus, reply, NULL);
1348       dbus_message_unref (reply);
1349     }
1350 #if 0
1351   else
1352     {
1353       g_print ("Registry | Unhandled message : %s|%s\n", iface, member);
1354     }
1355 #endif
1356
1357   return result;
1358 }
1359
1360 /*---------------------------------------------------------------------------*/
1361
1362 static DBusObjectPathVTable root_vtable =
1363 {
1364   NULL,
1365   &handle_method_root,
1366   NULL, NULL, NULL, NULL
1367 };
1368
1369 static DBusObjectPathVTable registry_vtable =
1370 {
1371   NULL,
1372   &handle_method_registry,
1373   NULL, NULL, NULL, NULL
1374 };
1375
1376 static DBusObjectPathVTable cache_vtable =
1377 {
1378   NULL,
1379   &handle_method_cache,
1380   NULL, NULL, NULL, NULL
1381 };
1382
1383 static gchar *app_sig_match_name_owner =
1384        "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged'";
1385
1386 SpiRegistry *
1387 spi_registry_new (DBusConnection *bus)
1388 {
1389   SpiRegistry *reg = g_object_new (SPI_REGISTRY_TYPE, NULL);
1390
1391   reg->bus = bus;
1392
1393   dbus_bus_add_match (bus, app_sig_match_name_owner, NULL);
1394   dbus_connection_add_filter (bus, signal_filter, reg, NULL);
1395
1396   dbus_connection_register_object_path (bus, SPI_DBUS_PATH_ROOT, &root_vtable, reg);
1397
1398   dbus_connection_register_object_path (bus, SPI_DBUS_PATH_CACHE, &cache_vtable, reg);
1399
1400   dbus_connection_register_object_path (bus, SPI_DBUS_PATH_REGISTRY, &registry_vtable, reg);
1401
1402   emit_Available (bus);
1403
1404   reg->events = NULL;
1405
1406   return reg;
1407 }
1408
1409 /*END------------------------------------------------------------------------*/