LCOV - code coverage report
Current view: top level - vcl/unx/gtk/a11y - atktable.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 218 0.0 %
Date: 2014-04-14 Functions: 0 35 0.0 %
Legend: Lines: hit not hit

          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: */

Generated by: LCOV version 1.10