libspi/accessible.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001 Sun Microsystems Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /* accessible.c: the core of the accessibility implementation */
  24
  25 #include <config.h>
  26 #include <stdio.h>
  27 #include <libspi/libspi.h>
  28
  29 /*
  30  * Our parent Gtk object type
  31  */
  32 #define PARENT_TYPE BONOBO_OBJECT_TYPE
  33
  34 /*
  35  * A pointer to our parent object class
  36  */
  37 static GObjectClass *spi_accessible_parent_class;
  38
  39 /*
  40  * Implemented GObject::finalize
  41  */
  42 static void
  43 spi_accessible_object_finalize (GObject *object)
  44 {
  45         SpiAccessible *accessible = SPI_ACCESSIBLE (object);
  46
  47         printf("spi_accessible_object_finalize called\n");
  48         ATK_OBJECT (accessible->atko); /* assertion */
  49         g_object_unref (G_OBJECT(accessible->atko));
  50         accessible->atko = NULL;
  51
  52         printf("atko freed, calling parent finalize\n");
  53         spi_accessible_parent_class->finalize (object);
  54 }
  55
  56 /*
  57  * CORBA Accessibility::Accessible::get_name method implementation
  58  */
  59 static CORBA_char *
  60 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
  61                                         CORBA_Environment     *ev)
  62 {
  63   CORBA_char * retval;
  64   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
  65   retval = (CORBA_char *) atk_object_get_name (accessible->atko);
  66   if (retval )
  67     retval = CORBA_string_dup (retval);
  68   else
  69     retval = CORBA_string_dup ("");
  70
  71   return retval;
  72 }
  73
  74 /*
  75  * CORBA Accessibility::Accessible::set_name method implementation
  76  */
  77 static void
  78 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
  79                                         const CORBA_char      *name,
  80                                         CORBA_Environment     *ev)
  81 {
  82   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
  83   atk_object_set_name (accessible->atko, name);
  84   printf ("SpiAccessible set_name called: %s\n", name);
  85 }
  86
  87 /*
  88  * CORBA Accessibility::Accessible::get_description method implementation
  89  */
  90 static CORBA_char *
  91 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
  92                                                CORBA_Environment     *ev)
  93 {
  94   CORBA_char * retval;
  95   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
  96   retval = CORBA_string_dup (atk_object_get_description (accessible->atko));
  97   if (retval )
  98     retval = CORBA_string_dup (retval);
  99   else
 100     retval = CORBA_string_dup ("");
 101
 102   return retval;
 103 }
 104
 105 /*
 106  * CORBA Accessibility::Accessible::set_description method implementation
 107  */
 108 static void
 109 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 110                                                const CORBA_char      *name,
 111                                                CORBA_Environment     *ev)
 112 {
 113   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 114   atk_object_set_description (accessible->atko, name);
 115   printf ("SpiAccessible set_description called: %s\n", name);
 116 }
 117
 118 /*
 119  * CORBA Accessibility::Accessible::get_parent method implementation
 120  */
 121 static Accessibility_Accessible
 122 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 123                                           CORBA_Environment     *ev)
 124 {
 125   Accessibility_Accessible retval;
 126   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 127   AtkObject     *parent;
 128
 129   parent = atk_object_get_parent (accessible->atko);
 130   retval = BONOBO_OBJREF (spi_accessible_new (parent));
 131
 132   printf ("SpiAccessible get_parent called\n");
 133
 134   return CORBA_Object_duplicate (retval, ev);
 135 }
 136
 137 /*
 138  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 139  */
 140 static CORBA_long
 141 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 142                                                    CORBA_Environment     *ev)
 143 {
 144   CORBA_long retval;
 145   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 146   retval = (CORBA_long) atk_object_get_index_in_parent (accessible->atko);
 147   printf ("SpiAccessible get_index_in_parent called\n");
 148   return retval;
 149 }
 150
 151 /*
 152  * CORBA Accessibility::Accessible::get_childCount method implementation
 153  */
 154 static CORBA_long
 155 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 156                                                CORBA_Environment     *ev)
 157 {
 158   CORBA_long retval;
 159   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 160   retval = (CORBA_long) atk_object_get_n_accessible_children (accessible->atko);
 161   printf ("SpiAccessible get_childCount called: %d\n", (int) retval);
 162   return retval;
 163 }
 164
 165 /*
 166  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 167  */
 168 static Accessibility_Accessible
 169 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 170                                                   const CORBA_long      index,
 171                                                   CORBA_Environment     *ev)
 172 {
 173   Accessibility_Accessible retval;
 174   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 175   AtkObject *child = atk_object_ref_accessible_child (accessible->atko, (gint) index);
 176   retval = BONOBO_OBJREF (spi_accessible_new (child));
 177   printf ("SpiAccessible get_child_at_index called.\n");
 178   return CORBA_Object_duplicate (retval, ev);
 179 }
 180
 181 /*
 182  * CORBA Accessibility::Accessible::getState method implementation
 183  */
 184 static Accessibility_StateSet
 185 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 186                                          CORBA_Environment     *ev)
 187 {
 188   Accessibility_StateSet retval;
 189 /*  SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 190     AtkStateSet *state = atk_object_ref_state_set (accessible->atko); */
 191   retval = CORBA_OBJECT_NIL;
 192   printf ("SpiAccessible get_state.\n");
 193   /* TODO: implement the bonobo stateset class */
 194   return (Accessibility_StateSet) retval;
 195 }
 196
 197 /*
 198  * CORBA Accessibility::Accessible::getRelationSet method implementation
 199  */
 200 static Accessibility_RelationSet *
 201 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 202                                                 CORBA_Environment     *ev)
 203 {
 204   Accessibility_RelationSet *retval;
 205   gint n_relations;
 206   gint i;
 207   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 208   AtkRelationSet *relation_set = atk_object_ref_relation_set (accessible->atko);
 209   n_relations = atk_relation_set_get_n_relations (relation_set);
 210   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 211   CORBA_sequence_Accessibility_Relation_allocbuf (n_relations);
 212
 213   for (i=0; i<n_relations; ++i)
 214     {
 215       retval->_buffer[i] =
 216               CORBA_Object_duplicate (bonobo_object_corba_objref (
 217                       BONOBO_OBJECT (spi_relation_new (atk_relation_set_get_relation (relation_set, i)))),
 218                                       ev);
 219     }
 220
 221   printf ("SpiAccessible get_relation_set.\n");
 222   return retval;
 223 }
 224
 225 /*
 226  * CORBA Accessibility::Accessible::getRole method implementation
 227  */
 228 static Accessibility_Role
 229 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 230                                         CORBA_Environment     *ev)
 231 {
 232   Accessibility_Role retval;
 233   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 234   AtkRole role = atk_object_get_role (accessible->atko);
 235   retval = role; /* relies on ability to cast these back and forth */
 236   printf ("SpiAccessible get_role.\n");
 237   return (Accessibility_Role) retval;
 238 }
 239
 240 static void
 241 spi_accessible_class_init (SpiAccessibleClass *klass)
 242 {
 243         GObjectClass * object_class = (GObjectClass *) klass;
 244         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 245         spi_accessible_parent_class = g_type_class_peek_parent (klass);
 246
 247         object_class->finalize = spi_accessible_object_finalize;
 248
 249         epv->_get_name = impl_accessibility_accessible_get_name;
 250         epv->_set_name = impl_accessibility_accessible_set_name;
 251         epv->_get_description = impl_accessibility_accessible_get_description;
 252         epv->_set_description = impl_accessibility_accessible_set_description;
 253
 254         epv->_get_parent = impl_accessibility_accessible_get_parent;
 255         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 256         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 257         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 258
 259         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 260         epv->getState = impl_accessibility_accessible_get_state;
 261         epv->getRole = impl_accessibility_accessible_get_role;
 262 }
 263
 264 static void
 265 spi_accessible_init (SpiAccessible *accessible)
 266 {
 267 }
 268
 269 BONOBO_TYPE_FUNC_FULL (SpiAccessible,
 270                        Accessibility_Accessible,
 271                        PARENT_TYPE,
 272                        spi_accessible);
 273
 274 SpiAccessible *
 275 spi_accessible_new (AtkObject *o)
 276 {
 277     SpiAccessible *retval =
 278                SPI_ACCESSIBLE (g_object_new (spi_accessible_get_type (), NULL));
 279     CORBA_Environment ev;
 280     CORBA_exception_init (&ev);
 281     g_object_ref (o);
 282     retval->atko = ATK_OBJECT (o);
 283
 284     /*
 285      * TODO: add interface containers/constructors for SPI_EDITABLE_TEXT, SPI_HYPERTEXT,
 286      *  SPI_IMAGE, SPI_SELECTION, SPI_TABLE, SPI_TEXT, SPI_VALUE.
 287      */
 288
 289     /* add appropriate ATK interfaces */
 290
 291     if (ATK_IS_ACTION (o))
 292       {
 293         bonobo_object_add_interface (bonobo_object (retval),
 294                                      BONOBO_OBJECT (spi_action_interface_new (o)));
 295       }
 296
 297     if (ATK_IS_COMPONENT (o))
 298       {
 299         bonobo_object_add_interface (bonobo_object (retval),
 300                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 301       }
 302
 303     if (ATK_IS_EDITABLE_TEXT (o))
 304       {
 305         bonobo_object_add_interface (bonobo_object (retval),
 306                                      BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 307       }
 308
 309     else if (ATK_IS_HYPERTEXT (o))
 310       {
 311         bonobo_object_add_interface (bonobo_object (retval),
 312                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 313       }
 314
 315     else if (ATK_IS_TEXT (o))
 316       {
 317         bonobo_object_add_interface (bonobo_object (retval),
 318                                      BONOBO_OBJECT (spi_text_interface_new (o)));
 319       }
 320
 321     if (ATK_IS_IMAGE (o))
 322       {
 323         bonobo_object_add_interface (bonobo_object (retval),
 324                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 325       }
 326
 327     if (ATK_IS_SELECTION (o))
 328       {
 329         bonobo_object_add_interface (bonobo_object (retval),
 330                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 331       }
 332
 333     if (ATK_IS_TABLE (o))
 334       {
 335         bonobo_object_add_interface (bonobo_object (retval),
 336                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 337       }
 338
 339     if (ATK_IS_VALUE (o))
 340       {
 341         bonobo_object_add_interface (bonobo_object (retval),
 342                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 343       }
 344
 345     return retval;
 346 }