accessibility/source/extended/AccessibleGridControl.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 <extended/AccessibleGridControl.hxx>
  21 #include <extended/AccessibleGridControlTable.hxx>
  22 #include <extended/AccessibleGridControlHeader.hxx>
  23 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  24 #include <com/sun/star/accessibility/AccessibleTableModelChange.hpp>
  25 #include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp>
  26 #include <vcl/accessibletable.hxx>
  27 #include <comphelper/types.hxx>
  28
  29 namespace accessibility
  30 {
  31
  32 using namespace ::com::sun::star::uno;
  33 using namespace ::com::sun::star;
  34 using namespace ::com::sun::star::lang;
  35 using namespace ::com::sun::star::accessibility;
  36 using namespace ::vcl;
  37 using namespace ::vcl::table;
  38
  39 AccessibleGridControl::AccessibleGridControl(
  40             const css::uno::Reference< css::accessibility::XAccessible >& _rxParent, const css::uno::Reference< css::accessibility::XAccessible >& _rxCreator,
  41             ::vcl::table::IAccessibleTable& _rTable )
  42     : AccessibleGridControlBase( _rxParent, _rTable, TCTYPE_GRIDCONTROL ),
  43       m_aCreator(_rxCreator)
  44 {
  45 }
  46
  47
  48 void SAL_CALL AccessibleGridControl::disposing()
  49 {
  50     SolarMutexGuard g;
  51
  52     m_aCreator.clear();
  53
  54     if ( m_xTable.is() )
  55     {
  56         m_xTable->dispose();
  57         m_xTable.clear();
  58     }
  59     if ( m_xCell.is() )
  60     {
  61         m_xCell->dispose();
  62         m_xCell.clear();
  63     }
  64     if ( m_xRowHeaderBar.is() )
  65     {
  66         m_xRowHeaderBar->dispose();
  67         m_xRowHeaderBar.clear();
  68     }
  69     if ( m_xColumnHeaderBar.is() )
  70     {
  71         m_xColumnHeaderBar->dispose();
  72         m_xColumnHeaderBar.clear();
  73     }
  74     AccessibleGridControlBase::disposing();
  75 }
  76
  77
  78 // css::accessibility::XAccessibleContext ---------------------------------------------------------
  79
  80 sal_Int32 SAL_CALL AccessibleGridControl::getAccessibleChildCount()
  81 {
  82     SolarMutexGuard aSolarGuard;
  83     ensureIsAlive();
  84     return m_aTable.GetAccessibleControlCount();
  85 }
  86
  87
  88 css::uno::Reference< css::accessibility::XAccessible > SAL_CALL
  89 AccessibleGridControl::getAccessibleChild( sal_Int32 nChildIndex )
  90 {
  91     SolarMutexGuard aSolarGuard;
  92
  93     if (nChildIndex<0 || nChildIndex>=getAccessibleChildCount())
  94         throw IndexOutOfBoundsException();
  95
  96     css::uno::Reference< css::accessibility::XAccessible > xChild;
  97     if (isAlive())
  98     {
  99         if(nChildIndex == 0 && m_aTable.HasColHeader())
 100         {
 101             if(!m_xColumnHeaderBar.is())
 102             {
 103                 m_xColumnHeaderBar = new AccessibleGridControlHeader(m_aCreator, m_aTable, vcl::table::TCTYPE_COLUMNHEADERBAR);
 104             }
 105             xChild = m_xColumnHeaderBar.get();
 106         }
 107         else if(m_aTable.HasRowHeader() && (nChildIndex == 1 || nChildIndex == 0))
 108         {
 109             if(!m_xRowHeaderBar.is())
 110             {
 111                 m_xRowHeaderBar = new AccessibleGridControlHeader(m_aCreator, m_aTable, vcl::table::TCTYPE_ROWHEADERBAR);
 112             }
 113             xChild = m_xRowHeaderBar.get();
 114         }
 115         else
 116         {
 117             if(!m_xTable.is())
 118             {
 119                 m_xTable = new AccessibleGridControlTable(m_aCreator, m_aTable);
 120             }
 121             xChild = m_xTable.get();
 122         }
 123     }
 124     return xChild;
 125 }
 126
 127
 128 sal_Int16 SAL_CALL AccessibleGridControl::getAccessibleRole()
 129 {
 130     SolarMutexGuard g;
 131
 132     ensureIsAlive();
 133     return AccessibleRole::PANEL;
 134 }
 135
 136
 137 // css::accessibility::XAccessibleComponent -------------------------------------------------------
 138
 139 css::uno::Reference< css::accessibility::XAccessible > SAL_CALL
 140 AccessibleGridControl::getAccessibleAtPoint( const awt::Point& rPoint )
 141 {
 142     SolarMutexGuard aSolarGuard;
 143     ensureIsAlive();
 144
 145     css::uno::Reference< css::accessibility::XAccessible > xChild;
 146     sal_Int32 nIndex = 0;
 147     if( m_aTable.ConvertPointToControlIndex( nIndex, VCLPoint( rPoint ) ) )
 148         xChild = m_aTable.CreateAccessibleControl( nIndex );
 149     else
 150     {
 151         // try whether point is in one of the fixed children
 152         // (table, header bars, corner control)
 153         Point aPoint( VCLPoint( rPoint ) );
 154         for( nIndex = 0; (nIndex < 3) && !xChild.is(); ++nIndex )
 155         {
 156             css::uno::Reference< css::accessibility::XAccessible > xCurrChild( implGetFixedChild( nIndex ) );
 157             css::uno::Reference< css::accessibility::XAccessibleComponent >
 158             xCurrChildComp( xCurrChild, uno::UNO_QUERY );
 159
 160             if( xCurrChildComp.is() &&
 161                 VCLRectangle( xCurrChildComp->getBounds() ).IsInside( aPoint ) )
 162             xChild = xCurrChild;
 163         }
 164     }
 165     return xChild;
 166 }
 167
 168
 169 void SAL_CALL AccessibleGridControl::grabFocus()
 170 {
 171     SolarMutexGuard aSolarGuard;
 172     ensureIsAlive();
 173         m_aTable.GrabFocus();
 174 }
 175
 176 // XServiceInfo ---------------------------------------------------------------
 177
 178 OUString SAL_CALL AccessibleGridControl::getImplementationName()
 179 {
 180     return OUString( "com.sun.star.accessibility.AccessibleGridControl" );
 181 }
 182
 183
 184 // internal virtual methods ---------------------------------------------------
 185
 186 tools::Rectangle AccessibleGridControl::implGetBoundingBox()
 187 {
 188     vcl::Window* pParent = m_aTable.GetAccessibleParentWindow();
 189     OSL_ENSURE( pParent, "implGetBoundingBox - missing parent window" );
 190     return m_aTable.GetWindowExtentsRelative( pParent );
 191 }
 192
 193
 194 tools::Rectangle AccessibleGridControl::implGetBoundingBoxOnScreen()
 195 {
 196     return m_aTable.GetWindowExtentsRelative( nullptr );
 197 }
 198 // internal helper methods ----------------------------------------------------
 199
 200 css::uno::Reference< css::accessibility::XAccessible > AccessibleGridControl::implGetTable()
 201 {
 202     if( !m_xTable.is() )
 203     {
 204         m_xTable = createAccessibleTable();
 205     }
 206     return m_xTable.get();
 207 }
 208
 209
 210 css::uno::Reference< css::accessibility::XAccessible >
 211 AccessibleGridControl::implGetHeaderBar( AccessibleTableControlObjType eObjType )
 212 {
 213     css::uno::Reference< css::accessibility::XAccessible > xRet;
 214     rtl::Reference< AccessibleGridControlHeader >* pxMember = nullptr;
 215
 216     if( eObjType == TCTYPE_ROWHEADERBAR )
 217         pxMember = &m_xRowHeaderBar;
 218     else if( eObjType ==  TCTYPE_COLUMNHEADERBAR )
 219         pxMember = &m_xColumnHeaderBar;
 220
 221     if( pxMember )
 222     {
 223         if( !pxMember->is() )
 224         {
 225             *pxMember = new AccessibleGridControlHeader(
 226                 m_aCreator, m_aTable, eObjType );
 227         }
 228         xRet = pxMember->get();
 229     }
 230     return xRet;
 231 }
 232
 233 css::uno::Reference< css::accessibility::XAccessible >
 234 AccessibleGridControl::implGetFixedChild( sal_Int32 nChildIndex )
 235 {
 236     css::uno::Reference< css::accessibility::XAccessible > xRet;
 237     switch( nChildIndex )
 238     {
 239         /** Child index of the column header bar (first row). */
 240         case 0:
 241             xRet = implGetHeaderBar( TCTYPE_COLUMNHEADERBAR );
 242         break;
 243         /** Child index of the row header bar ("handle column"). */
 244         case 1:
 245             xRet = implGetHeaderBar( TCTYPE_ROWHEADERBAR );
 246         break;
 247         /** Child index of the data table. */
 248         case 2:
 249             xRet = implGetTable();
 250         break;
 251     }
 252     return xRet;
 253 }
 254
 255 AccessibleGridControlTable* AccessibleGridControl::createAccessibleTable()
 256 {
 257     css::uno::Reference< css::accessibility::XAccessible > xCreator(m_aCreator);
 258     OSL_ENSURE( xCreator.is(), "extended/AccessibleGridControl::createAccessibleTable: my creator died - how this?" );
 259     return new AccessibleGridControlTable( xCreator, m_aTable );
 260 }
 261
 262 void AccessibleGridControl::commitCellEvent(sal_Int16 _nEventId,const Any& _rNewValue,const Any& _rOldValue)
 263 {
 264     sal_Int32 nChildCount = getAccessibleChildCount();
 265     if(nChildCount != 0)
 266     {
 267         for(sal_Int32 i=0;i<nChildCount;i++)
 268         {
 269             css::uno::Reference< css::accessibility::XAccessible > xAccessible = getAccessibleChild(i);
 270             if(css::uno::Reference< css::accessibility::XAccessible >(m_xTable.get()) == xAccessible)
 271             {
 272                 std::vector< AccessibleGridControlTableCell* >& rCells =
 273                     m_xTable->getCellVector();
 274                 size_t nIndex = m_aTable.GetCurrentRow() * m_aTable.GetColumnCount()
 275                               + m_aTable.GetCurrentColumn();
 276                 if (nIndex < rCells.size() && rCells[nIndex])
 277                 {
 278                     m_xCell = rCells[nIndex];
 279                     m_xCell->commitEvent( _nEventId, _rNewValue, _rOldValue );
 280                 }
 281             }
 282         }
 283     }
 284     else
 285     {
 286         if ( m_xTable.is() )
 287             m_xTable->commitEvent(_nEventId,_rNewValue,_rOldValue);
 288     }
 289 }
 290
 291 void AccessibleGridControl::commitTableEvent(sal_Int16 _nEventId,const Any& _rNewValue,const Any& _rOldValue)
 292 {
 293     if ( m_xTable.is() )
 294     {
 295         if(_nEventId == AccessibleEventId::ACTIVE_DESCENDANT_CHANGED)
 296         {
 297             const sal_Int32 nCurrentRow = m_aTable.GetCurrentRow();
 298             const sal_Int32 nCurrentCol = m_aTable.GetCurrentColumn();
 299             css::uno::Reference< css::accessibility::XAccessible > xChild;
 300             if (nCurrentRow > -1 && nCurrentCol > -1)
 301             {
 302                 sal_Int32 nColumnCount = m_aTable.GetColumnCount();
 303                 xChild = m_xTable->getAccessibleChild(nCurrentRow * nColumnCount + nCurrentCol);
 304             }
 305             m_xTable->commitEvent(_nEventId, Any(xChild),_rOldValue);
 306         }
 307         else if(_nEventId == AccessibleEventId::TABLE_MODEL_CHANGED)
 308         {
 309             AccessibleTableModelChange aChange;
 310             if(_rNewValue >>= aChange)
 311             {
 312                 if(aChange.Type == AccessibleTableModelChangeType::DELETE)
 313                 {
 314                     std::vector< AccessibleGridControlTableCell* >& rCells =
 315                         m_xTable->getCellVector();
 316                     std::vector< css::uno::Reference< css::accessibility::XAccessible > >& rAccCells =
 317                         m_xTable->getAccessibleCellVector();
 318                     int nColCount = m_aTable.GetColumnCount();
 319                     // check valid index - entries are inserted lazily
 320                     size_t const nStart = nColCount * aChange.FirstRow;
 321                     size_t const nEnd   = nColCount * aChange.LastRow;
 322                     if (nStart < rCells.size())
 323                     {
 324                         m_xTable->getCellVector().erase(
 325                             rCells.begin() + nStart,
 326                             rCells.begin() + std::min(rCells.size(), nEnd));
 327                     }
 328                     if (nStart < rAccCells.size())
 329                     {
 330                         m_xTable->getAccessibleCellVector().erase(
 331                             rAccCells.begin() + nStart,
 332                             rAccCells.begin() + std::min(rAccCells.size(), nEnd));
 333                     }
 334                     m_xTable->commitEvent(_nEventId,_rNewValue,_rOldValue);
 335                 }
 336                 else
 337                     m_xTable->commitEvent(_nEventId,_rNewValue,_rOldValue);
 338             }
 339         }
 340         else
 341             m_xTable->commitEvent(_nEventId,_rNewValue,_rOldValue);
 342     }
 343 }
 344
 345 // = AccessibleGridControlAccess
 346
 347
 348 AccessibleGridControlAccess::AccessibleGridControlAccess(
 349         const css::uno::Reference< css::accessibility::XAccessible >& rxParent, ::vcl::table::IAccessibleTable& rTable )
 350     : m_xParent( rxParent )
 351     , m_pTable( & rTable )
 352 {
 353 }
 354
 355
 356 AccessibleGridControlAccess::~AccessibleGridControlAccess()
 357 {
 358 }
 359
 360
 361 void AccessibleGridControlAccess::DisposeAccessImpl()
 362 {
 363     SolarMutexGuard g;
 364
 365     m_pTable = nullptr;
 366     if (m_xContext.is())
 367     {
 368         m_xContext->dispose();
 369         m_xContext.clear();
 370     }
 371 }
 372
 373
 374 css::uno::Reference< css::accessibility::XAccessibleContext > SAL_CALL AccessibleGridControlAccess::getAccessibleContext()
 375 {
 376     SolarMutexGuard g;
 377
 378     // if the context died meanwhile (we're no listener, so it won't tell us explicitly when this happens),
 379     // then reset an re-create.
 380     if ( m_xContext.is() && !m_xContext->isAlive() )
 381         m_xContext = nullptr;
 382
 383     if (!m_xContext.is() && m_pTable)
 384         m_xContext = new AccessibleGridControl(m_xParent, this, *m_pTable);
 385
 386     return m_xContext.get();
 387 }
 388
 389
 390 }   // namespace accessibility
 391
 392 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */