X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi-listener.h;h=19846c471764bd72a076653ed5d3166ad31bd49e;hb=b6a9e880c09f13a391a2a23b0dd685a518fe61a1;hp=81029d713dae82588697d947f998ac38b648d31c;hpb=3af8a4e874f524c212a01e4469db1c8043f1427f;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi-listener.h b/cspi/spi-listener.h index 81029d7..19846c4 100644 --- a/cspi/spi-listener.h +++ b/cspi/spi-listener.h @@ -25,29 +25,56 @@ #define _SPI_LISTENER_H_ #include +#include +#include "common/spi-types.h" #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; - -/* - * For internal use by CSPI implementation only - */ -typedef struct { - AccessibleEvent event; - void *data; -} InternalEvent; +/** + *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, @@ -55,8 +82,28 @@ typedef enum { 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; @@ -77,14 +124,95 @@ typedef AccessibleDeviceEvent AccessibleKeystroke; * 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) */ + +/** + * 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