vcl/osx/a11ytablewrapper.mm

   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
  21 #include <osx/a11yfactory.h>
  22
  23 #include "a11ytablewrapper.h"
  24
  25 using namespace ::com::sun::star::accessibility;
  26 using namespace ::com::sun::star::awt;
  27 using namespace ::com::sun::star::uno;
  28
  29 @implementation AquaA11yTableWrapper : AquaA11yWrapper
  30
  31 +(id)childrenAttributeForElement:(AquaA11yTableWrapper *)wrapper
  32 {
  33     XAccessibleTable * accessibleTable = [ wrapper accessibleTable ];
  34     NSArray* pResult = nil;
  35     if( accessibleTable )
  36     {
  37         NSMutableArray * cells = [ [ NSMutableArray alloc ] init ];
  38         try
  39         {
  40             sal_Int32 nRows = accessibleTable->getAccessibleRowCount();
  41             sal_Int32 nCols = accessibleTable->getAccessibleColumnCount();
  42
  43             // tdf#152648 Handle overflow when multiplying rows and columns
  44             sal_Int64 nCells = static_cast<sal_Int64>(nRows) * static_cast<sal_Int64>(nCols);
  45             if( nCells >= 0 && nCells < MAXIMUM_ACCESSIBLE_TABLE_CELLS )
  46             {
  47                 // make all children visible to the hierarchy
  48                 for ( sal_Int32 rowCount = 0; rowCount < nRows; rowCount++ )
  49                 {
  50                     for ( sal_Int32 columnCount = 0; columnCount < nCols; columnCount++ )
  51                     {
  52                         Reference < XAccessible > rAccessibleCell = accessibleTable -> getAccessibleCellAt ( rowCount, columnCount );
  53                         if ( rAccessibleCell.is() )
  54                         {
  55                             id cell_wrapper = [ AquaA11yFactory wrapperForAccessibleContext: rAccessibleCell -> getAccessibleContext() ];
  56                             [ cells addObject: cell_wrapper ];
  57                             [ cell_wrapper release ];
  58                         }
  59                     }
  60                 }
  61             }
  62             else
  63             {
  64                 XAccessibleComponent * accessibleComponent = [ wrapper accessibleComponent ];
  65                 // find out which cells are actually visible by determining the top-left-cell and the bottom-right-cell
  66                 Size tableSize = accessibleComponent -> getSize();
  67                 Point point;
  68                 point.X = 0;
  69                 point.Y = 0;
  70                 Reference < XAccessible > rAccessibleTopLeft = accessibleComponent -> getAccessibleAtPoint ( point );
  71                 point.X = tableSize.Width - 1;
  72                 point.Y = tableSize.Height - 1;
  73                 Reference < XAccessible > rAccessibleBottomRight = accessibleComponent -> getAccessibleAtPoint ( point );
  74                 if ( rAccessibleTopLeft.is() && rAccessibleBottomRight.is() )
  75                 {
  76                     sal_Int64 idxTopLeft = rAccessibleTopLeft -> getAccessibleContext() -> getAccessibleIndexInParent();
  77                     sal_Int64 idxBottomRight = rAccessibleBottomRight -> getAccessibleContext() -> getAccessibleIndexInParent();
  78                     sal_Int32 rowTopLeft = accessibleTable -> getAccessibleRow ( idxTopLeft );
  79                     sal_Int32 columnTopLeft = accessibleTable -> getAccessibleColumn ( idxTopLeft );
  80                     sal_Int32 rowBottomRight = accessibleTable -> getAccessibleRow ( idxBottomRight );
  81                     sal_Int32 columnBottomRight = accessibleTable -> getAccessibleColumn ( idxBottomRight );
  82                     // create an array containing the visible cells
  83                     for ( sal_Int32 rowCount = rowTopLeft; rowCount <= rowBottomRight; rowCount++ )
  84                     {
  85                         for ( sal_Int32 columnCount = columnTopLeft; columnCount <= columnBottomRight; columnCount++ )
  86                         {
  87                             Reference < XAccessible > rAccessibleCell = accessibleTable -> getAccessibleCellAt ( rowCount, columnCount );
  88                             if ( rAccessibleCell.is() )
  89                             {
  90                                 id cell_wrapper = [ AquaA11yFactory wrapperForAccessibleContext: rAccessibleCell -> getAccessibleContext() ];
  91                                 [ cells addObject: cell_wrapper ];
  92                                 [ cell_wrapper release ];
  93                             }
  94                         }
  95                     }
  96                 }
  97             }
  98             pResult = NSAccessibilityUnignoredChildren( cells );
  99         }
 100         catch (const Exception &)
 101         {
 102         }
 103         [cells autorelease];
 104     }
 105
 106     return pResult;
 107 }
 108
 109 +(void)addAttributeNamesTo: (NSMutableArray *)attributeNames object: (AquaA11yWrapper*)pObject
 110 {
 111     XAccessibleTable * accessibleTable = [ pObject accessibleTable ];
 112     if( accessibleTable )
 113     {
 114         sal_Int32 nRows = accessibleTable->getAccessibleRowCount();
 115         sal_Int32 nCols = accessibleTable->getAccessibleColumnCount();
 116
 117         // tdf#152648 Handle overflow when multiplying rows and columns
 118         sal_Int64 nCells = static_cast<sal_Int64>(nRows) * static_cast<sal_Int64>(nCols);
 119         if( nCells >= 0 && nCells < MAXIMUM_ACCESSIBLE_TABLE_CELLS )
 120         {
 121             [ attributeNames addObject: NSAccessibilityRowsAttribute ];
 122             [ attributeNames addObject: NSAccessibilityColumnsAttribute ];
 123         }
 124     }
 125 }
 126
 127 -(id)rowsAttribute
 128 {
 129     NSArray* pResult = nil;
 130
 131     XAccessibleTable * accessibleTable = [ self accessibleTable ];
 132     if( accessibleTable )
 133     {
 134         sal_Int32 nRows = accessibleTable->getAccessibleRowCount();
 135         sal_Int32 nCols = accessibleTable->getAccessibleColumnCount();
 136
 137         // tdf#152648 Handle overflow when multiplying rows and columns
 138         sal_Int64 nCells = static_cast<sal_Int64>(nRows) * static_cast<sal_Int64>(nCols);
 139         if( nCells >= 0 && nCells < MAXIMUM_ACCESSIBLE_TABLE_CELLS )
 140         {
 141             NSMutableArray * cells = [ [ NSMutableArray alloc ] init ];
 142             try
 143             {
 144                 for( sal_Int32 n = 0; n < nRows; n++ )
 145                 {
 146                     Reference < XAccessible > rAccessibleCell = accessibleTable -> getAccessibleCellAt ( n, 0 );
 147                     if ( rAccessibleCell.is() )
 148                     {
 149                         id cell_wrapper = [ AquaA11yFactory wrapperForAccessibleContext: rAccessibleCell -> getAccessibleContext() ];
 150                         [ cells addObject: cell_wrapper ];
 151                         [ cell_wrapper release ];
 152                     }
 153                 }
 154                 pResult = NSAccessibilityUnignoredChildren( cells );
 155             }
 156             catch (const Exception &)
 157             {
 158                 pResult = nil;
 159             }
 160             [ cells autorelease ];
 161         }
 162     }
 163
 164     return pResult;
 165 }
 166
 167 -(id)columnsAttribute
 168 {
 169     NSArray* pResult = nil;
 170
 171     XAccessibleTable * accessibleTable = [ self accessibleTable ];
 172
 173     if( accessibleTable )
 174     {
 175         sal_Int32 nRows = accessibleTable->getAccessibleRowCount();
 176         sal_Int32 nCols = accessibleTable->getAccessibleColumnCount();
 177
 178         // tdf#152648 Handle overflow when multiplying rows and columns
 179         sal_Int64 nCells = static_cast<sal_Int64>(nRows) * static_cast<sal_Int64>(nCols);
 180         if( nCells >= 0 && nCells < MAXIMUM_ACCESSIBLE_TABLE_CELLS )
 181         {
 182             NSMutableArray * cells = [ [ NSMutableArray alloc ] init ];
 183             try
 184             {
 185                 // find out number of columns
 186                 for( sal_Int32 n = 0; n < nCols; n++ )
 187                 {
 188                     Reference < XAccessible > rAccessibleCell = accessibleTable -> getAccessibleCellAt ( 0, n );
 189                     if ( rAccessibleCell.is() )
 190                     {
 191                         id cell_wrapper = [ AquaA11yFactory wrapperForAccessibleContext: rAccessibleCell -> getAccessibleContext() ];
 192                         [ cells addObject: cell_wrapper ];
 193                         [ cell_wrapper release ];
 194                     }
 195                 }
 196                 pResult = NSAccessibilityUnignoredChildren( cells );
 197             }
 198             catch (const Exception &)
 199             {
 200                 pResult = nil;
 201             }
 202             [ cells autorelease ];
 203         }
 204     }
 205
 206     return pResult;
 207 }
 208
 209 @end
 210
 211 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */