Update TODO, and also unref deviceeventcontroller when
[platform/core/uifw/at-spi2-atk.git] / cspi / spi_event.c
1 /*
2  * AT-SPI - Assistive Technology Service Provider Interface
3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
4  *
5  * Copyright 2001, 2002, 2003 Sun Microsystems Inc.,
6  * Copyright 2001, 2002, 2003 Ximian, Inc.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 #include <cspi/spi-private.h>
25 #include <cspi/bonobo/cspi-bonobo-listener.h>
26
27 static GSList *_cspi_event_queue = NULL;
28
29 /**
30  * SPI_freeAccessibleKeySet:
31  * @keyset: An AccessibleKeyset to free.
32  *
33  * Release the memory used by an AccessibleKeySet.
34  *
35  **/
36 void
37 SPI_freeAccessibleKeySet (AccessibleKeySet *keyset)
38 {
39   int i = 0;    
40   g_free (keyset->keysyms);
41   g_free (keyset->keycodes);
42   while (keyset->keystrings [i])
43     {
44       g_free (keyset->keystrings [i++]);
45     }
46   g_free (keyset->keystrings);
47   g_free (keyset);
48 }
49
50 /**
51  * SPI_createAccessibleKeySet:
52  * @len: the number of key values in the key set.
53  * @keysyms: a UTF-8 string containing symbolic key values to be matched, or NULL if
54  *           matching is performed against other key values instead.
55  * @keycodes: an array of unsigned short values which are the hardware keycodes
56  *           to be matched, or NULL if the keyset is specified solely by keysyms
57  *           and/or keystrings.
58  * @keystrings: an array of null-terminated character strings which specify key
59  *             name values to match, or NULL if the keyset is specified solely by
60  *             keycodes and/or keysyms.
61  *
62  * Create a new #AccessibleKeySet of a specified length.
63  * A KeySet is used typically to match key event values, and a matches are made
64  * using the following criteria: a match exists with a key event if all non-null
65  * i-th members of the keyset match the key event.
66  * If both keystring and keysym values are NULL, a keycode value match is
67  * forced, thus the match for keysym=0, keycode=0, keystring=NULL is
68  * keycode 0.
69  *
70  * Returns: a pointer to a newly-created #AccessibleKeySet.
71  *
72  **/
73 AccessibleKeySet *
74 SPI_createAccessibleKeySet (int len, const char *keysyms, short *keycodes,
75                             const char **keystrings)
76 {
77   AccessibleKeySet *keyset = g_new0 (AccessibleKeySet, 1);
78   int i, keysym_len = 0;
79   const char *keysym_ptr = keysyms;
80   keyset->len = len;
81   keyset->keysyms = g_new0 (unsigned long, len);
82   keyset->keycodes = g_new0 (unsigned short, len);
83   keyset->keystrings = g_new0 (char *, len);
84   if (keysyms)
85     {
86       keysym_len = g_utf8_strlen (keysyms, -1);
87     }
88   for (i = 0; i < len; ++i)
89     {
90       if (i < keysym_len)
91         {
92           keyset->keysyms [i] = (unsigned long) g_utf8_get_char (keysym_ptr);
93           keysym_ptr = g_utf8_find_next_char (keysym_ptr, NULL);
94         }
95       else
96         {
97           keyset->keysyms [i] = 0;
98         }
99       if (keycodes)
100         {
101           keyset->keycodes [i] = keycodes [i];
102         }
103       if (keystrings)
104         {
105           keyset->keystrings [i] = g_strdup (keystrings [i]);
106         }
107     }
108   return keyset;        
109 }
110
111 /**
112  * SPI_createAccessibleEventListener:
113  * @callback : an #AccessibleEventListenerCB callback function, or NULL.
114  * @user_data: a pointer to data which will be passed to the callback when invoked.
115  *
116  * Create a new #AccessibleEventListener with a specified (in-process) callback function.
117  *
118  * Returns: a pointer to a newly-created #AccessibleEventListener.
119  *
120  **/
121 AccessibleEventListener *
122 SPI_createAccessibleEventListener (AccessibleEventListenerCB callback,
123                                    void                     *user_data)
124 {
125   AccessibleEventListener *listener = cspi_event_listener_new ();
126   if (callback)
127     {
128       AccessibleEventListener_addCallback (listener, callback, user_data);
129     }
130   return listener;
131 }
132
133 /**
134  * AccessibleEventListener_addCallback:
135  * @listener: the #AccessibleEventListener instance to modify.
136  * @callback: an #AccessibleEventListenerCB function pointer.
137  * @user_data: a pointer to data which will be passed to the callback when invoked.
138  *
139  * Add an in-process callback function to an existing AccessibleEventListener.
140  * Note that the callback function must live in the same address
141  * space as the AccessibleEventListener implementation code, thus one should not
142  * use this function to attach callbacks to a 'remote' event listener
143  * (that is, one that was not created by a client call to
144  * createAccessibleEventListener ();
145  *
146  * Returns: #TRUE if successful, otherwise #FALSE.
147  *
148  **/
149 SPIBoolean
150 AccessibleEventListener_addCallback (AccessibleEventListener *listener,
151                                      AccessibleEventListenerCB callback,
152                                      void                     *user_data)
153 {
154   cspi_event_listener_add_cb (listener, callback, user_data);
155   return TRUE;
156 }
157
158 /**
159  * AccessibleEventListener_unref:
160  * @listener: a pointer to the #AccessibleEventListener being operated on.
161  *
162  * Decrements an #AccessibleEventListener's reference count.
163  **/
164 void
165 AccessibleEventListener_unref (AccessibleEventListener *listener)
166 {
167   cspi_event_listener_unref (listener);
168 }
169
170 /**
171  * AccessibleEventListener_removeCallback:
172  * @listener: the #AccessibleEventListener instance to modify.
173  * @callback: an #AccessibleEventListenerCB function pointer.
174  *
175  * Remove an in-process callback function from an existing AccessibleEventListener.
176  *
177  * Returns: #TRUE if successful, otherwise #FALSE.
178  *
179  **/
180 SPIBoolean
181 AccessibleEventListener_removeCallback (AccessibleEventListener  *listener,
182                                         AccessibleEventListenerCB callback)
183 {
184   cspi_event_listener_remove_cb (listener, callback);
185   return TRUE;
186 }
187
188 /**
189  * SPI_createAccessibleKeystrokeListener:
190  * @callback : an #AccessibleKeystrokeListenerCB callback function, or NULL.
191  * @user_data: a pointer to data which will be passed to the callback when invoked.
192  *
193  * Create a new #AccessibleKeystrokeListener with a specified callback function.
194  *
195  * Returns: a pointer to a newly-created #AccessibleKeystrokeListener.
196  *
197  **/
198 AccessibleKeystrokeListener *
199 SPI_createAccessibleKeystrokeListener (AccessibleKeystrokeListenerCB callback,
200                                        void                         *user_data)
201 {
202   AccessibleDeviceListener *listener = cspi_device_listener_new ();
203   if (callback)
204     {
205       AccessibleDeviceListener_addCallback (listener, callback, user_data);
206     }
207   return listener;
208 }
209
210 /**
211  * AccessibleKeystrokeListener_addCallback:
212  * @listener: the #AccessibleKeystrokeListener instance to modify.
213  * @callback: an #AccessibleKeystrokeListenerCB function pointer.
214  * @user_data: a pointer to data which will be passed to the callback when invoked.
215  *
216  * Add an in-process callback function to an existing #AccessibleKeystrokeListener.
217  *
218  * Returns: #TRUE if successful, otherwise #FALSE.
219  *
220  **/
221 SPIBoolean
222 AccessibleKeystrokeListener_addCallback (AccessibleKeystrokeListener *listener,
223                                          AccessibleKeystrokeListenerCB callback,
224                                          void                         *user_data)
225 {
226   cspi_device_listener_add_cb (listener, callback, user_data);
227   return TRUE;
228 }
229
230 /**
231  * AccessibleKeystrokeListener_removeCallback:
232  * @listener: the #AccessibleKeystrokeListener instance to modify.
233  * @callback: an #AccessibleKeystrokeListenerCB function pointer.
234  *
235  * Remove an in-process callback function from an existing #AccessibleKeystrokeListener.
236  *
237  * Returns: #TRUE if successful, otherwise #FALSE.
238  *
239  **/
240 SPIBoolean
241 AccessibleKeystrokeListener_removeCallback (AccessibleKeystrokeListener *listener,
242                                             AccessibleKeystrokeListenerCB callback)
243 {
244   cspi_device_listener_remove_cb (listener, callback);
245   return TRUE;
246 }
247
248 /**
249  * AccessibleKeystrokeListener_unref:
250  * @listener: a pointer to the #AccessibleKeystrokeListener being operated on.
251  *
252  * Decrements an #AccessibleKeystrokeListener's reference count.
253  **/
254 void
255 AccessibleKeystrokeListener_unref (AccessibleKeystrokeListener *listener)
256 {
257   cspi_device_listener_unref (listener);
258 }
259
260 /**
261  * SPI_createAccessibleDeviceListener:
262  * @callback : an #AccessibleDeviceListenerCB callback function, or NULL.
263  * @user_data: a pointer to data which will be passed to the callback when invoked.
264  *
265  * Create a new #AccessibleDeviceListener with a specified callback function.
266  *
267  * Returns: a pointer to a newly-created #AccessibleDeviceListener.
268  *
269  **/
270 AccessibleDeviceListener *
271 SPI_createAccessibleDeviceListener (AccessibleDeviceListenerCB callback,
272                                        void                         *user_data)
273 {
274   AccessibleDeviceListener *listener = cspi_device_listener_new ();
275   if (callback)
276     {
277       AccessibleDeviceListener_addCallback (listener, callback, user_data);
278     }
279   return listener;
280 }
281
282 /**
283  * AccessibleDeviceListener_addCallback:
284  * @listener: the #AccessibleDeviceListener instance to modify.
285  * @callback: an #AccessibleDeviceListenerCB function pointer.
286  * @user_data: a pointer to data which will be passed to the callback when invoked.
287  *
288  * Add an in-process callback function to an existing #AccessibleDeviceListener.
289  *
290  * Returns: #TRUE if successful, otherwise #FALSE.
291  *
292  **/
293 SPIBoolean
294 AccessibleDeviceListener_addCallback (AccessibleDeviceListener *listener,
295                                          AccessibleDeviceListenerCB callback,
296                                          void                         *user_data)
297 {
298   cspi_device_listener_add_cb (listener, callback, user_data);
299   return TRUE;
300 }
301
302 /**
303  * AccessibleDeviceListener_removeCallback:
304  * @listener: the #AccessibleDeviceListener instance to modify.
305  * @callback: an #AccessibleDeviceListenerCB function pointer.
306  *
307  * Remove an in-process callback function from an existing #AccessibleDeviceListener.
308  *
309  * Returns: #TRUE if successful, otherwise #FALSE.
310  *
311  **/
312 SPIBoolean
313 AccessibleDeviceListener_removeCallback (AccessibleDeviceListener *listener,
314                                             AccessibleDeviceListenerCB callback)
315 {
316   cspi_device_listener_remove_cb (listener, callback);
317   return TRUE;
318 }
319
320 /**
321  * AccessibleDeviceListener_unref:
322  * @listener: a pointer to the #AccessibleDeviceListener being operated on.
323  *
324  * Decrements an #AccessibleDeviceListener's reference count.
325  **/
326 void
327 AccessibleDeviceListener_unref (AccessibleDeviceListener *listener)
328 {
329   cspi_device_listener_unref (listener);
330 }
331
332 static char *
333 cspi_internal_event_get_text (const InternalEvent *e)
334 {
335   CORBA_any *any;
336   g_return_val_if_fail (e, NULL);
337   g_return_val_if_fail (e->data, NULL);
338   any = (CORBA_any *) e->data;
339   if (CORBA_TypeCode_equivalent (any->_type, TC_CORBA_string, NULL)) 
340     {
341       return CORBA_string_dup (* (char **) any->_value);
342     } 
343   else
344     {
345 #ifdef EVENT_CONTEXT_DEBUG
346       fprintf (stderr, "requested string, TC is not TC_CORBA_string! (%u)\n",
347                (unsigned) any->_type);
348 #endif
349       return NULL;
350     }
351 }
352
353 static Accessible *
354 cspi_internal_event_get_object (const InternalEvent *e)
355 {
356   CORBA_any *any;
357
358   g_return_val_if_fail (e, NULL);
359   g_return_val_if_fail (e->data, NULL);
360
361   any = (CORBA_any *) e->data;
362   if (CORBA_TypeCode_equal (any->_type, TC_CORBA_Object, cspi_ev()))
363     return cspi_object_take (* (CORBA_Object *) any->_value);
364   else 
365     return NULL;
366 }
367
368 /**
369  * AccessibleTextChangedEvent_getChangeString:
370  * @e: a pointer to the #AccessibleEvent being queried.
371  *
372  * Queries an #AccessibleEvent of type "object:text-changed", 
373  *         returning the text inserted or deleted.
374  *
375  * Returns: a UTF-8 text string indicating the text inserted,
376  *          deleted, or substituted by this event.
377  **/
378 char *
379 AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e)
380 {
381   const InternalEvent *foo = (InternalEvent *) e;
382   /* TODO: check the event type. */
383   return cspi_internal_event_get_text (foo);
384 }
385
386 /**
387  * AccessibleTextSelectionChangedEvent_getSelectionString:
388  * @e: a pointer to the #AccessibleEvent being queried.
389  *
390  * Queries an #AccessibleEvent of type "object:text-selection-changed", 
391  *         returning the newly added, removed, or modified selection string.
392  *
393  * Returns: a UTF-8 text string indicating the recently changed selection.
394  **/
395 char *
396 AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e)
397 {
398   const InternalEvent *foo = (InternalEvent *) e;
399   /* TODO: check the event type. */
400   return cspi_internal_event_get_text (foo);
401 }
402
403 /**
404  * AccessibleWindowEvent_getTitleString:
405  * @e: a pointer to the #AccessibleEvent being queried.
406  *
407  * Queries an #AccessibleEvent of type "window:", 
408  *         returning the window title.
409  *
410  * Returns: a UTF-8 text string representing the title of the 
411  *         recently changed window.
412  **/
413 char *
414 AccessibleWindowEvent_getTitleString (const AccessibleEvent *e)
415 {
416   const InternalEvent *foo = (InternalEvent *) e;
417   /* TODO: check the event type. */
418   return cspi_internal_event_get_text (foo);
419 }
420
421 /**
422  * AccessibleChildChangedEvent_getChildAccessible:
423  * @e: a pointer to the #AccessibleEvent being queried.
424  *
425  * Queries an #AccessibleEvent of type "object:children_changed"
426  *         to get a reference to the changed #Accessible.
427  *         Note that context #Accessibles are not guaranteed to outlive
428  *         event delivery, in which case this call may return %NULL
429  *         even if the object existed at the time of dispatch.
430  *
431  * Returns: the context #Accessible for the event, or %NULL if
432  *          there is no longer a valid context #Accessible 
433  *          object for the event.
434  **/
435 Accessible *
436 AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e)
437 {
438   const InternalEvent *foo = (InternalEvent *) e;
439   return (Accessible *) cspi_internal_event_get_object (foo);
440 }
441
442 /**
443  * AccessibleParentChangedEvent_getParentAccessible:
444  * @e: a pointer to the #AccessibleEvent being queried.
445  *
446  * Queries an #AccessibleEvent of type "object:property-change:accessible-parent"
447  *         to get a reference to the changed #Accessible.
448  *         Note that context #Accessibles are not guaranteed to outlive
449  *         event delivery, in which case this call may return %NULL
450  *         even if the object existed at the time of dispatch.
451  *
452  * Returns: an #Accessible pointer representing the new parent object.
453  **/
454 Accessible *
455 AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e)
456 {
457   const InternalEvent *foo = (InternalEvent *) e;
458   return (Accessible *) cspi_internal_event_get_object (foo);
459 }
460
461 /**
462  * AccessibleActiveDescendantChangedEvent_getActiveDescendant:
463  * @e: a pointer to the #AccessibleEvent being queried.
464  *
465  * Queries an #AccessibleEvent of type "object:active-descendant-changed"
466  *         to get a reference to the changed #Accessible.
467  *         Note that context #Accessibles are not guaranteed to outlive
468  *         event delivery, in which case this call may return %NULL
469  *         even if the object existed at the time of dispatch.
470  *
471  * Returns: an #Accessible pointer representing the new active descendant.
472  **/
473 Accessible *
474 AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e) 
475 {
476   const InternalEvent *foo = (InternalEvent *) e;
477   return (Accessible *) cspi_internal_event_get_object (foo);
478 }
479
480 /**
481  * AccessibleTableSummaryChangedEvent_getSummaryAccessible:
482  * @e: a pointer to the #AccessibleEvent being queried.
483  *
484  * Queries an #AccessibleEvent of type "object:property-changed:accessible-table-summary"
485  *         to get a reference to the changed #Accessible.
486  *         Note that context #Accessibles are not guaranteed to outlive
487  *         event delivery, in which case this call may return %NULL
488  *         even if the object existed at the time of dispatch.
489  *
490  * Returns: an #Accessible pointer representing the new table summary.
491  **/
492 Accessible *
493 AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e) 
494 {
495   const InternalEvent *foo = (InternalEvent *) e;
496   return (Accessible *) cspi_internal_event_get_object (foo);
497 }
498
499 /**
500  * AccessibleTableHeaderChangedEvent_getHeaderAccessible:
501  * @e: a pointer to the #AccessibleEvent being queried.
502  *
503  * Queries an #AccessibleEvent of type 
504  *         "object:property-changed:accessible-table-row-header" or
505  *         "object:property-changed:accessible-table-column-header"
506  *         to get a reference to the changed #Accessible.
507  *         Note that context #Accessibles are not guaranteed to outlive
508  *         event delivery, in which case this call may return %NULL
509  *         even if the object existed at the time of dispatch.
510  *
511  * Returns: an #Accessible pointer representing the new table header.
512  **/
513 Accessible *
514 AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e)
515 {
516   const InternalEvent *foo = (InternalEvent *) e;
517   return (Accessible *) cspi_internal_event_get_object (foo);
518 }
519
520
521 /**
522  * AccessibleTableCaptionChangedEvent_getCaptionString:
523  * @e: a pointer to the #AccessibleEvent being queried.
524  *
525  * Queries an #AccessibleEvent of type 
526  *         "object:property-changed:accessible-table-caption-object" 
527  *         returning the text in the caption, if present.
528  *
529  * Returns: a UTF-8 text string indicating the text in the caption.
530  **/
531 char *
532 AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e)
533 {
534   const InternalEvent *foo = (InternalEvent *) e;
535   /* TODO: check the event type. */
536   return cspi_internal_event_get_text (foo);
537 }
538
539 /**
540  * AccessibleTableRowDescriptionChangedEvent_getDescriptionString:
541  * @e: a pointer to the #AccessibleEvent being queried.
542  *
543  * Queries an #AccessibleEvent of type 
544  *         "object:property-changed:accessible-table-row-description" 
545  *         returning the new table row description.
546  *
547  * Returns: a UTF-8 text string representing the recently changed
548  *         table row description 
549  **/
550 char *
551 AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e)
552 {
553   const InternalEvent *foo = (InternalEvent *) e;
554   /* TODO: check the event type. */
555   return cspi_internal_event_get_text (foo);
556 }
557
558 /**
559  * AccessibleTableColumnDescriptionChangedEvent_getDescriptionString:
560  * @e: a pointer to the #AccessibleEvent being queried.
561  *
562  * Queries an #AccessibleEvent of type 
563  *         "object:property-changed:accessible-table-column-description" 
564  *         returning the new table column description.
565  *
566  * Returns: a UTF-8 text string representing the recently changed
567  *         table column description 
568  **/
569 char *
570 AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e)
571 {
572   const InternalEvent *foo = (InternalEvent *) e;
573   /* TODO: check the event type. */
574   return cspi_internal_event_get_text (foo);
575 }
576
577 /**
578  * AccessibleDescriptionChangedEvent_getDescriptionString:
579  * @e: a pointer to the #AccessibleEvent being queried.
580  *
581  * Queries an #AccessibleEvent of type 
582  *         "object:property-changed:accessible-description" 
583  *         returning the new description.
584  *
585  * Returns: a UTF-8 text string representing the recently changed
586  *         description 
587  **/
588 char *
589 AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e)
590 {
591   const InternalEvent *foo = (InternalEvent *) e;
592   /* TODO: check the event type. */
593   return cspi_internal_event_get_text (foo);
594 }
595
596 static gint
597 cspi_event_compare (gconstpointer p1, gconstpointer p2)
598 {
599   const InternalEvent *e1 = p1, *e2 = p2;
600   return (gint) ((long) e2->id  - (long) e1->id);
601 }
602
603 static InternalEvent *
604 cspi_internal_event_lookup (const InternalEvent *e)
605 {
606   InternalEvent *internal = NULL;
607   GSList *p =
608     g_slist_find_custom (_cspi_event_queue, e, cspi_event_compare);
609   if (p)
610     internal = p->data;
611   return internal;
612 }
613
614 static const InternalEvent *
615 cspi_internal_event_check (const AccessibleEvent *e)
616 {
617   InternalEvent *internal = (InternalEvent *) e;
618   if (internal->magic == SPI_INTERNAL_EVENT_MAGIC) 
619     return internal;
620   else
621     return NULL;
622 }
623
624 static InternalEvent *
625 cspi_internal_event_add (const InternalEvent *e)
626 {
627   _cspi_event_queue = g_slist_prepend (_cspi_event_queue, (gpointer) e);
628   return (InternalEvent *) e;
629 }
630
631 static void
632 cspi_internal_event_remove (const InternalEvent *e)
633 {
634   GSList *link = g_slist_find_custom (_cspi_event_queue, e, cspi_event_compare);
635   if (link)
636     _cspi_event_queue = g_slist_remove_link (_cspi_event_queue, link);
637 }
638
639 /**
640  * AccessibleNameChangedEvent_getNameString:
641  * @e: a pointer to the #AccessibleEvent being queried.
642  *
643  * Queries an #AccessibleEvent of type "object:property-change:accessible_name:", 
644  *         returning the name.
645  *
646  * Returns: a UTF-8 text string representing the name of the 
647  *         object which recently changed.
648  **/
649 char *
650 AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e)
651 {
652   const InternalEvent *foo = (InternalEvent *) e;
653   return cspi_internal_event_get_text (foo);
654 }
655
656 /**
657  * AccessibleEvent_ref:
658  * @e: a pointer to the #AccessibleEvent being referenced.
659  *
660  * Increments by 1 the reference count of the event
661  *
662  * Returns: TRUE if the function succeeded; FALSE if the pointer is not a
663  *         valid event.
664  **/
665 SPIBoolean
666 AccessibleEvent_ref (const AccessibleEvent *e)
667 {
668   const InternalEvent *private = cspi_internal_event_check (e);
669   if (private)
670     {
671       InternalEvent *event = cspi_internal_event_lookup (private);
672       /* 
673        * put event in the cache if it's not there already, 
674        * and increment refcount 
675        */
676       if (!event)
677         {
678           event = cspi_internal_event_add (private);
679         }
680       event->ref_count++;
681       return TRUE;
682     }
683   else
684     return FALSE;
685 }
686
687 /**
688  * AccessibleEvent_unref:
689  * @e: a pointer to the #AccessibleEvent being referenced.
690  *
691  * Decrements by 1 the reference count of the event. The event is destroyed
692  * when the reference count recahes zero.
693  *
694  **/
695 void
696 AccessibleEvent_unref (const AccessibleEvent *e)
697 {
698   const InternalEvent *private = cspi_internal_event_check (e);
699   /* decrement refcount and remove if appropriate */
700   if (private)
701     {
702       InternalEvent *event = cspi_internal_event_lookup (private);
703       if (event) 
704         {
705           event->ref_count--;
706           if (event->ref_count < 1)
707             cspi_internal_event_remove (event);
708         }
709     }
710 }