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 #include "relation.h"
  52
  53 /*
  54  * Our parent Gtk object type
  55  */
  56 #define PARENT_TYPE BONOBO_OBJECT_TYPE
  57
  58 /*
  59  * A pointer to our parent object class
  60  */
  61 static GObjectClass *spi_accessible_parent_class;
  62
  63 /*
  64  * Implemented GObject::finalize
  65  */
  66 static void
  67 spi_accessible_object_finalize (GObject *object)
  68 {
  69         SpiAccessible *accessible = SPI_ACCESSIBLE (object);
  70
  71         printf("spi_accessible_object_finalize called\n");
  72         ATK_OBJECT (accessible->atko); /* assertion */
  73         g_object_unref (G_OBJECT(accessible->atko));
  74         accessible->atko = NULL;
  75
  76         printf("atko freed, calling parent finalize\n");
  77         spi_accessible_parent_class->finalize (object);
  78 }
  79
  80 /*
  81  * CORBA Accessibility::Accessible::get_name method implementation
  82  */
  83 static CORBA_char *
  84 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
  85                                         CORBA_Environment     *ev)
  86 {
  87   CORBA_char * retval;
  88   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
  89   retval = (CORBA_char *) atk_object_get_name (accessible->atko);
  90   if (retval )
  91     retval = CORBA_string_dup (retval);
  92   else
  93     retval = CORBA_string_dup ("");
  94
  95   return retval;
  96 }
  97
  98 /*
  99  * CORBA Accessibility::Accessible::set_name method implementation
 100  */
 101 static void
 102 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
 103                                         const CORBA_char      *name,
 104                                         CORBA_Environment     *ev)
 105 {
 106   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 107   atk_object_set_name (accessible->atko, name);
 108   printf ("SpiAccessible set_name called: %s\n", name);
 109 }
 110
 111 /*
 112  * CORBA Accessibility::Accessible::get_description method implementation
 113  */
 114 static CORBA_char *
 115 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
 116                                                CORBA_Environment     *ev)
 117 {
 118   CORBA_char * retval;
 119   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 120   retval = CORBA_string_dup (atk_object_get_description (accessible->atko));
 121   if (retval )
 122     retval = CORBA_string_dup (retval);
 123   else
 124     retval = CORBA_string_dup ("");
 125
 126   return retval;
 127 }
 128
 129 /*
 130  * CORBA Accessibility::Accessible::set_description method implementation
 131  */
 132 static void
 133 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 134                                                const CORBA_char      *name,
 135                                                CORBA_Environment     *ev)
 136 {
 137   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 138   atk_object_set_description (accessible->atko, name);
 139   printf ("SpiAccessible set_description called: %s\n", name);
 140 }
 141
 142 /*
 143  * CORBA Accessibility::Accessible::get_parent method implementation
 144  */
 145 static Accessibility_Accessible
 146 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 147                                           CORBA_Environment     *ev)
 148 {
 149   Accessibility_Accessible retval;
 150   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 151   AtkObject     *parent;
 152
 153   parent = atk_object_get_parent (accessible->atko);
 154   retval = BONOBO_OBJREF (spi_accessible_new (parent));
 155
 156   printf ("SpiAccessible get_parent called\n");
 157
 158   return CORBA_Object_duplicate (retval, ev);
 159 }
 160
 161 /*
 162  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 163  */
 164 static CORBA_long
 165 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 166                                                    CORBA_Environment     *ev)
 167 {
 168   CORBA_long retval;
 169   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 170   retval = (CORBA_long) atk_object_get_index_in_parent (accessible->atko);
 171   printf ("SpiAccessible get_index_in_parent called\n");
 172   return retval;
 173 }
 174
 175 /*
 176  * CORBA Accessibility::Accessible::get_childCount method implementation
 177  */
 178 static CORBA_long
 179 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 180                                                CORBA_Environment     *ev)
 181 {
 182   CORBA_long retval;
 183   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 184   retval = (CORBA_long) atk_object_get_n_accessible_children (accessible->atko);
 185   printf ("SpiAccessible get_childCount called: %d\n", (int) retval);
 186   return retval;
 187 }
 188
 189 /*
 190  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 191  */
 192 static Accessibility_Accessible
 193 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 194                                                   const CORBA_long      index,
 195                                                   CORBA_Environment     *ev)
 196 {
 197   Accessibility_Accessible retval;
 198   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 199   AtkObject *child = atk_object_ref_accessible_child (accessible->atko, (gint) index);
 200   retval = BONOBO_OBJREF (spi_accessible_new (child));
 201   printf ("SpiAccessible get_child_at_index called.\n");
 202   return CORBA_Object_duplicate (retval, ev);
 203 }
 204
 205 /*
 206  * CORBA Accessibility::Accessible::getState method implementation
 207  */
 208 static Accessibility_StateSet
 209 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 210                                          CORBA_Environment     *ev)
 211 {
 212   Accessibility_StateSet retval;
 213 /*  SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 214     AtkStateSet *state = atk_object_ref_state_set (accessible->atko); */
 215   retval = CORBA_OBJECT_NIL;
 216   printf ("SpiAccessible get_state.\n");
 217   /* TODO: implement the bonobo stateset class */
 218   return (Accessibility_StateSet) retval;
 219 }
 220
 221 /*
 222  * CORBA Accessibility::Accessible::getRelationSet method implementation
 223  */
 224 static Accessibility_RelationSet *
 225 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 226                                                 CORBA_Environment     *ev)
 227 {
 228   Accessibility_RelationSet *retval;
 229   gint n_relations;
 230   gint i;
 231   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 232   AtkRelationSet *relation_set = atk_object_ref_relation_set (accessible->atko);
 233   n_relations = atk_relation_set_get_n_relations (relation_set);
 234   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 235   CORBA_sequence_Accessibility_Relation_allocbuf (n_relations);
 236
 237   for (i=0; i<n_relations; ++i)
 238     {
 239       retval->_buffer[i] =
 240               CORBA_Object_duplicate (bonobo_object_corba_objref (
 241                       BONOBO_OBJECT (spi_relation_new (atk_relation_set_get_relation (relation_set, i)))),
 242                                       ev);
 243     }
 244
 245   printf ("SpiAccessible get_relation_set.\n");
 246   return retval;
 247 }
 248
 249 /*
 250  * CORBA Accessibility::Accessible::getRole method implementation
 251  */
 252 static Accessibility_Role
 253 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 254                                         CORBA_Environment     *ev)
 255 {
 256   Accessibility_Role retval;
 257   SpiAccessible *accessible = SPI_ACCESSIBLE (bonobo_object_from_servant (servant));
 258   AtkRole role = atk_object_get_role (accessible->atko);
 259   retval = role; /* relies on ability to cast these back and forth */
 260   printf ("SpiAccessible get_role.\n");
 261   return (Accessibility_Role) retval;
 262 }
 263
 264 static void
 265 spi_accessible_class_init (SpiAccessibleClass *klass)
 266 {
 267         GObjectClass * object_class = (GObjectClass *) klass;
 268         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 269         spi_accessible_parent_class = g_type_class_peek_parent (klass);
 270
 271         object_class->finalize = spi_accessible_object_finalize;
 272
 273         epv->_get_name = impl_accessibility_accessible_get_name;
 274         epv->_set_name = impl_accessibility_accessible_set_name;
 275         epv->_get_description = impl_accessibility_accessible_get_description;
 276         epv->_set_description = impl_accessibility_accessible_set_description;
 277
 278         epv->_get_parent = impl_accessibility_accessible_get_parent;
 279         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 280         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 281         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 282
 283         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 284         epv->getState = impl_accessibility_accessible_get_state;
 285         epv->getRole = impl_accessibility_accessible_get_role;
 286 }
 287
 288 static void
 289 spi_accessible_init (SpiAccessible *accessible)
 290 {
 291 }
 292
 293 BONOBO_TYPE_FUNC_FULL (SpiAccessible,
 294                        Accessibility_Accessible,
 295                        PARENT_TYPE,
 296                        spi_accessible);
 297
 298 SpiAccessible *
 299 spi_accessible_new (AtkObject *o)
 300 {
 301     SpiAccessible *retval =
 302                SPI_ACCESSIBLE (g_object_new (spi_accessible_get_type (), NULL));
 303     CORBA_Environment ev;
 304     CORBA_exception_init (&ev);
 305     g_object_ref (o);
 306     retval->atko = ATK_OBJECT (o);
 307
 308     /*
 309      * TODO: add interface containers/constructors for SPI_EDITABLE_TEXT, SPI_HYPERTEXT,
 310      *  SPI_IMAGE, SPI_SELECTION, SPI_TABLE, SPI_TEXT, SPI_VALUE.
 311      */
 312
 313     /* add appropriate ATK interfaces */
 314
 315     if (ATK_IS_ACTION (o))
 316       {
 317         bonobo_object_add_interface (bonobo_object (retval),
 318                                      BONOBO_OBJECT (spi_action_interface_new (o)));
 319       }
 320
 321     if (ATK_IS_COMPONENT (o))
 322       {
 323         bonobo_object_add_interface (bonobo_object (retval),
 324                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 325       }
 326
 327     if (ATK_IS_EDITABLE_TEXT (o))
 328       {
 329         bonobo_object_add_interface (bonobo_object (retval),
 330                                      BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 331       }
 332
 333     else if (ATK_IS_HYPERTEXT (o))
 334       {
 335         bonobo_object_add_interface (bonobo_object (retval),
 336                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 337       }
 338
 339     else if (ATK_IS_TEXT (o))
 340       {
 341         bonobo_object_add_interface (bonobo_object (retval),
 342                                      BONOBO_OBJECT (spi_text_interface_new (o)));
 343       }
 344
 345     if (ATK_IS_IMAGE (o))
 346       {
 347         bonobo_object_add_interface (bonobo_object (retval),
 348                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 349       }
 350
 351     if (ATK_IS_SELECTION (o))
 352       {
 353         bonobo_object_add_interface (bonobo_object (retval),
 354                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 355       }
 356
 357     if (ATK_IS_TABLE (o))
 358       {
 359         bonobo_object_add_interface (bonobo_object (retval),
 360                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 361       }
 362
 363     if (ATK_IS_VALUE (o))
 364       {
 365         bonobo_object_add_interface (bonobo_object (retval),
 366                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 367       }
 368
 369     return retval;
 370 }