accessibility/source/extended/AccessibleGridControlTable.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 <com/sun/star/accessibility/AccessibleEventId.hpp>
  21 #include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
  22 #include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
  23 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  24 #include <extended/AccessibleGridControlTable.hxx>
  25 #include <extended/AccessibleGridControlTableCell.hxx>
  26 #include <vcl/accessibletable.hxx>
  27 #include <vcl/svapp.hxx>
  28 #include <vcl/unohelp.hxx>
  29 #include <tools/debug.hxx>
  30
  31 using ::com::sun::star::uno::Reference;
  32 using ::com::sun::star::uno::Sequence;
  33 using ::com::sun::star::uno::Any;
  34
  35 using namespace ::com::sun::star;
  36 using namespace ::com::sun::star::accessibility;
  37 using namespace ::vcl;
  38 using namespace ::vcl::table;
  39
  40
  41 namespace accessibility {
  42
  43
  44 AccessibleGridControlTable::AccessibleGridControlTable(
  45         const Reference< XAccessible >& rxParent,
  46         IAccessibleTable& rTable) :
  47     AccessibleGridControlTableBase(rxParent, rTable, AccessibleTableControlObjType::TABLE)
  48 {
  49 }
  50
  51 // XAccessibleContext ---------------------------------------------------------
  52
  53 Reference< XAccessible > SAL_CALL
  54 AccessibleGridControlTable::getAccessibleChild( sal_Int64 nChildIndex )
  55 {
  56     SolarMutexGuard aSolarGuard;
  57
  58     ensureIsAlive();
  59     ensureIsValidIndex( nChildIndex );
  60     sal_Int64 nCount = getAccessibleChildCount();
  61     if(m_aCellVector.empty() || m_aCellVector.size() != static_cast<unsigned>(nCount))
  62     {
  63         assert(o3tl::make_unsigned(nCount) < m_aCellVector.max_size());
  64         m_aCellVector.resize(nCount);
  65     }
  66     if(!m_aCellVector[nChildIndex].is())
  67     {
  68         m_aCellVector[nChildIndex].set(new AccessibleGridControlTableCell(this, m_aTable, nChildIndex/m_aTable.GetColumnCount(), nChildIndex%m_aTable.GetColumnCount()));
  69     }
  70     return m_aCellVector[nChildIndex];
  71 }
  72
  73 sal_Int64 SAL_CALL AccessibleGridControlTable::getAccessibleIndexInParent()
  74 {
  75     SolarMutexGuard aSolarGuard;
  76
  77     ensureIsAlive();
  78     if(m_aTable.HasRowHeader() && m_aTable.HasColHeader())
  79         return 0;
  80     else if(m_aTable.HasRowHeader() != m_aTable.HasColHeader())
  81         return 1;
  82     else
  83         return 2;
  84 }
  85
  86 // XAccessibleComponent -------------------------------------------------------
  87
  88 Reference< XAccessible > SAL_CALL
  89 AccessibleGridControlTable::getAccessibleAtPoint( const awt::Point& rPoint )
  90 {
  91     SolarMutexGuard aSolarGuard;
  92
  93     ensureIsAlive();
  94
  95     Reference< XAccessible > xChild;
  96     sal_Int32 nRow = 0;
  97     sal_Int32 nColumnPos = 0;
  98     if (m_aTable.ConvertPointToCellAddress(nRow, nColumnPos,
  99                                            vcl::unohelper::ConvertToVCLPoint(rPoint)))
 100         xChild = new AccessibleGridControlTableCell(this, m_aTable, nRow, nColumnPos);
 101     return xChild;
 102 }
 103
 104 void SAL_CALL AccessibleGridControlTable::grabFocus()
 105 {
 106     SolarMutexGuard aSolarGuard;
 107
 108     ensureIsAlive();
 109     m_aTable.GrabFocus();
 110 }
 111
 112 // XAccessibleTable -----------------------------------------------------------
 113
 114 OUString SAL_CALL AccessibleGridControlTable::getAccessibleRowDescription( sal_Int32 nRow )
 115 {
 116     SolarMutexGuard aSolarGuard;
 117
 118     ensureIsAlive();
 119     ensureIsValidRow( nRow );
 120     return u"row description"_ustr;
 121 }
 122
 123 OUString SAL_CALL AccessibleGridControlTable::getAccessibleColumnDescription( sal_Int32 nColumn )
 124 {
 125     SolarMutexGuard aSolarGuard;
 126
 127     ensureIsAlive();
 128     ensureIsValidColumn( nColumn );
 129     return u"col description"_ustr;
 130 }
 131
 132 Reference< XAccessibleTable > SAL_CALL AccessibleGridControlTable::getAccessibleRowHeaders()
 133 {
 134     SolarMutexGuard g;
 135
 136     ensureIsAlive();
 137     if(m_aTable.HasColHeader())
 138         return implGetHeaderBar( 1 );
 139     else
 140         return implGetHeaderBar( 0 );
 141 }
 142
 143 Reference< XAccessibleTable > SAL_CALL AccessibleGridControlTable::getAccessibleColumnHeaders()
 144 {
 145     SolarMutexGuard g;
 146
 147     ensureIsAlive();
 148     return implGetHeaderBar( 0 );
 149 }
 150
 151 Sequence< sal_Int32 > SAL_CALL AccessibleGridControlTable::getSelectedAccessibleRows()
 152 {
 153     SolarMutexGuard aSolarGuard;
 154
 155     ensureIsAlive();
 156     Sequence< sal_Int32 > aSelSeq;
 157     implGetSelectedRows( aSelSeq );
 158     return aSelSeq;
 159 }
 160
 161 //columns aren't selectable
 162 Sequence< sal_Int32 > SAL_CALL AccessibleGridControlTable::getSelectedAccessibleColumns()
 163 {
 164     return {};
 165 }
 166
 167 sal_Bool SAL_CALL AccessibleGridControlTable::isAccessibleRowSelected( sal_Int32 nRow )
 168 {
 169     SolarMutexGuard aSolarGuard;
 170
 171     ensureIsAlive();
 172     ensureIsValidRow( nRow );
 173     Sequence< sal_Int32 > selectedRows = getSelectedAccessibleRows();
 174     return comphelper::findValue(selectedRows, nRow) != -1;
 175 }
 176
 177 //columns aren't selectable
 178 sal_Bool SAL_CALL AccessibleGridControlTable::isAccessibleColumnSelected( sal_Int32 )
 179 {
 180     return false;
 181 }
 182
 183 Reference< XAccessible > SAL_CALL AccessibleGridControlTable::getAccessibleCellAt(
 184         sal_Int32 nRow, sal_Int32 nColumn )
 185 {
 186     SolarMutexGuard aSolarGuard;
 187
 188     ensureIsAlive();
 189     ensureIsValidAddress( nRow, nColumn );
 190     sal_Int64 nChildIndex = static_cast<sal_Int64>(nRow) * static_cast<sal_Int64>(m_aTable.GetColumnCount()) + nColumn;
 191     return getAccessibleChild(nChildIndex);
 192 }
 193
 194 sal_Bool SAL_CALL AccessibleGridControlTable::isAccessibleSelected(
 195         sal_Int32 nRow, sal_Int32 nColumn )
 196 {
 197     SolarMutexGuard aSolarGuard;
 198
 199     ensureIsAlive();
 200     ensureIsValidAddress( nRow, nColumn );
 201     //selection of single cells not possible, so if row is selected, the cell will be selected too
 202     return isAccessibleRowSelected(nRow);
 203 }
 204 void SAL_CALL AccessibleGridControlTable::selectAccessibleChild( sal_Int64 nChildIndex )
 205 {
 206     SolarMutexGuard aSolarGuard;
 207
 208     ensureIsAlive();
 209     ensureIsValidIndex( nChildIndex );
 210     sal_Int32 nColumns = m_aTable.GetColumnCount();
 211     sal_Int32 nRow = nChildIndex / nColumns;
 212     m_aTable.SelectRow( nRow, true );
 213 }
 214 sal_Bool SAL_CALL AccessibleGridControlTable::isAccessibleChildSelected( sal_Int64 nChildIndex )
 215 {
 216     SolarMutexGuard aSolarGuard;
 217
 218     ensureIsAlive();
 219     ensureIsValidIndex( nChildIndex );
 220     sal_Int32 nColumns = m_aTable.GetColumnCount();
 221     sal_Int32 nRow = nChildIndex / nColumns;
 222     return isAccessibleRowSelected(nRow);
 223 }
 224 void SAL_CALL AccessibleGridControlTable::clearAccessibleSelection()
 225 {
 226     SolarMutexGuard aSolarGuard;
 227
 228     ensureIsAlive();
 229     m_aTable.SelectAllRows( false );
 230 }
 231 void SAL_CALL AccessibleGridControlTable::selectAllAccessibleChildren()
 232 {
 233     SolarMutexGuard aSolarGuard;
 234
 235     ensureIsAlive();
 236     Sequence< sal_Int32 > selectedRows = getSelectedAccessibleRows();
 237     auto selectedRowsRange = asNonConstRange(selectedRows);
 238     for(tools::Long i=0; i<m_aTable.GetRowCount(); i++)
 239         selectedRowsRange[i]=i;
 240 }
 241 sal_Int64 SAL_CALL AccessibleGridControlTable::getSelectedAccessibleChildCount()
 242 {
 243     SolarMutexGuard aSolarGuard;
 244
 245     ensureIsAlive();
 246     Sequence< sal_Int32 > selectedRows = getSelectedAccessibleRows();
 247     sal_Int32 nColumns = m_aTable.GetColumnCount();
 248     return static_cast<sal_Int64>(selectedRows.getLength()) * static_cast<sal_Int64>(nColumns);
 249 }
 250 Reference< XAccessible > SAL_CALL
 251 AccessibleGridControlTable::getSelectedAccessibleChild( sal_Int64 nSelectedChildIndex )
 252 {
 253     SolarMutexGuard aSolarGuard;
 254
 255     ensureIsAlive();
 256     if (nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount())
 257         throw lang::IndexOutOfBoundsException(u"Invalid index into selection"_ustr, *this);
 258
 259     const sal_Int32 nColCount = getAccessibleColumnCount();
 260     assert(nColCount > 0 && "Column count non-positive, but child count > 0");
 261     const sal_Int32 nIndexInSelectedRowsSequence = nSelectedChildIndex / nColCount;
 262     const Sequence<sal_Int32> aSelectedRows = getSelectedAccessibleRows();
 263     const sal_Int32 nRowIndex = aSelectedRows[nIndexInSelectedRowsSequence];
 264     const sal_Int32 nColIndex = nSelectedChildIndex % nColCount;
 265     return getAccessibleCellAt(nRowIndex, nColIndex);
 266 }
 267 //not implemented yet, because only row selection possible
 268 void SAL_CALL AccessibleGridControlTable::deselectAccessibleChild(
 269         sal_Int64 )
 270 {
 271     SolarMutexGuard aSolarGuard;
 272
 273     ensureIsAlive();
 274 }
 275 // XInterface -----------------------------------------------------------------
 276
 277 Any SAL_CALL AccessibleGridControlTable::queryInterface( const uno::Type& rType )
 278 {
 279     Any aAny( AccessibleGridControlTableBase::queryInterface( rType ) );
 280     return aAny.hasValue() ?
 281         aAny : AccessibleGridControlTableSelectionImplHelper::queryInterface( rType );
 282 }
 283
 284 void SAL_CALL AccessibleGridControlTable::acquire() noexcept
 285 {
 286     AccessibleGridControlTableBase::acquire();
 287 }
 288
 289 void SAL_CALL AccessibleGridControlTable::release() noexcept
 290 {
 291     AccessibleGridControlTableBase::release();
 292 }
 293 // XServiceInfo ---------------------------------------------------------------
 294
 295 OUString SAL_CALL AccessibleGridControlTable::getImplementationName()
 296 {
 297     return u"com.sun.star.accessibility.AccessibleGridControlTable"_ustr;
 298 }
 299
 300 void AccessibleGridControlTable::dispose()
 301 {
 302     for (rtl::Reference<AccessibleGridControlTableCell>& rxCell : m_aCellVector)
 303     {
 304         if (rxCell.is())
 305         {
 306             rxCell->dispose();
 307             rxCell.clear();
 308         }
 309     }
 310
 311     AccessibleGridControlTableBase::dispose();
 312 }
 313
 314 void AccessibleGridControlTable::commitEvent(sal_Int16 nEventId, const css::uno::Any& rNewValue,
 315                                              const css::uno::Any& rOldValue)
 316 {
 317     if (nEventId == AccessibleEventId::TABLE_MODEL_CHANGED)
 318     {
 319         AccessibleTableModelChange aChange;
 320         if (rNewValue >>= aChange)
 321         {
 322             assert(aChange.Type != AccessibleTableModelChangeType::COLUMNS_REMOVED);
 323
 324             if (aChange.Type == AccessibleTableModelChangeType::ROWS_REMOVED)
 325             {
 326                 int nColCount = m_aTable.GetColumnCount();
 327                 // check valid index - entries are inserted lazily
 328                 size_t const nStart = nColCount * aChange.FirstRow;
 329                 size_t const nEnd = nColCount * aChange.LastRow;
 330                 if (nStart < m_aCellVector.size())
 331                 {
 332                     m_aCellVector.erase(
 333                         m_aCellVector.begin() + nStart,
 334                         m_aCellVector.begin() + std::min(m_aCellVector.size(), nEnd));
 335                 }
 336             }
 337         }
 338     }
 339
 340     AccessibleGridControlBase::commitEvent(nEventId, rNewValue, rOldValue);
 341 }
 342
 343 // internal virtual methods ---------------------------------------------------
 344
 345 tools::Rectangle AccessibleGridControlTable::implGetBoundingBox()
 346 {
 347     vcl::Window* pParent = m_aTable.GetAccessibleParentWindow();
 348     assert(pParent && "implGetBoundingBox - missing parent window");
 349     tools::Rectangle aGridRect( m_aTable.GetWindowExtentsRelative( *pParent ));
 350     tools::Rectangle aTableRect( m_aTable.calcTableRect() );
 351     tools::Long nX = aGridRect.Left() + aTableRect.Left();
 352     tools::Long nY = aGridRect.Top() + aTableRect.Top();
 353     tools::Long nWidth = aGridRect.GetSize().Width()-aTableRect.Left();
 354     tools::Long nHeight = aGridRect.GetSize().Height()-aTableRect.Top();
 355     tools::Rectangle aTable( Point( nX, nY ), Size( nWidth, nHeight ));
 356     return aTable;
 357 }
 358
 359 AbsoluteScreenPixelRectangle AccessibleGridControlTable::implGetBoundingBoxOnScreen()
 360 {
 361     tools::Rectangle aGridRect( m_aTable.GetWindowExtentsAbsolute());
 362     tools::Rectangle aTableRect( m_aTable.calcTableRect() );
 363     tools::Long nX = aGridRect.Left() + aTableRect.Left();
 364     tools::Long nY = aGridRect.Top() + aTableRect.Top();
 365     tools::Long nWidth = aGridRect.GetSize().Width()-aTableRect.Left();
 366     tools::Long nHeight = aGridRect.GetSize().Height()-aTableRect.Top();
 367     AbsoluteScreenPixelRectangle aTable( AbsoluteScreenPixelPoint( nX, nY ), AbsoluteScreenPixelSize( nWidth, nHeight ));
 368     return aTable;
 369 }
 370 // internal helper methods ----------------------------------------------------
 371 Reference< XAccessibleTable > AccessibleGridControlTable::implGetHeaderBar(
 372         sal_Int32 nChildIndex )
 373 {
 374     Reference< XAccessible > xRet;
 375
 376     if (!m_xParent.is())
 377         return nullptr;
 378
 379     Reference<XAccessibleContext> xContext = m_xParent->getAccessibleContext();
 380     if( xContext.is() )
 381     {
 382         try
 383         {
 384             xRet = xContext->getAccessibleChild( nChildIndex );
 385         }
 386         catch (const lang::IndexOutOfBoundsException&)
 387         {
 388             OSL_FAIL( "implGetHeaderBar - wrong child index" );
 389         }
 390         // RuntimeException goes to caller
 391     }
 392     return Reference< XAccessibleTable >( xRet, uno::UNO_QUERY );
 393 }
 394
 395
 396 } // namespace accessibility
 397
 398
 399 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */