2001-11-13 Michael Meeks <michael@ximian.com>
[platform/core/uifw/at-spi2-atk.git] / 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 SpiTable bonobo object
39  */
40 #include "table.h"
41
42 /*
43  * Static function declarations
44  */
45
46 static void
47 spi_table_class_init (SpiTableClass *klass);
48 static void
49 spi_table_init (SpiTable *table);
50 static void
51 spi_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 spi_table_get_type (void)
135 {
136   static GType type = 0;
137
138   if (!type) {
139     static const GTypeInfo tinfo = {
140       sizeof (SpiTableClass),
141       (GBaseInitFunc) NULL,
142       (GBaseFinalizeFunc) NULL,
143       (GClassInitFunc) spi_table_class_init,
144       (GClassFinalizeFunc) NULL,
145       NULL, /* class data */
146       sizeof (SpiTable),
147       0, /* n preallocs */
148       (GInstanceInitFunc) spi_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 (SpiTableClass, epv),
162                                &tinfo,
163                                "SpiAccessibleTable");
164   }
165
166   return type;
167 }
168
169 static void
170 spi_table_class_init (SpiTableClass *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 = spi_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 spi_table_init (SpiTable *table)
204 {
205 }
206
207 static void
208 spi_table_finalize (GObject *obj)
209 {
210   SpiTable *table = SPI_TABLE (obj);
211   g_object_unref (table->atko);
212   table->atko = NULL;  
213   parent_class->finalize (obj);
214 }
215
216 SpiTable *
217 spi_table_interface_new (AtkObject *obj)
218 {
219   SpiTable *new_table =
220     SPI_TABLE(g_object_new (SPI_TABLE_TYPE, NULL));
221   new_table->atko = obj;
222   g_object_ref (obj);
223   return new_table;
224 }
225
226
227
228 static Accessibility_Accessible
229 impl__get_caption (PortableServer_Servant _servant,
230                    CORBA_Environment * ev)
231 {
232   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
233   AtkObject *atk_object;
234   Accessibility_Accessible rv;
235
236   atk_object = atk_table_get_caption (ATK_TABLE(table-> atko));
237   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(atk_object)));
238   return CORBA_Object_duplicate (rv, ev);
239 }
240
241
242
243 static Accessibility_Accessible
244 impl__get_summary (PortableServer_Servant _servant,
245                    CORBA_Environment * ev)
246 {
247   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
248   AtkObject *atk_object;
249   Accessibility_Accessible rv;
250
251   atk_object = atk_table_get_summary (ATK_TABLE(table->atko));
252   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(atk_object)));
253   return CORBA_Object_duplicate (rv, ev);
254 }
255
256
257
258 static CORBA_long
259 impl__get_nRows (PortableServer_Servant _servant,
260                  CORBA_Environment * ev)
261 {
262   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
263   return (CORBA_long)
264     atk_table_get_n_rows (ATK_TABLE(table->atko) );
265 }
266
267
268
269 static CORBA_long
270 impl__get_nColumns (PortableServer_Servant _servant,
271                     CORBA_Environment * ev)
272 {
273   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
274   return (CORBA_long)
275     atk_table_get_n_columns (ATK_TABLE(table->atko));
276 }
277
278
279
280 static Accessibility_Accessible
281 impl_getAccessibleAt (PortableServer_Servant _servant,
282                       const CORBA_long row,
283                       const CORBA_long column,
284                       CORBA_Environment * ev)
285 {
286   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
287   AtkObject *atk_object;
288   Accessibility_Accessible rv;
289
290   atk_object = atk_table_ref_at (ATK_TABLE(table->atko),
291                                              (gint) row, (gint) column);
292   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(atk_object)));
293   return CORBA_Object_duplicate (rv, ev);
294 }
295
296
297
298 static CORBA_long
299 impl_getIndexAt (PortableServer_Servant _servant,
300                  const CORBA_long row, const CORBA_long column,
301                  CORBA_Environment * ev)
302 {
303   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
304   return (CORBA_long)
305     atk_table_get_index_at (ATK_TABLE(table->atko),
306                             (gint) row, (gint) column);
307 }
308
309
310
311 static CORBA_long
312 impl_getRowAtIndex (PortableServer_Servant _servant,
313                     const CORBA_long index,
314                     CORBA_Environment * ev)
315 {
316   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
317   return (CORBA_long)
318     atk_table_get_row_at_index (ATK_TABLE(table->atko), (gint) index);
319 }
320
321
322
323 static CORBA_long
324 impl_getColumnAtIndex (PortableServer_Servant _servant,
325                        const CORBA_long index,
326                        CORBA_Environment * ev)
327 {
328   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
329   return (CORBA_long)
330     atk_table_get_column_at_index (ATK_TABLE(table->atko), (gint) index);
331 }
332
333
334
335 static CORBA_string
336 impl_getRowDescription (PortableServer_Servant _servant,
337                         const CORBA_long row,
338                         CORBA_Environment * ev)
339 {
340   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
341   CORBA_char *rv;
342
343   rv = atk_table_get_row_description (ATK_TABLE(table->atko), (gint) row);
344   if (rv)
345     return CORBA_string_dup (rv);
346   else
347     return CORBA_string_dup ("");
348 }
349
350
351
352 static CORBA_string
353 impl_getColumnDescription (PortableServer_Servant _servant,
354                            const CORBA_long column,
355                            CORBA_Environment * ev)
356 {
357   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
358   CORBA_char *rv;
359
360   rv = atk_table_get_column_description (ATK_TABLE(table->atko), (gint) column);
361   if (rv)
362     return CORBA_string_dup (rv);
363   else
364     return CORBA_string_dup ("");
365 }
366
367
368
369 static CORBA_long
370 impl_getRowExtentAt (PortableServer_Servant _servant,
371                      const CORBA_long row,
372                      const CORBA_long column,
373                      CORBA_Environment * ev)
374 {
375   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
376   return (CORBA_long)
377     atk_table_get_row_extent_at (ATK_TABLE(table->atko),
378                                  (gint) row, (gint) column);
379 }
380
381
382
383 static CORBA_long
384 impl_getColumnExtentAt (PortableServer_Servant _servant,
385                         const CORBA_long row,
386                         const CORBA_long column,
387                         CORBA_Environment * ev)
388 {
389   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
390   return (CORBA_long)
391     atk_table_get_column_extent_at (ATK_TABLE(table->atko),
392                                  (gint) row, (gint) column);
393 }
394
395
396
397 static Accessibility_Table
398 impl_getRowHeader (PortableServer_Servant _servant,
399                    const CORBA_long row,
400                    CORBA_Environment * ev)
401 {
402   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
403   AtkObject *header;
404   Accessibility_Table rv;
405
406   header = atk_table_get_row_header (ATK_TABLE(table->atko), (gint) row);
407   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(header)));
408   return CORBA_Object_duplicate (rv, ev);
409 }
410
411
412
413 static        Accessibility_Table
414 impl_getColumnHeader (PortableServer_Servant _servant,
415                       const CORBA_long column,
416                       CORBA_Environment * ev)
417 {
418   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
419   AtkObject *header;
420   Accessibility_Table rv;
421
422   header = atk_table_get_column_header (ATK_TABLE(table->atko), (gint) column);
423   rv = bonobo_object_corba_objref (BONOBO_OBJECT(spi_accessible_new(header)));
424   return CORBA_Object_duplicate (rv, ev);
425 }
426
427
428
429 static Accessibility_LongSeq *
430 impl_getSelectedRows (PortableServer_Servant _servant,
431                       CORBA_Environment * ev)
432 {
433   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
434   gint *selectedRows;
435   gint length;
436   Accessibility_LongSeq *retval;
437
438   length = atk_table_get_selected_rows (ATK_TABLE(table->atko), &selectedRows);
439
440   g_return_val_if_fail (length, NULL);
441   retval = Accessibility_LongSeq__alloc ();
442   retval->_maximum = retval->_length = (CORBA_long) length;
443   retval->_buffer = Accessibility_LongSeq_allocbuf (length);
444
445   while (--length)
446     retval->_buffer[length] = (CORBA_long) selectedRows[length];
447   g_free ((gpointer) selectedRows);
448   return retval;
449 }
450
451
452
453 static Accessibility_LongSeq *
454 impl_getSelectedColumns (PortableServer_Servant _servant,
455                          CORBA_Environment * ev)
456 {
457   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
458   gint *selectedColumns;
459   gint length;
460   Accessibility_LongSeq *retval;
461
462   length = atk_table_get_selected_columns (ATK_TABLE(table->atko), &selectedColumns);
463
464   g_return_val_if_fail (length, NULL);
465
466   retval = Accessibility_LongSeq__alloc ();
467   retval->_maximum = retval->_length = (CORBA_long) length;
468   retval->_buffer = Accessibility_LongSeq_allocbuf (length);
469
470   while (--length)
471     retval->_buffer[length] = (CORBA_long) selectedColumns[length];
472   g_free ((gpointer) selectedColumns);
473   return retval;
474 }
475
476
477
478 static CORBA_boolean
479 impl_isRowSelected (PortableServer_Servant _servant,
480                     const CORBA_long row,
481                     CORBA_Environment * ev)
482 {
483   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
484   return (CORBA_boolean)
485     atk_table_is_row_selected (ATK_TABLE(table->atko), (gint) row);
486 }
487
488
489
490 static CORBA_boolean
491 impl_isColumnSelected (PortableServer_Servant _servant,
492                        const CORBA_long column,
493                        CORBA_Environment * ev)
494 {
495   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
496   return (CORBA_boolean)
497     atk_table_is_column_selected (ATK_TABLE(table->atko), (gint) column);
498 }
499
500
501
502 static CORBA_boolean
503 impl_isSelected (PortableServer_Servant _servant,
504                  const CORBA_long row,
505                  const CORBA_long column,
506                  CORBA_Environment * ev)
507 {
508   SpiTable *table = SPI_TABLE (bonobo_object_from_servant (_servant));
509   return (CORBA_boolean)
510     atk_table_is_selected (ATK_TABLE(table->atko),
511                            (gint) row, (gint) column);
512 }
513
514
515