cspi/bonobo/cspi-bonobo-listener.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001 Sun Microsystems Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <libbonobo.h>
  24 #include "../spi-private.h"
  25 #include "cspi-bonobo-listener.h"
  26
  27 typedef struct
  28 {
  29   union
  30     {
  31       AccessibleEventListenerCB     event;
  32       AccessibleKeystrokeListenerCB key_event;
  33       gpointer                      method;
  34     } cb;
  35   gpointer user_data;
  36 } EventHandler;
  37
  38 GObjectClass *event_parent_class;
  39 GObjectClass *keystroke_parent_class;
  40
  41 /*
  42  * Misc. helpers.
  43  */
  44
  45 static EventHandler *
  46 cspi_event_handler_new (gpointer method, gpointer user_data)
  47 {
  48   EventHandler *eh = g_new0 (EventHandler, 1);
  49
  50   eh->cb.method = method;
  51   eh->user_data = user_data;
  52
  53   return eh;
  54 }
  55
  56 static void
  57 cspi_event_handler_free (EventHandler *handler)
  58 {
  59   g_free (handler);
  60 }
  61
  62 static GList *
  63 cspi_event_list_remove_by_cb (GList *list, gpointer callback)
  64 {
  65   GList *l, *next;
  66
  67   for (l = list; l; l = next)
  68     {
  69       EventHandler *eh = l->data;
  70       next = l->next;
  71
  72       list = g_list_delete_link (list, l);
  73
  74       cspi_event_handler_free (eh);
  75     }
  76
  77   return list;
  78 }
  79
  80 /*
  81  * Standard event dispatcher
  82  */
  83
  84 BONOBO_CLASS_BOILERPLATE (CSpiEventListener, cspi_event_listener,
  85                           GObject, spi_event_listener_get_type ())
  86
  87 static void
  88 cspi_event (SpiEventListener    *listener,
  89             Accessibility_Event *event)
  90 {
  91   GList *l;
  92   CSpiEventListener *clistener = (CSpiEventListener *) listener;
  93   AccessibleEvent    aevent;
  94   Accessible        *source;
  95
  96   source = cspi_object_add_ref (event->source, TRUE);
  97
  98   aevent.type    = event->type;
  99   aevent.source  = source;
 100   aevent.detail1 = event->detail1;
 101   aevent.detail2 = event->detail2;
 102
 103   /* FIXME: re-enterancy hazard on this list */
 104   for (l = clistener->callbacks; l; l = l->next)
 105     {
 106       EventHandler *eh = l->data;
 107
 108       eh->cb.event (&aevent, eh->user_data);
 109     }
 110
 111   cspi_object_unref (source);
 112 }
 113
 114 static void
 115 cspi_event_listener_instance_init (CSpiEventListener *listener)
 116 {
 117 }
 118
 119 static void
 120 cspi_event_listener_finalize (GObject *object)
 121 {
 122   CSpiEventListener *listener = (CSpiEventListener *) object;
 123   GList *l;
 124
 125   for (l = listener->callbacks; l; l = l->next)
 126     {
 127       cspi_event_handler_free (l->data);
 128     }
 129
 130   g_list_free (listener->callbacks);
 131
 132   event_parent_class->finalize (object);
 133 }
 134
 135 static void
 136 cspi_event_listener_class_init (CSpiEventListenerClass *klass)
 137 {
 138   GObjectClass *object_class = (GObjectClass *) klass;
 139
 140   event_parent_class = g_type_class_peek_parent (klass);
 141   object_class->finalize = cspi_event_listener_finalize;
 142
 143   klass->event = cspi_event;
 144 }
 145
 146 gpointer
 147 cspi_event_listener_new (void)
 148 {
 149   CSpiEventListener *listener;
 150
 151   listener = g_object_new (cspi_event_listener_get_type (), NULL);
 152
 153   return listener;
 154 }
 155
 156 void
 157 cspi_event_listener_add_cb (AccessibleEventListener  *al,
 158                             AccessibleEventListenerCB callback,
 159                             void                     *user_data)
 160 {
 161   CSpiEventListener *listener = al;
 162
 163   g_return_if_fail (CSPI_IS_EVENT_LISTENER (listener));
 164
 165   listener->callbacks = g_list_prepend (listener->callbacks,
 166                                         cspi_event_handler_new (callback, user_data));
 167 }
 168
 169 void
 170 cspi_event_listener_remove_cb (AccessibleEventListener  *al,
 171                                AccessibleEventListenerCB callback)
 172 {
 173   CSpiEventListener *listener = al;
 174
 175   g_return_if_fail (CSPI_IS_EVENT_LISTENER (listener));
 176
 177   listener->callbacks = cspi_event_list_remove_by_cb (listener->callbacks, callback);
 178 }
 179
 180 /*
 181  * Key event dispatcher
 182  */
 183 static gboolean
 184 cspi_key_event (SpiKeystrokeListener            *listener,
 185                 const Accessibility_DeviceEvent *keystroke)
 186 {
 187   GList *l;
 188   CSpiKeystrokeListener *clistener = (CSpiKeystrokeListener *) listener;
 189   AccessibleKeystroke akeystroke;
 190   gboolean handled = FALSE;
 191
 192 #ifdef SPI_KEYEVENT_DEBUG
 193   fprintf (stderr, "%s%c",
 194            (keystroke->modifiers & SPI_KEYMASK_ALT)?"Alt-":"",
 195            ((keystroke->modifiers & SPI_KEYMASK_SHIFT)^(keystroke->modifiers & SPI_KEYMASK_SHIFTLOCK))?
 196            (char) toupper((int) keystroke->keyID) : (char) tolower((int) keystroke->keyID));
 197
 198   fprintf (stderr, "Key:\tsym %ld\n\tmods %x\n\tcode %d\n\ttime %ld\n",
 199            (long) keystroke->keyID,
 200            (unsigned int) keystroke->modifiers,
 201            (int) keystroke->keycode,
 202            (long int) keystroke->timestamp);
 203 #endif
 204
 205   switch (keystroke->type)
 206     {
 207       case Accessibility_KEY_PRESSED:
 208         akeystroke.type = SPI_KEY_PRESSED;
 209         break;
 210       case Accessibility_KEY_RELEASED:
 211         akeystroke.type = SPI_KEY_RELEASED;
 212         break;
 213       default:
 214         akeystroke.type = 0;
 215         break;
 216     }
 217   akeystroke.keyID     = keystroke->id;
 218   akeystroke.keycode   = keystroke->hw_code;
 219   akeystroke.timestamp = keystroke->timestamp;
 220   akeystroke.keystring = g_strdup (keystroke->event_string);
 221   akeystroke.modifiers = keystroke->modifiers;
 222
 223   /* FIXME: re-enterancy hazard on this list */
 224   for (l = clistener->callbacks; l; l = l->next)
 225     {
 226       EventHandler *eh = l->data;
 227
 228       if ((handled = eh->cb.key_event (&akeystroke, eh->user_data)))
 229         {
 230           break;
 231         }
 232     }
 233
 234   return handled;
 235 }
 236
 237 static void
 238 cspi_keystroke_listener_init (CSpiKeystrokeListener *listener)
 239 {
 240 }
 241
 242
 243 static void
 244 cspi_keystroke_listener_finalize (GObject *object)
 245 {
 246   CSpiKeystrokeListener *listener = (CSpiKeystrokeListener *) object;
 247   GList *l;
 248
 249   for (l = listener->callbacks; l; l = l->next)
 250     {
 251       cspi_event_handler_free (l->data);
 252     }
 253
 254   g_list_free (listener->callbacks);
 255
 256   keystroke_parent_class->finalize (object);
 257 }
 258
 259 static void
 260 cspi_keystroke_listener_class_init (CSpiKeystrokeListenerClass *klass)
 261 {
 262   GObjectClass *object_class = (GObjectClass *) klass;
 263
 264   keystroke_parent_class = g_type_class_peek_parent (klass);
 265   object_class->finalize = cspi_keystroke_listener_finalize;
 266
 267   klass->key_event = cspi_key_event;
 268 }
 269
 270 BONOBO_TYPE_FUNC (CSpiKeystrokeListener,
 271                   spi_keystroke_listener_get_type (),
 272                   cspi_keystroke_listener);
 273
 274 gpointer
 275 cspi_keystroke_listener_new (void)
 276 {
 277   CSpiEventListener *listener;
 278
 279   listener = g_object_new (cspi_keystroke_listener_get_type (), NULL);
 280
 281   return listener;
 282 }
 283
 284 void
 285 cspi_keystroke_listener_add_cb (AccessibleKeystrokeListener  *al,
 286                                 AccessibleKeystrokeListenerCB callback,
 287                                 void                         *user_data)
 288 {
 289   CSpiKeystrokeListener *listener = al;
 290
 291   g_return_if_fail (CSPI_IS_KEYSTROKE_LISTENER (listener));
 292
 293   listener->callbacks = g_list_prepend (listener->callbacks,
 294                                         cspi_event_handler_new (callback, user_data));
 295 }
 296
 297 void
 298 cspi_keystroke_listener_remove_cb (AccessibleKeystrokeListener  *al,
 299                                    AccessibleKeystrokeListenerCB callback)
 300 {
 301   CSpiKeystrokeListener *listener = al;
 302
 303   g_return_if_fail (CSPI_IS_KEYSTROKE_LISTENER (listener));
 304
 305   listener->callbacks = cspi_event_list_remove_by_cb (listener->callbacks, callback);
 306 }
 307
 308 void
 309 cspi_event_listener_unref (AccessibleEventListener *listener)
 310 {
 311   bonobo_object_unref (BONOBO_OBJECT (listener));
 312 }
 313
 314 void
 315 cspi_keystroke_listener_unref (AccessibleKeystrokeListener *listener)
 316 {
 317   bonobo_object_unref (BONOBO_OBJECT (listener));
 318 }
 319
 320
 321 CORBA_Object
 322 cspi_event_listener_get_corba (AccessibleEventListener *listener)
 323 {
 324   return BONOBO_OBJREF (listener);
 325 }
 326
 327 CORBA_Object
 328 cspi_keystroke_listener_get_corba (AccessibleKeystrokeListener *listener)
 329 {
 330   return BONOBO_OBJREF (listener);
 331 }
 332