toolkit/test/accessibility/AccessibleCellHandler.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 import com.sun.star.uno.UnoRuntime;
  20 import com.sun.star.accessibility.XAccessibleContext;
  21 import com.sun.star.accessibility.XAccessibleTable;
  22 import com.sun.star.accessibility.XAccessible;
  23
  24
  25 class AccessibleCellHandler extends NodeHandler
  26 {
  27     public NodeHandler createHandler (XAccessibleContext xContext)
  28     {
  29         AccessibleCellHandler aCellHandler = null;
  30         if (xContext != null)
  31         {
  32             XAccessible xParent = xContext.getAccessibleParent();
  33             if (xParent != null)
  34             {
  35                 XAccessibleTable xTable =
  36                     UnoRuntime.queryInterface (
  37                     XAccessibleTable.class, xParent.getAccessibleContext());
  38                 if (xTable != null)
  39                     aCellHandler = new AccessibleCellHandler (xTable);
  40             }
  41         }
  42         return aCellHandler;
  43
  44     }
  45
  46     public AccessibleCellHandler ()
  47     {
  48     }
  49
  50     public AccessibleCellHandler (XAccessibleTable xTable)
  51     {
  52         if (xTable != null)
  53             maChildList.setSize (8);
  54     }
  55
  56     protected static XAccessibleTable getTable(Object aObject)
  57     {
  58         return UnoRuntime.queryInterface (
  59             XAccessibleTable.class, aObject);
  60     }
  61
  62     public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
  63     {
  64         AccessibleTreeNode aChild = null;
  65         XAccessibleTable xTable = null;
  66         XAccessibleContext xContext = null;
  67         AccessibleTreeNode aGrandParent = aParent.getParent();
  68         if (aGrandParent instanceof AccTreeNode)
  69         {
  70             xTable = ((AccTreeNode)aGrandParent).getTable();
  71             xContext = ((AccTreeNode)aGrandParent).getContext();
  72         }
  73         if (aParent instanceof AccTreeNode)
  74         {
  75             xContext = ((AccTreeNode)aParent).getContext();
  76         }
  77         try
  78         {
  79             if( xTable != null && xContext != null )
  80             {
  81                 switch( nIndex )
  82                 {
  83                     case 0:
  84                         {
  85                             int nChild = xContext.getAccessibleIndexInParent();
  86                             int nRow = xTable.getAccessibleRow( nChild );
  87
  88                             aChild = new StringNode ("# table row: " + nRow, aParent);
  89                         }
  90                         break;
  91                     case 1:
  92                         {
  93                             int nChild = xContext.getAccessibleIndexInParent();
  94                             int nCol = xTable.getAccessibleColumn( nChild );
  95
  96                             aChild = new StringNode ("# table column: " + nCol, aParent);
  97                         }
  98                         break;
  99                     case 2:
 100                         {
 101                             int nChild = xContext.getAccessibleIndexInParent();
 102                             int nRow = xTable.getAccessibleRow( nChild );
 103                             int nCol = xTable.getAccessibleColumn( nChild );
 104                             int nExt = xTable.getAccessibleRowExtentAt( nRow, nCol );
 105
 106                             aChild = new StringNode ("# table row extend: " + nExt, aParent);
 107                         }
 108                         break;
 109                      case 3:
 110                         {
 111                             int nChild = xContext.getAccessibleIndexInParent();
 112                             int nRow = xTable.getAccessibleRow( nChild );
 113                             int nCol = xTable.getAccessibleColumn( nChild );
 114                             int nExt = xTable.getAccessibleColumnExtentAt( nRow, nCol );
 115
 116                             aChild = new StringNode ("# table column extend: " + nExt, aParent);
 117                         }
 118                         break;
 119                      case 4:
 120                         {
 121                             int nChild = xContext.getAccessibleIndexInParent();
 122                             int nRow = xTable.getAccessibleRow( nChild );
 123                             int nCol = xTable.getAccessibleColumn( nChild );
 124                             XAccessible xChild =
 125                                 xTable.getAccessibleCellAt( nRow, nCol );
 126
 127                             aChild = new StringNode ("# cell name retrieved from table: " + xChild.getAccessibleContext().getAccessibleName(), aParent);
 128                         }
 129                         break;
 130                      case 5:
 131                         {
 132                             int nChild = xContext.getAccessibleIndexInParent();
 133                             int nRow = xTable.getAccessibleRow( nChild );
 134                             int nCol = xTable.getAccessibleColumn( nChild );
 135                             boolean bSelected =
 136                                 xTable.isAccessibleSelected( nRow, nCol );
 137
 138                             aChild = new StringNode ("cell is selected: " + bSelected, aParent);
 139                         }
 140                         break;
 141                      case 6:
 142                         {
 143                             int nChild = xContext.getAccessibleIndexInParent();
 144                             int nRow = xTable.getAccessibleRow( nChild );
 145                             boolean bSelected =
 146                                 xTable.isAccessibleRowSelected( nRow );
 147
 148                             aChild = new StringNode ("table row is selected: " + bSelected, aParent);
 149                         }
 150                         break;
 151                      case 7:
 152                         {
 153                             int nChild = xContext.getAccessibleIndexInParent();
 154                             int nCol = xTable.getAccessibleColumn( nChild );
 155                             boolean bSelected =
 156                                 xTable.isAccessibleColumnSelected( nCol );
 157
 158                             aChild = new StringNode ("table column is selected: " + bSelected, aParent);
 159                         }
 160                         break;
 161                     default:
 162                         aChild = new StringNode ("unknown child index " + nIndex, aParent);
 163                 }
 164             }
 165         }
 166         catch (Exception e)
 167         {
 168             // Return empty child.
 169         }
 170
 171         return aChild;
 172     }
 173 }