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 /*
  24  * accessible.c: test for accessibility implementation
  25  *
  26  */
  27 #include <config.h>
  28 #include <bonobo/Bonobo.h>
  29
  30 #include <stdio.h>
  31
  32 /*
  33  * This pulls the CORBA definitions for the "Accessibility::Accessible" server
  34  */
  35 #include <libspi/Accessibility.h>
  36
  37 /*
  38  * This pulls the definition for the BonoboObject (Gtk Type)
  39  */
  40 #include "accessible.h"
  41 #include "component.h"
  42 #include "editabletext.h"
  43 #include "hyperlink.h"
  44 #include "hypertext.h"
  45 #include "image.h"
  46 #include "selection.h"
  47 #include "table.h"
  48 #include "text.h"
  49 #include "value.h"
  50 #include "action.h"
  51
  52 /*
  53  * Our parent Gtk object type
  54  */
  55 #define PARENT_TYPE BONOBO_OBJECT_TYPE
  56
  57 /*
  58  * A pointer to our parent object class
  59  */
  60 static GObjectClass *spi_accessible_parent_class;
  61
  62 /*
  63  * Implemented GObject::finalize
  64  */
  65 static void
  66 spi_accessible_object_finalize (GObject *object)
  67 {
  68         SpiAccessible *accessible = SPI_ACCESSIBLE (object);
  69
  70         printf("spi_accessible_object_finalize called\n");
  71         ATK_OBJECT (accessible->atko); /* assertion */
  72         g_object_unref (G_OBJECT(accessible->atko));
  73         accessible->atko = NULL;
  74
  75         printf("atko freed, calling parent finalize\n");
  76         spi_accessible_parent_class->finalize (object);
  77 }
  78
  79 /*
  80  * CORBA Accessibility::Accessible::get_name method implementation
  81  */
  82 static CORBA_char *
  83 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
  84                                         CORBA_Environment     *ev)
  85 {
  86   CORBA_char * retval;
  87   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
  88   retval = (CORBA_char *) atk_object_get_name (accessible->atko);
  89   if (retval )
  90     retval = CORBA_string_dup (retval);
  91   else
  92     retval = CORBA_string_dup ("");
  93
  94   return retval;
  95 }
  96
  97 /*
  98  * CORBA Accessibility::Accessible::set_name method implementation
  99  */
 100 static void
 101 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
 102                                         const CORBA_char      *name,
 103                                         CORBA_Environment     *ev)
 104 {
 105   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 106   atk_object_set_name (accessible->atko, name);
 107   printf ("SpiAccessible set_name called: %s\n", name);
 108 }
 109
 110 /*
 111  * CORBA Accessibility::Accessible::get_description method implementation
 112  */
 113 static CORBA_char *
 114 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
 115                                                CORBA_Environment     *ev)
 116 {
 117   CORBA_char * retval;
 118   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 119   retval = CORBA_string_dup (atk_object_get_description (accessible->atko));
 120   if (retval )
 121     retval = CORBA_string_dup (retval);
 122   else
 123     retval = CORBA_string_dup ("");
 124
 125   return retval;
 126 }
 127
 128 /*
 129  * CORBA Accessibility::Accessible::set_description method implementation
 130  */
 131 static void
 132 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 133                                                const CORBA_char      *name,
 134                                                CORBA_Environment     *ev)
 135 {
 136   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 137   atk_object_set_description (accessible->atko, name);
 138   printf ("SpiAccessible set_description called: %s\n", name);
 139 }
 140
 141 /*
 142  * CORBA Accessibility::Accessible::get_parent method implementation
 143  */
 144 static Accessibility_Accessible
 145 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 146                                           CORBA_Environment     *ev)
 147 {
 148   Accessibility_Accessible retval;
 149   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 150   AtkObject     *parent;
 151
 152   parent = atk_object_get_parent (accessible->atko);
 153   retval = BONOBO_OBJREF (spi_accessible_new (parent));
 154
 155   printf ("SpiAccessible get_parent called\n");
 156
 157   return CORBA_Object_duplicate (retval, ev);
 158 }
 159
 160 /*
 161  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 162  */
 163 static CORBA_long
 164 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 165                                                    CORBA_Environment     *ev)
 166 {
 167   CORBA_long retval;
 168   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 169   retval = (CORBA_long) atk_object_get_index_in_parent (accessible->atko);
 170   printf ("SpiAccessible get_index_in_parent called\n");
 171   return retval;
 172 }
 173
 174 /*
 175  * CORBA Accessibility::Accessible::get_childCount method implementation
 176  */
 177 static CORBA_long
 178 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 179                                                CORBA_Environment     *ev)
 180 {
 181   CORBA_long retval;
 182   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 183   retval = (CORBA_long) atk_object_get_n_accessible_children (accessible->atko);
 184   printf ("SpiAccessible get_childCount called: %d\n", (int) retval);
 185   return retval;
 186 }
 187
 188 /*
 189  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 190  */
 191 static Accessibility_Accessible
 192 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 193                                                   const CORBA_long      index,
 194                                                   CORBA_Environment     *ev)
 195 {
 196   Accessibility_Accessible retval;
 197   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 198   AtkObject *child = atk_object_ref_accessible_child (accessible->atko, (gint) index);
 199   retval = BONOBO_OBJREF (spi_accessible_new (child));
 200   printf ("SpiAccessible get_child_at_index called.\n");
 201   return CORBA_Object_duplicate (retval, ev);
 202 }
 203
 204 /*
 205  * CORBA Accessibility::Accessible::getState method implementation
 206  */
 207 static Accessibility_StateSet
 208 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 209                                          CORBA_Environment     *ev)
 210 {
 211   Accessibility_StateSet retval;
 212 /*  SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 213     AtkStateSet *state = atk_object_ref_state_set (accessible->atko); */
 214   retval = CORBA_OBJECT_NIL;
 215   printf ("SpiAccessible get_state.\n");
 216   /* TODO: implement the bonobo stateset class */
 217   return (Accessibility_StateSet) retval;
 218 }
 219
 220 /*
 221  * CORBA Accessibility::Accessible::getRelationSet method implementation
 222  */
 223 static Accessibility_RelationSet *
 224 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 225                                                 CORBA_Environment     *ev)
 226 {
 227   Accessibility_RelationSet *retval;
 228 /*  SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 229     AtkRelationSet *relation_set = atk_object_ref_relation_set (accessible->atko); */
 230   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 231   /*
 232    *  TODO: fill the sequence with relation set objects, themselves
 233    *  initialized from the AtkRelation object in the AtkRelationSet.
 234    */
 235   printf ("SpiAccessible get_relation_set.\n");
 236   return retval;
 237 }
 238
 239 /*
 240  * CORBA Accessibility::Accessible::getRole method implementation
 241  */
 242 static Accessibility_Role
 243 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 244                                         CORBA_Environment     *ev)
 245 {
 246   Accessibility_Role retval;
 247   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 248   AtkRole role = atk_object_get_role (accessible->atko);
 249   retval = role;
 250   printf ("SpiAccessible get_role.\n");
 251   return (Accessibility_Role) retval;
 252 }
 253
 254 static void
 255 spi_accessible_class_init (SpiAccessibleClass *klass)
 256 {
 257         GObjectClass * object_class = (GObjectClass *) klass;
 258         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 259         spi_accessible_parent_class = g_type_class_peek_parent (klass);
 260
 261         object_class->finalize = spi_accessible_object_finalize;
 262
 263         epv->_get_name = impl_accessibility_accessible_get_name;
 264         epv->_set_name = impl_accessibility_accessible_set_name;
 265         epv->_get_description = impl_accessibility_accessible_get_description;
 266         epv->_set_description = impl_accessibility_accessible_set_description;
 267
 268         epv->_get_parent = impl_accessibility_accessible_get_parent;
 269         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 270         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 271         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 272
 273         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 274         epv->getState = impl_accessibility_accessible_get_state;
 275         epv->getRole = impl_accessibility_accessible_get_role;
 276 }
 277
 278 static void
 279 spi_accessible_init (SpiAccessible *accessible)
 280 {
 281 }
 282
 283 GType
 284 spi_accessible_get_type (void)
 285 {
 286         static GType type = 0;
 287
 288         if (!type) {
 289                 static const GTypeInfo tinfo = {
 290                         sizeof (SpiAccessibleClass),
 291                         (GBaseInitFunc) NULL,
 292                         (GBaseFinalizeFunc) NULL,
 293                         (GClassInitFunc) spi_accessible_class_init,
 294                         (GClassFinalizeFunc) NULL,
 295                         NULL, /* class data */
 296                         sizeof (SpiAccessible),
 297                         0, /* n preallocs */
 298                         (GInstanceInitFunc) spi_accessible_init,
 299                         NULL /* value table */
 300                 };
 301                 /*
 302                  * Bonobo_type_unique auto-generates a load of
 303                  * CORBA structures for us. All derived types must
 304                  * use bonobo_type_unique.
 305                  */
 306                 type = bonobo_type_unique (
 307                         PARENT_TYPE,
 308                         POA_Accessibility_Accessible__init,
 309                         NULL,
 310                         G_STRUCT_OFFSET (SpiAccessibleClass, epv),
 311                         &tinfo,
 312                         "SpiAccessible");
 313         }
 314
 315         return type;
 316 }
 317
 318 SpiAccessible *
 319 spi_accessible_new (AtkObject *o)
 320 {
 321     SpiAccessible *retval =
 322                SPI_ACCESSIBLE (g_object_new (spi_accessible_get_type (), NULL));
 323     CORBA_Environment ev;
 324     CORBA_exception_init (&ev);
 325     g_object_ref (o);
 326     retval->atko = ATK_OBJECT (o);
 327
 328     /*
 329      * TODO: add interface containers/constructors for SPI_EDITABLE_TEXT, SPI_HYPERTEXT,
 330      *  SPI_IMAGE, SPI_SELECTION, SPI_TABLE, SPI_TEXT, SPI_VALUE.
 331      */
 332
 333     /* add appropriate ATK interfaces */
 334
 335     if (ATK_IS_ACTION (o))
 336       {
 337         bonobo_object_add_interface (bonobo_object (retval),
 338                                      BONOBO_OBJECT (spi_action_interface_new (o)));
 339       }
 340
 341     if (ATK_IS_COMPONENT (o))
 342       {
 343         bonobo_object_add_interface (bonobo_object (retval),
 344                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 345       }
 346
 347     if (ATK_IS_EDITABLE_TEXT (o))
 348       {
 349         bonobo_object_add_interface (bonobo_object (retval),
 350                                      BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 351       }
 352
 353     else if (ATK_IS_HYPERTEXT (o))
 354       {
 355         bonobo_object_add_interface (bonobo_object (retval),
 356                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 357       }
 358
 359     else if (ATK_IS_TEXT (o))
 360       {
 361         bonobo_object_add_interface (bonobo_object (retval),
 362                                      BONOBO_OBJECT (spi_text_interface_new (o)));
 363       }
 364
 365     if (ATK_IS_IMAGE (o))
 366       {
 367         bonobo_object_add_interface (bonobo_object (retval),
 368                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 369       }
 370
 371     if (ATK_IS_SELECTION (o))
 372       {
 373         bonobo_object_add_interface (bonobo_object (retval),
 374                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 375       }
 376
 377     if (ATK_IS_TABLE (o))
 378       {
 379         bonobo_object_add_interface (bonobo_object (retval),
 380                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 381       }
 382
 383     if (ATK_IS_VALUE (o))
 384       {
 385         bonobo_object_add_interface (bonobo_object (retval),
 386                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 387       }
 388
 389     return retval;
 390 }