libspi/table.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 /* table.c : implements the Table interface */
  24
  25 #include <config.h>
  26 #include <stdio.h>
  27 #include <libspi/accessible.h>
  28 #include <libspi/table.h>
  29
  30 /* Static function declarations */
  31
  32 static void
  33 spi_table_class_init (SpiTableClass *klass);
  34 static void
  35 spi_table_init (SpiTable *table);
  36 static void
  37 spi_table_finalize (GObject *obj);
  38 static Accessibility_Accessible
  39 impl__get_caption (PortableServer_Servant _servant,
  40                    CORBA_Environment * ev);
  41 static Accessibility_Accessible
  42 impl__get_summary (PortableServer_Servant _servant,
  43                    CORBA_Environment * ev);
  44 static CORBA_long
  45 impl__get_nRows (PortableServer_Servant _servant,
  46                  CORBA_Environment * ev);
  47 static CORBA_long
  48 impl__get_nRows (PortableServer_Servant _servant,
  49                  CORBA_Environment * ev);
  50 static CORBA_long
  51 impl__get_nColumns (PortableServer_Servant _servant,
  52                     CORBA_Environment * ev);
  53 static Accessibility_Accessible
  54 impl_getAccessibleAt (PortableServer_Servant _servant,
  55                       const CORBA_long row,
  56                       const CORBA_long column,
  57                       CORBA_Environment * ev);
  58 static CORBA_long
  59 impl_getIndexAt (PortableServer_Servant _servant,
  60                  const CORBA_long row, const CORBA_long column,
  61                  CORBA_Environment * ev);
  62 static CORBA_long
  63 impl_getRowAtIndex (PortableServer_Servant _servant,
  64                     const CORBA_long index,
  65                     CORBA_Environment * ev);
  66 static CORBA_long
  67 impl_getColumnAtIndex (PortableServer_Servant _servant,
  68                        const CORBA_long index,
  69                        CORBA_Environment * ev);
  70 static CORBA_string
  71 impl_getRowDescription (PortableServer_Servant _servant,
  72                         const CORBA_long row,
  73                         CORBA_Environment * ev);
  74 static CORBA_string
  75 impl_getColumnDescription (PortableServer_Servant _servant,
  76                            const CORBA_long column,
  77                            CORBA_Environment * ev);
  78 static CORBA_long
  79 impl_getRowExtentAt (PortableServer_Servant _servant,
  80                      const CORBA_long row,
  81                      const CORBA_long column,
  82                      CORBA_Environment * ev);
  83 static CORBA_long
  84 impl_getColumnExtentAt (PortableServer_Servant _servant,
  85                         const CORBA_long row,
  86                         const CORBA_long column,
  87                         CORBA_Environment * ev);
  88 static Accessibility_Table
  89 impl_getRowHeader (PortableServer_Servant _servant,
  90                    const CORBA_long row,
  91                    CORBA_Environment * ev);
  92 static        Accessibility_Table
  93 impl_getColumnHeader (PortableServer_Servant _servant,
  94                       const CORBA_long column,
  95                       CORBA_Environment * ev);
  96 static Accessibility_LongSeq *
  97 impl_getSelectedRows (PortableServer_Servant _servant,
  98                       CORBA_Environment * ev);
  99 static Accessibility_LongSeq *
 100 impl_getSelectedColumns (PortableServer_Servant _servant,
 101                          CORBA_Environment * ev);
 102 static CORBA_boolean
 103 impl_isRowSelected (PortableServer_Servant _servant,
 104                     const CORBA_long row,
 105                     CORBA_Environment * ev);
 106 static CORBA_boolean
 107 impl_isColumnSelected (PortableServer_Servant _servant,
 108                        const CORBA_long column,
 109                        CORBA_Environment * ev);
 110 static CORBA_boolean
 111 impl_isSelected (PortableServer_Servant _servant,
 112                  const CORBA_long row,
 113                  const CORBA_long column,
 114                  CORBA_Environment * ev);
 115
 116
 117 static GObjectClass *parent_class;
 118
 119 GType
 120 spi_table_get_type (void)
 121 {
 122   static GType type = 0;
 123
 124   if (!type) {
 125     static const GTypeInfo tinfo = {
 126       sizeof (SpiTableClass),
 127       (GBaseInitFunc) NULL,
 128       (GBaseFinalizeFunc) NULL,
 129       (GClassInitFunc) spi_table_class_init,
 130       (GClassFinalizeFunc) NULL,
 131       NULL, /* class data */
 132       sizeof (SpiTable),
 133       0, /* n preallocs */
 134       (GInstanceInitFunc) spi_table_init,
 135                         NULL /* value table */
 136     };
 137
 138     /*
 139      * Bonobo_type_unique auto-generates a load of
 140      * CORBA structures for us. All derived types must
 141      * use bonobo_type_unique.
 142      */
 143     type = bonobo_type_unique (
 144                                BONOBO_OBJECT_TYPE,
 145                                POA_Accessibility_Table__init,
 146                                NULL,
 147                                G_STRUCT_OFFSET (SpiTableClass, epv),
 148                                &tinfo,
 149                                "SpiAccessibleTable");
 150   }
 151
 152   return type;
 153 }
 154
 155 static void
 156 spi_table_class_init (SpiTableClass *klass)
 157 {
 158   GObjectClass * object_class = (GObjectClass *) klass;
 159   POA_Accessibility_Table__epv *epv = &klass->epv;
 160   parent_class = g_type_class_peek_parent (klass);
 161
 162   object_class->finalize = spi_table_finalize;
 163
 164
 165   /* Initialize epv table */
 166
 167   epv->_get_caption = impl__get_caption;
 168   epv->_get_summary = impl__get_summary;
 169   epv->_get_nRows = impl__get_nRows;
 170   epv->_get_nColumns = impl__get_nColumns;
 171   epv->getAccessibleAt = impl_getAccessibleAt;
 172   epv->getIndexAt = impl_getIndexAt;
 173   epv->getRowAtIndex = impl_getRowAtIndex;
 174   epv->getColumnAtIndex = impl_getColumnAtIndex;
 175   epv->getRowDescription = impl_getRowDescription;
 176   epv->getColumnDescription = impl_getColumnDescription;
 177   epv->getRowExtentAt = impl_getRowExtentAt;
 178   epv->getColumnExtentAt = impl_getColumnExtentAt;
 179   epv->getRowHeader = impl_getRowHeader;
 180   epv->getColumnHeader = impl_getColumnHeader;
 181   epv->getSelectedRows = impl_getSelectedRows;
 182   epv->getSelectedColumns = impl_getSelectedColumns;
 183   epv->isRowSelected = impl_isRowSelected;
 184   epv->isColumnSelected = impl_isColumnSelected;
 185   epv->isSelected = impl_isSelected;
 186 }
 187
 188 static void
 189 spi_table_init (SpiTable *table)
 190 {
 191 }
 192
 193 static void
 194 spi_table_finalize (GObject *obj)
 195 {
 196   SpiTable *table = SPI_TABLE (obj);
 197   g_object_unref (table->atko);
 198   table->atko = NULL;
 199   parent_class->finalize (obj);
 200 }
 201
 202 SpiTable *
 203 spi_table_interface_new (AtkObject *obj)
 204 {
 205   SpiTable *new_table =
 206     SPI_TABLE(g_object_new (SPI_TABLE_TYPE, NULL));
 207   new_table->atko = obj;
 208   g_object_ref (obj);
 209   return new_table;
 210 }
 211
 212
 213
 214 static Accessibility_Accessible
 215 impl__get_caption (PortableServer_Servant _servant,
 216                    CORBA_Environment * ev)
 217 {
 218   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 219   AtkObject *atk_object;
 220   Accessibility_Accessible rv;
 221
 222   atk_object = atk_table_get_caption (ATK_TABLE(table-> atko));
 223   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(atk_object)));
 224   return CORBA_Object_duplicate (rv, ev);
 225 }
 226
 227
 228
 229 static Accessibility_Accessible
 230 impl__get_summary (PortableServer_Servant _servant,
 231                    CORBA_Environment * ev)
 232 {
 233   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 234   AtkObject *atk_object;
 235   Accessibility_Accessible rv;
 236
 237   atk_object = atk_table_get_summary (ATK_TABLE(table->atko));
 238   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(atk_object)));
 239   return CORBA_Object_duplicate (rv, ev);
 240 }
 241
 242
 243
 244 static CORBA_long
 245 impl__get_nRows (PortableServer_Servant _servant,
 246                  CORBA_Environment * ev)
 247 {
 248   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 249   return (CORBA_long)
 250     atk_table_get_n_rows (ATK_TABLE(table->atko) );
 251 }
 252
 253
 254
 255 static CORBA_long
 256 impl__get_nColumns (PortableServer_Servant _servant,
 257                     CORBA_Environment * ev)
 258 {
 259   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 260   return (CORBA_long)
 261     atk_table_get_n_columns (ATK_TABLE(table->atko));
 262 }
 263
 264
 265
 266 static Accessibility_Accessible
 267 impl_getAccessibleAt (PortableServer_Servant _servant,
 268                       const CORBA_long row,
 269                       const CORBA_long column,
 270                       CORBA_Environment * ev)
 271 {
 272   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 273   AtkObject *atk_object;
 274   Accessibility_Accessible rv;
 275
 276   atk_object = atk_table_ref_at (ATK_TABLE(table->atko),
 277                                              (gint) row, (gint) column);
 278   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(atk_object)));
 279   return CORBA_Object_duplicate (rv, ev);
 280 }
 281
 282
 283
 284 static CORBA_long
 285 impl_getIndexAt (PortableServer_Servant _servant,
 286                  const CORBA_long row, const CORBA_long column,
 287                  CORBA_Environment * ev)
 288 {
 289   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 290   return (CORBA_long)
 291     atk_table_get_index_at (ATK_TABLE(table->atko),
 292                             (gint) row, (gint) column);
 293 }
 294
 295
 296
 297 static CORBA_long
 298 impl_getRowAtIndex (PortableServer_Servant _servant,
 299                     const CORBA_long index,
 300                     CORBA_Environment * ev)
 301 {
 302   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 303   return (CORBA_long)
 304     atk_table_get_row_at_index (ATK_TABLE(table->atko), (gint) index);
 305 }
 306
 307
 308
 309 static CORBA_long
 310 impl_getColumnAtIndex (PortableServer_Servant _servant,
 311                        const CORBA_long index,
 312                        CORBA_Environment * ev)
 313 {
 314   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 315   return (CORBA_long)
 316     atk_table_get_column_at_index (ATK_TABLE(table->atko), (gint) index);
 317 }
 318
 319
 320
 321 static CORBA_string
 322 impl_getRowDescription (PortableServer_Servant servant,
 323                         const CORBA_long       row,
 324                         CORBA_Environment     *ev)
 325 {
 326   const char *rv;
 327   SpiTable   *table;
 328
 329   table = SPI_TABLE (bonobo_object_from_servant (servant));
 330
 331   rv = atk_table_get_row_description (ATK_TABLE (table->atko), row);
 332
 333   if (rv)
 334     return CORBA_string_dup (rv);
 335   else
 336     return CORBA_string_dup ("");
 337 }
 338
 339
 340
 341 static CORBA_string
 342 impl_getColumnDescription (PortableServer_Servant servant,
 343                            const CORBA_long       column,
 344                            CORBA_Environment     *ev)
 345 {
 346   const char *rv;
 347   SpiTable   *table;
 348
 349   table = SPI_TABLE (bonobo_object_from_servant (servant));
 350
 351   rv = atk_table_get_row_description (ATK_TABLE (table->atko), column);
 352
 353   if (rv)
 354     return CORBA_string_dup (rv);
 355   else
 356     return CORBA_string_dup ("");
 357 }
 358
 359
 360
 361 static CORBA_long
 362 impl_getRowExtentAt (PortableServer_Servant _servant,
 363                      const CORBA_long row,
 364                      const CORBA_long column,
 365                      CORBA_Environment * ev)
 366 {
 367   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 368   return (CORBA_long)
 369     atk_table_get_row_extent_at (ATK_TABLE(table->atko),
 370                                  (gint) row, (gint) column);
 371 }
 372
 373
 374
 375 static CORBA_long
 376 impl_getColumnExtentAt (PortableServer_Servant _servant,
 377                         const CORBA_long row,
 378                         const CORBA_long column,
 379                         CORBA_Environment * ev)
 380 {
 381   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 382   return (CORBA_long)
 383     atk_table_get_column_extent_at (ATK_TABLE(table->atko),
 384                                  (gint) row, (gint) column);
 385 }
 386
 387
 388
 389 static Accessibility_Table
 390 impl_getRowHeader (PortableServer_Servant _servant,
 391                    const CORBA_long row,
 392                    CORBA_Environment * ev)
 393 {
 394   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 395   AtkObject *header;
 396   Accessibility_Table rv;
 397
 398   header = atk_table_get_row_header (ATK_TABLE(table->atko), (gint) row);
 399   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(header)));
 400   return CORBA_Object_duplicate (rv, ev);
 401 }
 402
 403
 404
 405 static        Accessibility_Table
 406 impl_getColumnHeader (PortableServer_Servant _servant,
 407                       const CORBA_long column,
 408                       CORBA_Environment * ev)
 409 {
 410   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 411   AtkObject *header;
 412   Accessibility_Table rv;
 413
 414   header = atk_table_get_column_header (ATK_TABLE(table->atko), (gint) column);
 415   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(header)));
 416   return CORBA_Object_duplicate (rv, ev);
 417 }
 418
 419
 420
 421 static Accessibility_LongSeq *
 422 impl_getSelectedRows (PortableServer_Servant _servant,
 423                       CORBA_Environment * ev)
 424 {
 425   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 426   gint *selectedRows;
 427   gint length;
 428   Accessibility_LongSeq *retval;
 429
 430   length = atk_table_get_selected_rows (ATK_TABLE(table->atko), &selectedRows);
 431
 432   g_return_val_if_fail (length, NULL);
 433   retval = Accessibility_LongSeq__alloc ();
 434   retval->_maximum = retval->_length = (CORBA_long) length;
 435   retval->_buffer = Accessibility_LongSeq_allocbuf (length);
 436
 437   while (--length)
 438     retval->_buffer[length] = (CORBA_long) selectedRows[length];
 439   g_free ((gpointer) selectedRows);
 440   return retval;
 441 }
 442
 443
 444
 445 static Accessibility_LongSeq *
 446 impl_getSelectedColumns (PortableServer_Servant _servant,
 447                          CORBA_Environment * ev)
 448 {
 449   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 450   gint *selectedColumns;
 451   gint length;
 452   Accessibility_LongSeq *retval;
 453
 454   length = atk_table_get_selected_columns (ATK_TABLE(table->atko), &selectedColumns);
 455
 456   g_return_val_if_fail (length, NULL);
 457
 458   retval = Accessibility_LongSeq__alloc ();
 459   retval->_maximum = retval->_length = (CORBA_long) length;
 460   retval->_buffer = Accessibility_LongSeq_allocbuf (length);
 461
 462   while (--length)
 463     retval->_buffer[length] = (CORBA_long) selectedColumns[length];
 464   g_free ((gpointer) selectedColumns);
 465   return retval;
 466 }
 467
 468
 469
 470 static CORBA_boolean
 471 impl_isRowSelected (PortableServer_Servant _servant,
 472                     const CORBA_long row,
 473                     CORBA_Environment * ev)
 474 {
 475   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 476   return (CORBA_boolean)
 477     atk_table_is_row_selected (ATK_TABLE(table->atko), (gint) row);
 478 }
 479
 480
 481
 482 static CORBA_boolean
 483 impl_isColumnSelected (PortableServer_Servant _servant,
 484                        const CORBA_long column,
 485                        CORBA_Environment * ev)
 486 {
 487   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 488   return (CORBA_boolean)
 489     atk_table_is_column_selected (ATK_TABLE(table->atko), (gint) column);
 490 }
 491
 492
 493
 494 static CORBA_boolean
 495 impl_isSelected (PortableServer_Servant _servant,
 496                  const CORBA_long row,
 497                  const CORBA_long column,
 498                  CORBA_Environment * ev)
 499 {
 500   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
 501   return (CORBA_boolean)
 502     atk_table_is_selected (ATK_TABLE(table->atko),
 503                            (gint) row, (gint) column);
 504 }
 505
 506
 507