xref: /aoo41x/main/vcl/unx/gtk/a11y/atktable.cxx (revision 9f62ea84) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_vcl.hxx"
26 
27 #include "atkwrapper.hxx"
28 
29 #include <com/sun/star/accessibility/XAccessibleTable.hpp>
30 
31 #ifdef ENABLE_TRACING
32 #include <stdio.h>
33 #endif
34 
35 using namespace ::com::sun::star;
36 
37 static inline AtkObject *
38 atk_object_wrapper_conditional_ref( const uno::Reference< accessibility::XAccessible >& rxAccessible )
39 {
40 #ifdef ENABLE_TRACING
41     fprintf( stderr, ": %p\n", rxAccessible.get() );
42 #endif
43 
44     if( rxAccessible.is() )
45         return atk_object_wrapper_ref( rxAccessible );
46 
47     return NULL;
48 }
49 
50 /*****************************************************************************/
51 
52 // FIXME
53 static G_CONST_RETURN gchar *
54 getAsConst( rtl::OUString rString )
55 {
56     static const int nMax = 10;
57     static rtl::OString aUgly[nMax];
58     static int nIdx = 0;
59     nIdx = (nIdx + 1) % nMax;
60     aUgly[nIdx] = rtl::OUStringToOString( rString, RTL_TEXTENCODING_UTF8 );
61     return aUgly[ nIdx ];
62 }
63 
64 /*****************************************************************************/
65 
66 static accessibility::XAccessibleTable*
67     getTable( AtkTable *pTable ) throw (uno::RuntimeException)
68 {
69     AtkObjectWrapper *pWrap = ATK_OBJECT_WRAPPER( pTable );
70     if( pWrap )
71     {
72         if( !pWrap->mpTable && pWrap->mpContext )
73         {
74             uno::Any any = pWrap->mpContext->queryInterface( accessibility::XAccessibleTable::static_type(NULL) );
75             pWrap->mpTable = reinterpret_cast< accessibility::XAccessibleTable * > (any.pReserved);
76             pWrap->mpTable->acquire();
77         }
78 
79         return pWrap->mpTable;
80     }
81 
82     return NULL;
83 }
84 
85 /*****************************************************************************/
86 
87 extern "C" {
88 
89 static AtkObject*
90 table_wrapper_ref_at (AtkTable *table,
91                       gint      row,
92                       gint      column)
93 {
94     try {
95         accessibility::XAccessibleTable* pTable = getTable( table );
96 
97 #ifdef ENABLE_TRACING
98         if( pTable )
99             fprintf(stderr, "getAccessibleCellAt( %u, %u ) returns", row, column );
100 
101         if( column >= 255 )
102             fprintf(stderr, "getAccessibleCellAt( %u, %u ) returns", row, column );
103 
104 #endif
105 
106         if( pTable )
107             return atk_object_wrapper_conditional_ref( pTable->getAccessibleCellAt( row, column ) );
108     }
109 
110     catch(const uno::Exception& e) {
111         g_warning( "Exception in getAccessibleCellAt()" );
112     }
113 
114     return NULL;
115 }
116 
117 /*****************************************************************************/
118 
119 static gint
120 table_wrapper_get_index_at (AtkTable      *table,
121                             gint          row,
122                             gint          column)
123 {
124     try {
125         accessibility::XAccessibleTable* pTable = getTable( table );
126 
127 #ifdef ENABLE_TRACING
128         if( pTable )
129             fprintf(stderr, "getAccessibleIndex( %u, %u ) returns %u\n",
130                 row, column, pTable->getAccessibleIndex( row, column ) );
131 #endif
132 
133         if( pTable )
134             return pTable->getAccessibleIndex( row, column );
135     }
136     catch(const uno::Exception& e) {
137         g_warning( "Exception in getAccessibleIndex()" );
138     }
139 
140     return -1;
141 }
142 
143 /*****************************************************************************/
144 
145 static gint
146 table_wrapper_get_column_at_index (AtkTable      *table,
147                                    gint          nIndex)
148 {
149     try {
150         accessibility::XAccessibleTable* pTable = getTable( table );
151 
152 #ifdef ENABLE_TRACING
153         if( pTable )
154             fprintf(stderr, "getAccessibleColumn( %u ) returns %u\n",
155                 nIndex, pTable->getAccessibleColumn( nIndex ) );
156 #endif
157 
158         if( pTable )
159             return pTable->getAccessibleColumn( nIndex );
160     }
161     catch(const uno::Exception& e) {
162         g_warning( "Exception in getAccessibleColumn()" );
163     }
164 
165     return -1;
166 }
167 
168 /*****************************************************************************/
169 
170 static gint
171 table_wrapper_get_row_at_index( AtkTable *table,
172                                 gint      nIndex )
173 {
174     try {
175         accessibility::XAccessibleTable* pTable = getTable( table );
176 
177 #ifdef ENABLE_TRACING
178         if( pTable )
179             fprintf(stderr, "getAccessibleRow( %u ) returns %u\n",
180                 nIndex, pTable->getAccessibleRow( nIndex ) );
181 #endif
182 
183         if( pTable )
184             return pTable->getAccessibleRow( nIndex );
185     }
186     catch(const uno::Exception& e) {
187         g_warning( "Exception in getAccessibleRow()" );
188     }
189 
190     return -1;
191 }
192 
193 /*****************************************************************************/
194 
195 static gint
196 table_wrapper_get_n_columns( AtkTable *table )
197 {
198     try {
199         accessibility::XAccessibleTable* pTable = getTable( table );
200 
201 #ifdef ENABLE_TRACING
202         if( pTable )
203             fprintf(stderr, "XAccessibleTable::getAccessibleColumnCount returns %u\n",
204                 pTable->getAccessibleColumnCount() );
205 #endif
206 
207         if( pTable )
208             return pTable->getAccessibleColumnCount();
209     }
210     catch(const uno::Exception& e) {
211         g_warning( "Exception in getAccessibleColumnCount()" );
212     }
213 
214     return -1;
215 }
216 
217 /*****************************************************************************/
218 
219 static gint
220 table_wrapper_get_n_rows( AtkTable *table )
221 {
222     try {
223         accessibility::XAccessibleTable* pTable = getTable( table );
224 
225 #ifdef ENABLE_TRACING
226         if( pTable )
227             fprintf(stderr, "getAccessibleRowCount() returns %u\n",
228                 pTable->getAccessibleRowCount() );
229 #endif
230 
231         if( pTable )
232             return pTable->getAccessibleRowCount();
233     }
234     catch(const uno::Exception& e) {
235         g_warning( "Exception in getAccessibleRowCount()" );
236     }
237 
238     return -1;
239 }
240 
241 /*****************************************************************************/
242 
243 static gint
244 table_wrapper_get_column_extent_at( AtkTable *table,
245                                     gint      row,
246                                     gint      column )
247 {
248     try {
249         accessibility::XAccessibleTable* pTable = getTable( table );
250 
251 #ifdef ENABLE_TRACING
252         if( pTable )
253             fprintf(stderr, "getAccessibleColumnExtentAt( %u, %u ) returns %u\n",
254                 row, column, pTable->getAccessibleColumnExtentAt( row, column ) );
255 #endif
256 
257         if( pTable )
258             return pTable->getAccessibleColumnExtentAt( row, column );
259     }
260     catch(const uno::Exception& e) {
261         g_warning( "Exception in getAccessibleColumnExtentAt()" );
262     }
263 
264     return -1;
265 }
266 
267 /*****************************************************************************/
268 
269 static gint
270 table_wrapper_get_row_extent_at( AtkTable *table,
271                                  gint      row,
272                                  gint      column )
273 {
274     try {
275         accessibility::XAccessibleTable* pTable = getTable( table );
276 
277 #ifdef ENABLE_TRACING
278         if( pTable )
279             fprintf(stderr, "getAccessibleRowExtentAt( %u, %u ) returns %u\n",
280                 row, column, pTable->getAccessibleRowExtentAt( row, column ) );
281 #endif
282 
283         if( pTable )
284             return pTable->getAccessibleRowExtentAt( row, column );
285     }
286     catch(const uno::Exception& e) {
287         g_warning( "Exception in getAccessibleRowExtentAt()" );
288     }
289 
290     return -1;
291 }
292 
293 /*****************************************************************************/
294 
295 static AtkObject *
296 table_wrapper_get_caption( AtkTable *table )
297 {
298     try {
299         accessibility::XAccessibleTable* pTable = getTable( table );
300 
301 #ifdef ENABLE_TRACING
302         if( pTable )
303             fprintf(stderr, "getAccessibleCaption() returns" );
304 #endif
305 
306         if( pTable )
307             return atk_object_wrapper_conditional_ref( pTable->getAccessibleCaption() );
308     }
309 
310     catch(const uno::Exception& e) {
311         g_warning( "Exception in getAccessibleCaption()" );
312     }
313 
314     return NULL;
315 }
316 
317 /*****************************************************************************/
318 
319 static G_CONST_RETURN gchar *
320 table_wrapper_get_row_description( AtkTable *table,
321                                    gint      row )
322 {
323     try {
324         accessibility::XAccessibleTable* pTable = getTable( table );
325 
326 #ifdef ENABLE_TRACING
327         if( pTable )
328             fprintf(stderr, "getAccessibleRowDescription( %u ) returns %s\n",
329                 row, getAsConst( pTable->getAccessibleRowDescription( row ) ) );
330 #endif
331 
332         if( pTable )
333             return getAsConst( pTable->getAccessibleRowDescription( row ) );
334     }
335     catch(const uno::Exception& e) {
336         g_warning( "Exception in getAccessibleRowDescription()" );
337     }
338 
339     return NULL;
340 }
341 
342 /*****************************************************************************/
343 
344 static G_CONST_RETURN gchar *
345 table_wrapper_get_column_description( AtkTable *table,
346                                       gint      column )
347 {
348     try {
349         accessibility::XAccessibleTable* pTable = getTable( table );
350 
351 #ifdef ENABLE_TRACING
352         if( pTable )
353             fprintf(stderr, "getAccessibleColumnDescription( %u ) returns %s\n",
354                 column, getAsConst( pTable->getAccessibleColumnDescription( column ) ) );
355 #endif
356 
357         if( pTable )
358             return getAsConst( pTable->getAccessibleColumnDescription( column ) );
359     }
360     catch(const uno::Exception& e) {
361         g_warning( "Exception in getAccessibleColumnDescription()" );
362     }
363 
364     return NULL;
365 }
366 
367 /*****************************************************************************/
368 
369 static AtkObject *
370 table_wrapper_get_row_header( AtkTable *table,
371                               gint      row )
372 {
373     try {
374         accessibility::XAccessibleTable* pTable = getTable( table );
375         if( pTable )
376         {
377             uno::Reference< accessibility::XAccessibleTable > xRowHeaders( pTable->getAccessibleRowHeaders() );
378 
379 #ifdef ENABLE_TRACING
380             if( xRowHeaders.is() )
381                 fprintf(stderr, "getAccessibleRowHeader( %u )->getAccessibleCellAt( 0, %u ) returns",
382                     row, row );
383             else
384                 fprintf(stderr, "getAccessibleRowHeader( %u ) returns %p\n", row, xRowHeaders.get() );
385 #endif
386 
387             if( xRowHeaders.is() )
388                 return atk_object_wrapper_conditional_ref( xRowHeaders->getAccessibleCellAt( row, 0 ) );
389         }
390     }
391     catch(const uno::Exception& e) {
392         g_warning( "Exception in getAccessibleRowHeaders()" );
393     }
394 
395     return NULL;
396 }
397 
398 /*****************************************************************************/
399 
400 static AtkObject *
401 table_wrapper_get_column_header( AtkTable *table,
402                                  gint      column )
403 {
404     try {
405         accessibility::XAccessibleTable* pTable = getTable( table );
406 
407         if( pTable )
408         {
409             uno::Reference< accessibility::XAccessibleTable > xColumnHeaders( pTable->getAccessibleColumnHeaders() );
410 
411 #ifdef ENABLE_TRACING
412             if( xColumnHeaders.is() )
413                 fprintf(stderr, "getAccessibleColumnHeader( %u )->getAccessibleCellAt( 0, %u ) returns",
414                     column, column );
415             else
416                 fprintf(stderr, "getAccessibleColumnHeader( %u ) returns %p\n", column, xColumnHeaders.get() );
417 #endif
418 
419             if( xColumnHeaders.is() )
420                 return atk_object_wrapper_conditional_ref( xColumnHeaders->getAccessibleCellAt( 0, column ) );
421         }
422     }
423     catch(const uno::Exception& e) {
424         g_warning( "Exception in getAccessibleColumnHeaders()" );
425     }
426 
427     return NULL;
428 }
429 
430 /*****************************************************************************/
431 
432 static AtkObject *
433 table_wrapper_get_summary( AtkTable *table )
434 {
435     try {
436         accessibility::XAccessibleTable* pTable = getTable( table );
437 
438 #ifdef ENABLE_TRACING
439         if( pTable )
440             fprintf(stderr, "getAccessibleSummary() returns" );
441 #endif
442 
443         if( pTable )
444         {
445     // FIXME: Summary ??
446 //            AtkObject* summary;
447             return atk_object_wrapper_conditional_ref( pTable->getAccessibleSummary() );
448         }
449     }
450     catch(const uno::Exception& e) {
451         g_warning( "Exception in getAccessibleSummary()" );
452     }
453 
454     return NULL;
455 }
456 
457 /*****************************************************************************/
458 
459 static gint
460 convertToGIntArray( const uno::Sequence< ::sal_Int32 >& aSequence, gint **pSelected )
461 {
462     if( aSequence.getLength() )
463     {
464         *pSelected = g_new( gint, aSequence.getLength() );
465 
466         for( sal_Int32 i = 0; i < aSequence.getLength(); i++ )
467             (*pSelected) [i] = aSequence[i];
468     }
469 
470     return aSequence.getLength();
471 }
472 
473 /*****************************************************************************/
474 
475 static gint
476 table_wrapper_get_selected_columns( AtkTable      *table,
477                                     gint          **pSelected )
478 {
479     *pSelected = NULL;
480     try {
481         accessibility::XAccessibleTable* pTable = getTable( table );
482 
483 #ifdef ENABLE_TRACING
484         if( pTable )
485             fprintf(stderr, "getSelectedAccessibleColumns() \n" );
486 #endif
487 
488         if( pTable )
489             return convertToGIntArray( pTable->getSelectedAccessibleColumns(), pSelected );
490     }
491     catch(const uno::Exception& e) {
492         g_warning( "Exception in getSelectedAccessibleColumns()" );
493     }
494 
495     return 0;
496 }
497 
498 /*****************************************************************************/
499 
500 static gint
501 table_wrapper_get_selected_rows( AtkTable      *table,
502                                  gint          **pSelected )
503 {
504     *pSelected = NULL;
505     try {
506         accessibility::XAccessibleTable* pTable = getTable( table );
507 
508 #ifdef ENABLE_TRACING
509         if( pTable )
510             fprintf(stderr, "getSelectedAccessibleRows() \n" );
511 #endif
512 
513         if( pTable )
514             return convertToGIntArray( pTable->getSelectedAccessibleRows(), pSelected );
515     }
516     catch(const uno::Exception& e) {
517         g_warning( "Exception in getSelectedAccessibleRows()" );
518     }
519 
520     return 0;
521 }
522 
523 /*****************************************************************************/
524 
525 static gboolean
526 table_wrapper_is_column_selected( AtkTable      *table,
527                                   gint          column )
528 {
529     try {
530         accessibility::XAccessibleTable* pTable = getTable( table );
531 
532 #ifdef ENABLE_TRACING
533         if( pTable )
534             fprintf(stderr, "isAccessibleColumnSelected( %u ) returns %s\n",
535                 column, pTable->isAccessibleColumnSelected( column ) ? "true" : "false" );
536 #endif
537 
538         if( pTable )
539             return pTable->isAccessibleColumnSelected( column );
540     }
541     catch(const uno::Exception& e) {
542         g_warning( "Exception in isAccessibleColumnSelected()" );
543     }
544 
545     return 0;
546 }
547 
548 /*****************************************************************************/
549 
550 static gboolean
551 table_wrapper_is_row_selected( AtkTable      *table,
552                                gint          row )
553 {
554     try {
555         accessibility::XAccessibleTable* pTable = getTable( table );
556 
557 #ifdef ENABLE_TRACING
558         if( pTable )
559             fprintf(stderr, "isAccessibleRowSelected( %u ) returns %s\n",
560                 row, pTable->isAccessibleRowSelected( row ) ? "true" : "false" );
561 #endif
562 
563         if( pTable )
564             return pTable->isAccessibleRowSelected( row );
565     }
566     catch(const uno::Exception& e) {
567         g_warning( "Exception in isAccessibleRowSelected()" );
568     }
569 
570     return FALSE;
571 }
572 
573 /*****************************************************************************/
574 
575 static gboolean
576 table_wrapper_is_selected( AtkTable      *table,
577                            gint          row,
578                            gint          column )
579 {
580     try {
581         accessibility::XAccessibleTable* pTable = getTable( table );
582 
583 #ifdef ENABLE_TRACING
584         if( pTable )
585             fprintf(stderr, "isAccessibleSelected( %u, %u ) returns %s\n",
586                 row, column, pTable->isAccessibleSelected( row , column ) ? "true" : "false" );
587 #endif
588 
589         if( pTable )
590             return pTable->isAccessibleSelected( row, column );
591     }
592     catch(const uno::Exception& e) {
593         g_warning( "Exception in isAccessibleSelected()" );
594     }
595 
596     return FALSE;
597 }
598 
599 /*****************************************************************************/
600 
601 static gboolean
602 table_wrapper_add_row_selection( AtkTable *, gint )
603 {
604     g_warning( "FIXME: no simple analogue for add_row_selection" );
605     return 0;
606 }
607 
608 /*****************************************************************************/
609 
610 static gboolean
611 table_wrapper_remove_row_selection( AtkTable *, gint )
612 {
613     g_warning( "FIXME: no simple analogue for remove_row_selection" );
614     return 0;
615 }
616 
617 /*****************************************************************************/
618 
619 static gboolean
620 table_wrapper_add_column_selection( AtkTable *, gint )
621 {
622     g_warning( "FIXME: no simple analogue for add_column_selection" );
623     return 0;
624 }
625 
626 /*****************************************************************************/
627 
628 static gboolean
629 table_wrapper_remove_column_selection( AtkTable *, gint )
630 {
631     g_warning( "FIXME: no simple analogue for remove_column_selection" );
632     return 0;
633 }
634 
635 /*****************************************************************************/
636 
637 static void
638 table_wrapper_set_caption( AtkTable *, AtkObject * )
639 { // meaningless helper
640 }
641 
642 /*****************************************************************************/
643 
644 static void
645 table_wrapper_set_column_description( AtkTable *, gint, const gchar * )
646 { // meaningless helper
647 }
648 
649 
650 /*****************************************************************************/
651 
652 static void
653 table_wrapper_set_column_header( AtkTable *, gint, AtkObject * )
654 { // meaningless helper
655 }
656 
657 
658 /*****************************************************************************/
659 
660 static void
661 table_wrapper_set_row_description( AtkTable *, gint, const gchar * )
662 { // meaningless helper
663 }
664 
665 /*****************************************************************************/
666 
667 static void
668 table_wrapper_set_row_header( AtkTable *, gint, AtkObject * )
669 { // meaningless helper
670 }
671 
672 /*****************************************************************************/
673 
674 static void
675 table_wrapper_set_summary( AtkTable *, AtkObject * )
676 { // meaningless helper
677 }
678 
679 /*****************************************************************************/
680 
681 } // extern "C"
682 
683 void
684 tableIfaceInit (AtkTableIface *iface)
685 {
686   g_return_if_fail (iface != NULL);
687 
688   iface->ref_at = table_wrapper_ref_at;
689   iface->get_n_rows = table_wrapper_get_n_rows;
690   iface->get_n_columns = table_wrapper_get_n_columns;
691   iface->get_index_at = table_wrapper_get_index_at;
692   iface->get_column_at_index = table_wrapper_get_column_at_index;
693   iface->get_row_at_index = table_wrapper_get_row_at_index;
694   iface->is_row_selected = table_wrapper_is_row_selected;
695   iface->is_selected = table_wrapper_is_selected;
696   iface->get_selected_rows = table_wrapper_get_selected_rows;
697   iface->add_row_selection = table_wrapper_add_row_selection;
698   iface->remove_row_selection = table_wrapper_remove_row_selection;
699   iface->add_column_selection = table_wrapper_add_column_selection;
700   iface->remove_column_selection = table_wrapper_remove_column_selection;
701   iface->get_selected_columns = table_wrapper_get_selected_columns;
702   iface->is_column_selected = table_wrapper_is_column_selected;
703   iface->get_column_extent_at = table_wrapper_get_column_extent_at;
704   iface->get_row_extent_at = table_wrapper_get_row_extent_at;
705   iface->get_row_header = table_wrapper_get_row_header;
706   iface->set_row_header = table_wrapper_set_row_header;
707   iface->get_column_header = table_wrapper_get_column_header;
708   iface->set_column_header = table_wrapper_set_column_header;
709   iface->get_caption = table_wrapper_get_caption;
710   iface->set_caption = table_wrapper_set_caption;
711   iface->get_summary = table_wrapper_get_summary;
712   iface->set_summary = table_wrapper_set_summary;
713   iface->get_row_description = table_wrapper_get_row_description;
714   iface->set_row_description = table_wrapper_set_row_description;
715   iface->get_column_description = table_wrapper_get_column_description;
716   iface->set_column_description = table_wrapper_set_column_description;
717 }
718