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