-#include <cspi/spi-private.h>
-#include <cspi/spi-listener-impl.h>
+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
+ *
+ * Copyright 2002 Ximian Inc.
+ * Copyright 2002 Sun Microsystems, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <libbonobo.h>
+#include "../spi-private.h"
+#include "cspi-bonobo-listener.h"
+
+typedef struct
+{
+ union
+ {
+ AccessibleEventListenerCB event;
+ AccessibleDeviceListenerCB device_event;
+ gpointer method;
+ } cb;
+ gpointer user_data;
+} EventHandler;
+
+GObjectClass *event_parent_class;
+GObjectClass *device_parent_class;
+
+static guint32 _e_id = 0;
+
+/*
+ * Misc. helpers.
+ */
+
+static EventHandler *
+cspi_event_handler_new (gpointer method, gpointer user_data)
+{
+ EventHandler *eh = g_new0 (EventHandler, 1);
+
+ eh->cb.method = method;
+ eh->user_data = user_data;
+
+ return eh;
+}
+
+static void
+cspi_event_handler_free (EventHandler *handler)
+{
+ g_free (handler);
+}
+
+static GList *
+cspi_event_list_remove_by_cb (GList *list, gpointer callback)
+{
+ GList *l, *next;
+
+ for (l = list; l; l = next)
+ {
+ EventHandler *eh = l->data;
+ next = l->next;
+
+ list = g_list_delete_link (list, l);
+
+ cspi_event_handler_free (eh);
+ }
+
+ return list;
+}
/*
* Standard event dispatcher
cspi_event (SpiEventListener *listener,
Accessibility_Event *event)
{
- GSList *l;
+ GList *l;
CSpiEventListener *clistener = (CSpiEventListener *) listener;
- AccessibleEvent aevent;
-
- aevent.type = event->type;
- aevent.source = cspi_object_add (event->source);
- aevent.detail1 = event->detail1;
- aevent.detail2 = event->detail2;
+ InternalEvent aevent;
+ Accessible *source = cspi_object_borrow (event->source);
+
+ aevent.event.type = event->type;
+ aevent.event.source = source;
+ aevent.event.detail1 = event->detail1;
+ aevent.event.detail2 = event->detail2;
+ aevent.id = _e_id++;
+ aevent.magic = SPI_INTERNAL_EVENT_MAGIC;
+ aevent.ref_count = 0;
+ aevent.data = &event->any_data;
+ /* FIXME: re-enterancy hazard on this list */
for (l = clistener->callbacks; l; l = l->next)
{
- AccessibleEventListenerCB cb = l->data;
- cb (&aevent);
+ EventHandler *eh = l->data;
+ /* cast hides our private stuff from client handlers */
+ eh->cb.event ((AccessibleEvent *) &aevent, eh->user_data);
}
-
- cspi_object_unref (aevent.source);
+
+ cspi_object_return (source);
}
static void
}
static void
+cspi_event_listener_finalize (GObject *object)
+{
+ CSpiEventListener *listener = (CSpiEventListener *) object;
+ GList *l;
+
+ for (l = listener->callbacks; l; l = l->next)
+ {
+ cspi_event_handler_free (l->data);
+ }
+
+ g_list_free (listener->callbacks);
+
+ event_parent_class->finalize (object);
+}
+
+static void
cspi_event_listener_class_init (CSpiEventListenerClass *klass)
{
+ GObjectClass *object_class = (GObjectClass *) klass;
+
+ event_parent_class = g_type_class_peek_parent (klass);
+ object_class->finalize = cspi_event_listener_finalize;
+
klass->event = cspi_event;
}
-CSpiEventListener *
+gpointer
cspi_event_listener_new (void)
{
- return g_object_new (spi_event_listener_get_type (), NULL);
+ CSpiEventListener *listener;
+
+ listener = g_object_new (cspi_event_listener_get_type (), NULL);
+
+ return listener;
}
void
-cspi_event_listener_add_callback (CSpiEventListener *listener,
- AccessibleEventListenerCB callback)
+cspi_event_listener_add_cb (AccessibleEventListener *al,
+ AccessibleEventListenerCB callback,
+ void *user_data)
{
- g_return_if_fail (IS_CSPI_KEYSTROKE_LISTENER (listener));
- listener->callbacks = g_slist_prepend (listener->callbacks, callback);
+ CSpiEventListener *listener = al;
+
+ g_return_if_fail (CSPI_IS_EVENT_LISTENER (listener));
+
+ listener->callbacks = g_list_prepend (listener->callbacks,
+ cspi_event_handler_new ((void *) callback, user_data));
}
void
-cspi_event_listener_remove_callback (CSpiEventListener *listener,
- AccessibleEventListenerCB callback)
+cspi_event_listener_remove_cb (AccessibleEventListener *al,
+ AccessibleEventListenerCB callback)
{
- g_return_if_fail (IS_CSPI_KEYSTROKE_LISTENER (listener));
- listener->callbacks = g_slist_remove (listener->callbacks, callback);
+ CSpiEventListener *listener = al;
+
+ g_return_if_fail (CSPI_IS_EVENT_LISTENER (listener));
+
+ listener->callbacks = cspi_event_list_remove_by_cb (listener->callbacks, (void *) callback);
}
-/*
- * Key event dispatcher
+/*
+ * Device event handler
*/
-
static gboolean
-cspi_key_event (SpiKeystrokeListener *listener,
- const Accessibility_KeyStroke *keystroke)
+cspi_device_event (SpiDeviceListener *listener,
+ const Accessibility_DeviceEvent *event)
{
- GSList *l;
- CSpiKeystrokeListener *clistener = (CSpiKeystrokeListener *) listener;
- AccessibleKeystroke akeystroke;
+ GList *l;
+ CSpiDeviceListener *clistener = (CSpiDeviceListener *) listener;
+ AccessibleDeviceEvent anevent;
gboolean handled = FALSE;
- switch (keystroke->type)
+ switch (event->type)
{
- case Accessibility_KEY_PRESSED:
- akeystroke.type = SPI_KEY_PRESSED;
+ case Accessibility_KEY_PRESSED_EVENT:
+ anevent.type = SPI_KEY_PRESSED;
+ break;
+ case Accessibility_KEY_RELEASED_EVENT:
+ anevent.type = SPI_KEY_RELEASED;
+ break;
+ case Accessibility_BUTTON_PRESSED_EVENT:
+ anevent.type = SPI_BUTTON_PRESSED;
break;
- case Accessibility_KEY_RELEASED:
- akeystroke.type = SPI_KEY_RELEASED;
+ case Accessibility_BUTTON_RELEASED_EVENT:
+ anevent.type = SPI_BUTTON_RELEASED;
break;
default:
- akeystroke.type = 0;
+ anevent.type = 0;
break;
}
- akeystroke.keyID = keystroke->keyID;
- akeystroke.keycode = keystroke->keycode;
- akeystroke.timestamp = keystroke->timestamp;
- akeystroke.modifiers = keystroke->modifiers;
+ anevent.keyID = event->id;
+ anevent.keycode = event->hw_code;
+ anevent.timestamp = event->timestamp;
+ anevent.keystring = g_strdup (event->event_string);
+ anevent.modifiers = event->modifiers;
+ anevent.is_text = event->is_text;
+ /* FIXME: re-enterancy hazard on this list */
for (l = clistener->callbacks; l; l = l->next)
{
- AccessibleKeystrokeListenerCB cb = l->data;
- if ((handled = cb (&akeystroke)))
+ EventHandler *eh = l->data;
+
+ if ((handled = eh->cb.device_event (&anevent, eh->user_data)))
{
break;
}
}
static void
-cspi_keystroke_listener_init (CSpiKeystrokeListener *listener)
+cspi_device_listener_init (CSpiDeviceListener *listener)
{
}
static void
-cspi_keystroke_listener_class_init (CSpiKeystrokeListenerClass *klass)
+cspi_device_listener_finalize (GObject *object)
+{
+ CSpiDeviceListener *listener = (CSpiDeviceListener *) object;
+ GList *l;
+
+ for (l = listener->callbacks; l; l = l->next)
+ {
+ cspi_event_handler_free (l->data);
+ }
+
+ g_list_free (listener->callbacks);
+
+ device_parent_class->finalize (object);
+}
+
+static void
+cspi_device_listener_class_init (CSpiDeviceListenerClass *klass)
+{
+ GObjectClass *object_class = (GObjectClass *) klass;
+
+ device_parent_class = g_type_class_peek_parent (klass);
+ object_class->finalize = cspi_device_listener_finalize;
+
+ klass->device_event = cspi_device_event;
+}
+
+BONOBO_TYPE_FUNC (CSpiDeviceListener,
+ spi_device_listener_get_type (),
+ cspi_device_listener)
+
+gpointer
+cspi_device_listener_new (void)
{
- klass->key_event = cspi_key_event;
+ CSpiEventListener *listener = g_object_new (cspi_device_listener_get_type (), NULL);
+
+ return listener;
}
-BONOBO_TYPE_FUNC (CSpiKeystrokeListener,
- spi_keystroke_listener_get_type (),
- cspi_keystroke_listener);
+void
+cspi_device_listener_add_cb (AccessibleDeviceListener *al,
+ AccessibleDeviceListenerCB callback,
+ void *user_data)
+{
+ CSpiDeviceListener *listener = al;
+
+ g_return_if_fail (CSPI_IS_DEVICE_LISTENER (listener));
-CSpiKeystrokeListener *
-cspi_keystroke_listener_new (void)
+ listener->callbacks = g_list_prepend (listener->callbacks,
+ cspi_event_handler_new ((void *)callback, user_data));
+}
+
+void
+cspi_device_listener_remove_cb (AccessibleDeviceListener *al,
+ AccessibleDeviceListenerCB callback)
{
- return g_object_new (spi_keystroke_listener_get_type (), NULL);
+ CSpiDeviceListener *listener = al;
+
+ g_return_if_fail (CSPI_IS_DEVICE_LISTENER (listener));
+
+ listener->callbacks = cspi_event_list_remove_by_cb (listener->callbacks, (void *) callback);
}
void
-cspi_keystroke_listener_add_callback (CSpiKeystrokeListener *listener,
- AccessibleKeystrokeListenerCB callback)
+cspi_event_listener_unref (AccessibleEventListener *listener)
{
- g_return_if_fail (IS_CSPI_KEYSTROKE_LISTENER (listener));
- listener->callbacks = g_slist_prepend (listener->callbacks, callback);
+ bonobo_object_unref (BONOBO_OBJECT (listener));
}
void
-cspi_keystroke_listener_remove_callback (CSpiKeystrokeListener *listener,
- AccessibleKeystrokeListenerCB callback)
+cspi_device_listener_unref (AccessibleDeviceListener *listener)
+{
+ bonobo_object_unref (BONOBO_OBJECT (listener));
+}
+
+
+CORBA_Object
+cspi_event_listener_get_corba (AccessibleEventListener *listener)
{
- g_return_if_fail (IS_CSPI_KEYSTROKE_LISTENER (listener));
- listener->callbacks = g_slist_remove (listener->callbacks, callback);
+ return BONOBO_OBJREF (listener);
}
+
+CORBA_Object
+cspi_device_listener_get_corba (AccessibleDeviceListener *listener)
+{
+ return BONOBO_OBJREF (listener);
+}
+
projects / platform / core / uifw / at-spi2-atk.git / blobdiff