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