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