Added methods for Component Layer and MDI Z-Order information (see

[platform/core/uifw/at-spi2-atk.git] / cspi / spi_event.c

diff --git a/cspi/spi_event.c b/cspi/spi_event.c
index 4db0b71..bc8a355 100644 (file)
--- a/cspi/spi_event.c
+++ b/cspi/spi_event.c
@@ -1,44 +1,73 @@
+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
+ *
+ * Copyright 2001 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 <cspi/spi-private.h>
+#include <cspi/spi-listener-impl.h>
 
 /**
- * createEventListener:
+ * createAccessibleEventListener:
  * @callback : an #AccessibleEventListenerCB callback function, or NULL.
  *
- * Create a new #AccessibleEventListener with a specified callback function.
+ * Create a new #AccessibleEventListener with a specified (in-process) callback function.
  *
  * Returns: a pointer to a newly-created #AccessibleEventListener.
  *
  **/
 AccessibleEventListener *
-createEventListener (AccessibleEventListenerCB callback)
+createAccessibleEventListener (AccessibleEventListenerCB callback)
 {
-  AccessibleEventListener *listener = accessible_event_listener_new ();
+  AccessibleEventListener *listener = cspi_event_listener_new ();
   if (callback)
     {
-      accessible_event_listener_add_callback (listener, callback);
+      AccessibleEventListener_addCallback (listener, callback);
     }
   return listener;
 }
 
 /**
- * EventListener_addCallback:
+ * AccessibleEventListener_addCallback:
  * @listener: the #AccessibleEventListener instance to modify.
  * @callback: an #AccessibleEventListenerCB function pointer.
  *
  * Add an in-process callback function to an existing AccessibleEventListener.
+ * Note that the callback function must live in the same address
+ * space as the AccessibleEventListener implementation code, thus one should not
+ * use this function to attach callbacks to a 'remote' event listener
+ * (that is, one that was not created by a client call to
+ * createAccessibleEventListener ();
  *
  * Returns: #TRUE if successful, otherwise #FALSE.
  *
  **/
-boolean
-EventListener_addCallback (AccessibleEventListener *listener,
-                           AccessibleEventListenerCB callback)
+SPIBoolean
+AccessibleEventListener_addCallback (AccessibleEventListener *listener,
+                                    AccessibleEventListenerCB callback)
 {
-  accessible_event_listener_add_callback (listener, callback);
+  cspi_event_listener_add_callback (listener, callback);
   return TRUE;
 }
 
 /**
- * EventListener_removeCallback:
+ * AccessibleEventListener_removeCallback:
  * @listener: the #AccessibleEventListener instance to modify.
  * @callback: an #AccessibleEventListenerCB function pointer.
  *
@@ -47,67 +76,79 @@ EventListener_addCallback (AccessibleEventListener *listener,
  * Returns: #TRUE if successful, otherwise #FALSE.
  *
  **/
-boolean
-EventListener_removeCallback (AccessibleEventListener *listener,
-                           AccessibleEventListenerCB callback)
+SPIBoolean
+AccessibleEventListener_removeCallback (AccessibleEventListener  *listener,
+                                       AccessibleEventListenerCB callback)
 {
-  accessible_event_listener_remove_callback (listener, callback);
+  cspi_event_listener_remove_callback (listener, callback);
   return TRUE;
 }
 
 /**
- * createKeystrokeListener:
- * @callback : an #KeystrokeListenerCB callback function, or NULL.
+ * createAccessibleKeystrokeListener:
+ * @callback : an #AccessibleKeystrokeListenerCB callback function, or NULL.
  *
- * Create a new #KeystrokeListener with a specified callback function.
+ * Create a new #AccessibleKeystrokeListener with a specified callback function.
  *
- * Returns: a pointer to a newly-created #KeystrokeListener.
+ * Returns: a pointer to a newly-created #AccessibleKeystrokeListener.
  *
  **/
-KeystrokeListener *
-createKeystrokeListener (KeystrokeListenerCB callback)
+AccessibleKeystrokeListener *
+createAccessibleKeystrokeListener (AccessibleKeystrokeListenerCB callback)
 {
-  KeystrokeListener *listener = keystroke_listener_new ();
+  CSpiKeystrokeListener *listener = cspi_keystroke_listener_new ();
   if (callback)
     {
-      keystroke_listener_add_callback (listener, callback);
+      AccessibleKeystrokeListener_addCallback (listener, callback);
     }
-  return listener;
+  return (AccessibleKeystrokeListener *)listener;
 }
 
 /**
- * KeystrokeListener_addCallback:
- * @listener: the #KeystrokeListener instance to modify.
- * @callback: an #KeystrokeListenerCB function pointer.
+ * AccessibleKeystrokeListener_addCallback:
+ * @listener: the #AccessibleKeystrokeListener instance to modify.
+ * @callback: an #AccessibleKeystrokeListenerCB function pointer.
  *
- * Add an in-process callback function to an existing #KeystrokeListener.
+ * Add an in-process callback function to an existing #AccessibleKeystrokeListener.
  *
  * Returns: #TRUE if successful, otherwise #FALSE.
  *
  **/
-boolean
-KeystrokeListener_addCallback (KeystrokeListener *listener,
-                           KeystrokeListenerCB callback)
+SPIBoolean
+AccessibleKeystrokeListener_addCallback (AccessibleKeystrokeListener *listener,
+                                        AccessibleKeystrokeListenerCB callback)
 {
-  keystroke_listener_add_callback (listener, callback);
+  cspi_keystroke_listener_add_callback (listener, callback);
   return TRUE;
 }
 
 /**
- * KeystrokeListener_removeCallback:
- * @listener: the #KeystrokeListener instance to modify.
- * @callback: an #KeystrokeListenerCB function pointer.
+ * AccessibleKeystrokeListener_removeCallback:
+ * @listener: the #AccessibleKeystrokeListener instance to modify.
+ * @callback: an #AccessibleKeystrokeListenerCB function pointer.
  *
- * Remove an in-process callback function from an existing KeystrokeListener.
+ * Remove an in-process callback function from an existing #AccessibleKeystrokeListener.
  *
  * Returns: #TRUE if successful, otherwise #FALSE.
  *
  **/
-boolean
-KeystrokeListener_removeCallback (KeystrokeListener *listener,
-                                 KeystrokeListenerCB callback)
+SPIBoolean
+AccessibleKeystrokeListener_removeCallback (AccessibleKeystrokeListener *listener,
+                                           AccessibleKeystrokeListenerCB callback)
 {
-  keystroke_listener_remove_callback (listener, callback);
+  cspi_keystroke_listener_remove_callback (listener, callback);
   return TRUE;
 }
 
+
+/**
+ * AccessibleKeystrokeListener_unref:
+ * @listener: a pointer to the #AccessibleKeystrokeListener being operated on.
+ *
+ * Decrements an #AccessibleKeystrokeListener's reference count.
+ **/
+void AccessibleKeystrokeListener_unref (AccessibleKeystrokeListener *listener)
+{
+  /* Would prefer this not to be bonobo api */
+  bonobo_object_unref (BONOBO_OBJECT (listener));
+}