X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi-listener.h;h=19846c471764bd72a076653ed5d3166ad31bd49e;hb=b6a9e880c09f13a391a2a23b0dd685a518fe61a1;hp=0f9e6003c3a2471bde581c82afa06cafbec3d553;hpb=fd46827d0ef868929e7c255334b73adf2e305a85;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi-listener.h b/cspi/spi-listener.h index 0f9e600..19846c4 100644 --- a/cspi/spi-listener.h +++ b/cspi/spi-listener.h @@ -1,33 +1,120 @@ +/* + * AT-SPI - Assistive Technology Service Provider Interface + * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) + * + * Copyright 2001, 2002 Sun Microsystems Inc., + * Copyright 2001, 2002 Ximian, 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. + */ + #ifndef _SPI_LISTENER_H_ #define _SPI_LISTENER_H_ #include +#include +#include "common/spi-types.h" -G_BEGIN_DECLS +#ifdef __cplusplus +extern "C" { +#endif -/* - * Structure used to encapsulate event information - */ +typedef enum +{ + EVENT_DATA_STRING, + EVENT_DATA_OBJECT, + EVENT_DATA_RECT +} EVENT_DATA_TYPE; + +/** + * AccessibleEvent: + * @type: a string representing the type of the event, with increasing specificity + * from left to right, delimited by colons. Leftmost token represents event source type, + * next token represents event category, and next token represents the subcategory + * of the event, for instance the specific property, state, or attribute being notified. + * @source: The #Accessible from which the event originated. + * @detail1: an event-type-specific integer value. + * @detail2: an event-type-specific integer value. + * + * A structure used to encapsulate event information. + **/ typedef struct { const char *type; Accessible *source; long detail1; long detail2; + EVENT_DATA_TYPE v_type; + union + { + char *text; + Accessible *accessible; + SPIRect rect; + } v; } AccessibleEvent; +/** + *AccessibleDeviceEventType: + *@SPI_KEY_PRESSED: A device key has been pressed. + *@SPI_KEY_RELEASED: A device key has been released. + *@SPI_BUTTON_PRESSED: A device button or switch (other than a keyboard key) + * has been pressed. + *@SPI_BUTTON_RELEASED: A device button or switch has been released. + * + *The type of an AccessibleDeviceEvent. + **/ typedef enum { SPI_KEY_PRESSED = 1<<0, - SPI_KEY_RELEASED = 1<<1 -} AccessibleKeyEventType; + SPI_KEY_RELEASED = 1<<1, + SPI_BUTTON_PRESSED = 1<<2, + SPI_BUTTON_RELEASED = 1<<3 +} AccessibleDeviceEventType; +/** + *AccessibleKeyEventType: + * + *This is a synonym for AccessibleDeviceEventType + **/ +typedef AccessibleDeviceEventType AccessibleKeyEventType; +/** + * AccessibleDeviceEvent: + * @keyID: Symbolic representation for the key or switch generating the event, e.g. keysym or button number. + * @keystring: A symbolic name for the key or switch, or, if is_text is true, a string approximating the + * inserted text characters which would result from this event, if a text entry field has keyboard focus. + * @timestamp: A time in ms when this event occurred, relative to some unspecified starting point. + * Timestamp values should therefore be used to compare events but should not be tested against a + * fixed time. + * @type: The #AccessibleDeviceEventType identifying the specific type of event. + * @is_text: A boolean value indicating whether the event represents 'printable' text (i.e. whether it + * changes the current insertion buffer of a focussed text entry component or not). Whitespace + * is considered "printable" in this context, since it typically inserts characters into the buffer. + * + * A structure encapsulating information relevant to a device event notification. + **/ typedef struct { long keyID; short keycode; + char * keystring; long timestamp; - AccessibleKeyEventType type; + AccessibleDeviceEventType type; unsigned short modifiers; -} AccessibleKeystroke; + SPIBoolean is_text; +} AccessibleDeviceEvent; + +typedef AccessibleDeviceEvent AccessibleKeystroke; /* * Function prototype typedefs for Event Listener Callbacks. @@ -37,12 +124,97 @@ typedef struct { * void (*AccessibleEventListenerCB) (AccessibleEvent *event); * * SPIBoolean (*AccessibleKeystrokeListenerCB) (AccessibleKeystrokeEvent *Event); + * Note that AccessibleKeystrokeListeners may consume the event received + * if one of their callbacks returns TRUE (see SPI_registerAccessibleKeystrokeListener) */ -typedef void (*AccessibleEventListenerCB) (AccessibleEvent *event, - void *user_data); -typedef SPIBoolean (*AccessibleKeystrokeListenerCB) (AccessibleKeystroke *stroke, - void *user_data); -G_END_DECLS +/** + * AccessibleEventListenerCB: + * @event: The event for which notification is sent. + * @user_data: User data which is passed to the callback each time a notification takes place. + * + * A function prototype for callbacks via which clients are notified of AT-SPI events. + * + **/ +typedef void (*AccessibleEventListenerCB) (const AccessibleEvent *event, + void *user_data); +/** + * AccessibleKeystrokeListenerCB: + * @stroke: the #AccessibleKeystroke event for which notification is taking place. + * @user_data: data passed to the callback each time it is notified, according to the data + * which was passed in when the listener/callback was registered. + * + * A function prototype for a callback function called when a key event notification takes place. + * + * Returns: %TRUE if the client wishes to consume the event and prevent its + * dispatch to other listeners or the currently focussed application, if + * the relevant callback was registered with the #SPI_KEYLISTENER_CANCONSUME flag. + **/ +typedef SPIBoolean (*AccessibleKeystrokeListenerCB) (const AccessibleKeystroke *stroke, + void *user_data); +/** + * AccessibleDeviceListenerCB: + * @stroke: The #AccessibleDeviceEvent for which notification is being received. + * @user_data: Data which is passed to the client each time this callback is notified. + * + * A callback function prototype via which clients receive device event notifications. + * + * Returns: %TRUE if the client wishes to consume/preempt the event, preventing it from being + * relayed to the currently focussed application, %FALSE if the event delivery should proceed as normal. + **/ +typedef SPIBoolean (*AccessibleDeviceListenerCB) (const AccessibleDeviceEvent *stroke, + void *user_data); + +#define CSPI_EVENT_LISTENER_TYPE (cspi_event_listener_get_type ()) +#define CSPI_EVENT_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), CSPI_EVENT_LISTENER_TYPE, CSpiEventListener)) +#define CSPI_EVENT_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), CSPI_EVENT_LISTENER_TYPE, CSpiEventListenerClass)) +#define CSPI_IS_EVENT_LISTENER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), CSPI_EVENT_LISTENER_TYPE)) +#define CSPI_IS_EVENT_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), CSPI_EVENT_LISTENER_TYPE)) +#define CSPI_EVENT_LISTENER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CSPI_EVENT_LISTENER_TYPE, CSpiEventListenerClass)) + +typedef struct { + GObject parent; + GList *callbacks; +} CSpiEventListener; + +typedef struct { + GObjectClass parent_class; + + /* signals */ + void (*event) (CSpiEventListener *listener, + AccessibleEvent *e); +} CSpiEventListenerClass; + +GType cspi_event_listener_get_type (void); + +#define CSPI_DEVICE_LISTENER_TYPE (cspi_device_listener_get_type ()) +#define CSPI_DEVICE_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), CSPI_DEVICE_LISTENER_TYPE, CSpiDeviceListener)) +#define CSPI_DEVICE_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), CSPI_DEVICE_LISTENER_TYPE, CSpiDeviceListenerClass)) +#define CSPI_IS_DEVICE_LISTENER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), CSPI_DEVICE_LISTENER_TYPE)) +#define CSPI_IS_DEVICE_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), CSPI_DEVICE_LISTENER_TYPE)) +#define CSPI_DEVICE_LISTENER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CSPI_DEVICE_LISTENER_TYPE, CSpiDeviceListenerClass)) + +typedef struct { + GObject parent; + guint id; + GList *callbacks; +} CSpiDeviceListener; + +typedef struct { + GObjectClass parent_class; + gboolean (*device_event) (CSpiDeviceListener *listener, const Accessibility_DeviceEvent *key); +} CSpiDeviceListenerClass; + +GType cspi_device_listener_get_type (void); +gpointer cspi_device_listener_new (void); +void cspi_device_listener_add_cb (AccessibleDeviceListener *al, + AccessibleDeviceListenerCB callback, + void *user_data); +void cspi_device_listener_remove_cb (AccessibleDeviceListener *al, + AccessibleDeviceListenerCB callback); +void cspi_device_listener_unref (AccessibleDeviceListener *listener); +#ifdef __cplusplus +} +#endif #endif