winaccessibility/source/UAccCOM/AccTableCell.cxx

   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 "AccTableCell.h"
  21 #include "MAccessible.h"
  22
  23 #include <vcl/svapp.hxx>
  24 #include <com/sun/star/accessibility/XAccessible.hpp>
  25
  26 using namespace com::sun::star::accessibility;
  27 using namespace com::sun::star::uno;
  28
  29 CAccTableCell::CAccTableCell()
  30     : m_nIndexInParent(0)
  31 {
  32 }
  33
  34 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::put_XInterface(hyper pXInterface)
  35 {
  36     // internal IUNOXWrapper - no mutex meeded
  37
  38     try
  39     {
  40         CUNOXWrapper::put_XInterface(pXInterface);
  41         if (pUNOInterface == nullptr)
  42             return E_INVALIDARG;
  43
  44         Reference<XAccessibleContext> xContext = pUNOInterface->getAccessibleContext();
  45         if (!xContext.is())
  46             return E_FAIL;
  47
  48         // retrieve reference to table (parent of the cell)
  49         Reference<XAccessibleContext> xParentContext
  50             = xContext->getAccessibleParent()->getAccessibleContext();
  51         Reference<XAccessibleTable> xTable(xParentContext, UNO_QUERY);
  52
  53         if (!xTable.is())
  54         {
  55             m_xTable.clear();
  56             return E_FAIL;
  57         }
  58
  59         m_xTable = xTable;
  60         m_nIndexInParent = xContext->getAccessibleIndexInParent();
  61         return S_OK;
  62     }
  63     catch (...)
  64     {
  65         return E_FAIL;
  66     }
  67 }
  68
  69 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_columnExtent(long* pColumnsSpanned)
  70 {
  71     SolarMutexGuard g;
  72
  73     try
  74     {
  75         if (pColumnsSpanned == nullptr)
  76             return E_INVALIDARG;
  77
  78         if (!m_xTable.is())
  79             return E_FAIL;
  80
  81         long nRow = 0, nColumn = 0;
  82         get_rowIndex(&nRow);
  83         get_columnIndex(&nColumn);
  84
  85         *pColumnsSpanned = m_xTable->getAccessibleColumnExtentAt(nRow, nColumn);
  86         return S_OK;
  87     }
  88     catch (...)
  89     {
  90         return E_FAIL;
  91     }
  92 }
  93
  94 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_columnHeaderCells(IUnknown*** cellAccessibles,
  95                                                                        long* pColumnHeaderCellCount)
  96 {
  97     SolarMutexGuard g;
  98
  99     if (!cellAccessibles || !pColumnHeaderCellCount)
 100         return E_INVALIDARG;
 101
 102     if (!m_xTable.is())
 103         return E_FAIL;
 104
 105     Reference<XAccessibleTable> xHeaders = m_xTable->getAccessibleColumnHeaders();
 106     if (!xHeaders.is())
 107         return E_FAIL;
 108
 109     const sal_Int32 nCount = xHeaders->getAccessibleRowCount();
 110     *pColumnHeaderCellCount = nCount;
 111     *cellAccessibles = static_cast<IUnknown**>(CoTaskMemAlloc(nCount * sizeof(IUnknown*)));
 112     sal_Int32 nCol = 0;
 113     get_columnIndex(&nCol);
 114     for (sal_Int32 nRow = 0; nRow < nCount; nRow++)
 115     {
 116         Reference<XAccessible> xCell = xHeaders->getAccessibleCellAt(nRow, nCol);
 117         assert(xCell.is());
 118
 119         IAccessible* pIAccessible = CMAccessible::get_IAccessibleFromXAccessible(xCell.get());
 120         if (!pIAccessible)
 121         {
 122             Reference<XAccessible> xTableAcc(m_xTable, UNO_QUERY);
 123             CMAccessible::g_pAccObjectManager->InsertAccObj(xCell.get(), xTableAcc.get());
 124             pIAccessible = CMAccessible::get_IAccessibleFromXAccessible(xCell.get());
 125         }
 126         assert(pIAccessible && "Couldn't retrieve IAccessible object for cell.");
 127
 128         pIAccessible->AddRef();
 129         (*cellAccessibles)[nRow] = pIAccessible;
 130     }
 131     return S_OK;
 132 }
 133
 134 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_columnIndex(long* pColumnIndex)
 135 {
 136     SolarMutexGuard g;
 137
 138     try
 139     {
 140         if (pColumnIndex == nullptr)
 141             return E_INVALIDARG;
 142
 143         if (!m_xTable.is())
 144             return E_FAIL;
 145
 146         *pColumnIndex = m_xTable->getAccessibleColumn(m_nIndexInParent);
 147         return S_OK;
 148     }
 149     catch (...)
 150     {
 151         return E_FAIL;
 152     }
 153 }
 154
 155 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_rowExtent(long* pRowsSpanned)
 156 {
 157     SolarMutexGuard g;
 158
 159     try
 160     {
 161         if (pRowsSpanned == nullptr)
 162             return E_INVALIDARG;
 163
 164         if (!m_xTable.is())
 165             return E_FAIL;
 166
 167         long nRow = 0, nColumn = 0;
 168         get_rowIndex(&nRow);
 169         get_columnIndex(&nColumn);
 170
 171         *pRowsSpanned = m_xTable->getAccessibleRowExtentAt(nRow, nColumn);
 172
 173         return S_OK;
 174     }
 175     catch (...)
 176     {
 177         return E_FAIL;
 178     }
 179 }
 180
 181 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_rowHeaderCells(IUnknown*** cellAccessibles,
 182                                                                     long* pRowHeaderCellCount)
 183 {
 184     SolarMutexGuard g;
 185
 186     if (!cellAccessibles || !pRowHeaderCellCount)
 187         return E_INVALIDARG;
 188
 189     if (!m_xTable.is())
 190         return E_FAIL;
 191
 192     Reference<XAccessibleTable> xHeaders = m_xTable->getAccessibleRowHeaders();
 193     if (!xHeaders.is())
 194         return E_FAIL;
 195
 196     const sal_Int32 nCount = xHeaders->getAccessibleColumnCount();
 197     *pRowHeaderCellCount = nCount;
 198     *cellAccessibles = static_cast<IUnknown**>(CoTaskMemAlloc(nCount * sizeof(IUnknown*)));
 199     sal_Int32 nRow = 0;
 200     get_rowIndex(&nRow);
 201     for (sal_Int32 nCol = 0; nCol < nCount; nCol++)
 202     {
 203         Reference<XAccessible> xCell = xHeaders->getAccessibleCellAt(nRow, nCol);
 204         assert(xCell.is());
 205
 206         IAccessible* pIAccessible = CMAccessible::get_IAccessibleFromXAccessible(xCell.get());
 207         if (!pIAccessible)
 208         {
 209             Reference<XAccessible> xTableAcc(m_xTable, UNO_QUERY);
 210             CMAccessible::g_pAccObjectManager->InsertAccObj(xCell.get(), xTableAcc.get());
 211             pIAccessible = CMAccessible::get_IAccessibleFromXAccessible(xCell.get());
 212         }
 213         assert(pIAccessible && "Couldn't retrieve IAccessible object for cell.");
 214
 215         pIAccessible->AddRef();
 216         (*cellAccessibles)[nCol] = pIAccessible;
 217     }
 218     return S_OK;
 219 }
 220
 221 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_rowIndex(long* pRowIndex)
 222 {
 223     SolarMutexGuard g;
 224
 225     try
 226     {
 227         if (pRowIndex == nullptr)
 228             return E_INVALIDARG;
 229
 230         if (!m_xTable.is())
 231             return E_FAIL;
 232
 233         *pRowIndex = m_xTable->getAccessibleRow(m_nIndexInParent);
 234         return S_OK;
 235     }
 236     catch (...)
 237     {
 238         return E_FAIL;
 239     }
 240 }
 241
 242 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_isSelected(boolean* pIsSelected)
 243 {
 244     SolarMutexGuard g;
 245
 246     try
 247     {
 248         if (pIsSelected == nullptr)
 249             return E_INVALIDARG;
 250
 251         if (!m_xTable.is())
 252             return E_FAIL;
 253
 254         long nRow = 0, nColumn = 0;
 255         get_rowIndex(&nRow);
 256         get_columnIndex(&nColumn);
 257
 258         *pIsSelected = m_xTable->isAccessibleSelected(nRow, nColumn);
 259         return S_OK;
 260     }
 261     catch (...)
 262     {
 263         return E_FAIL;
 264     }
 265 }
 266
 267 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_rowColumnExtents(long* pRow, long* pColumn,
 268                                                                       long* pRowExtents,
 269                                                                       long* pColumnExtents,
 270                                                                       boolean* pIsSelected)
 271 {
 272     SolarMutexGuard g;
 273
 274     if (!pRow || !pColumn || !pRowExtents || !pColumnExtents || !pIsSelected)
 275         return E_INVALIDARG;
 276
 277     if (get_rowIndex(pRow) != S_OK)
 278         return E_FAIL;
 279     if (get_columnIndex(pColumn) != S_OK)
 280         return E_FAIL;
 281     if (get_rowExtent(pRowExtents) != S_OK)
 282         return E_FAIL;
 283     if (get_columnExtent(pColumnExtents) != S_OK)
 284         return E_FAIL;
 285     if (get_isSelected(pIsSelected) != S_OK)
 286         return E_FAIL;
 287     return S_OK;
 288 }
 289
 290 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTableCell::get_table(IUnknown** ppTable)
 291 {
 292     if (!ppTable)
 293         return E_INVALIDARG;
 294
 295     if (!m_xTable.is())
 296         return E_FAIL;
 297
 298     Reference<XAccessible> xAcc(m_xTable, UNO_QUERY);
 299     if (!xAcc.is())
 300         return E_FAIL;
 301
 302     IAccessible* pRet = CMAccessible::get_IAccessibleFromXAccessible(xAcc.get());
 303     if (!pRet)
 304         return E_FAIL;
 305
 306     *ppTable = pRet;
 307     pRet->AddRef();
 308     return S_OK;
 309 }
 310
 311 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */