svtools/source/brwbox/brwbox3.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 <osl/diagnose.h>
  21 #include <svtools/brwbox.hxx>
  22 #include <vcl/AccessibleBrowseBoxObjType.hxx>
  23 #include <vcl/accessiblefactory.hxx>
  24 #include <sal/log.hxx>
  25 #include <tools/debug.hxx>
  26 #include <tools/multisel.hxx>
  27 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  28
  29 // Accessibility ==============================================================
  30
  31 using namespace ::com::sun::star::uno;
  32 using ::com::sun::star::accessibility::XAccessible;
  33 using namespace ::com::sun::star::accessibility;
  34
  35
  36 namespace svt
  37 {
  38     static Reference< XAccessible > getHeaderCell(BrowseBox::THeaderCellMap& _raHeaderCells,
  39                                             sal_Int32 _nPos,
  40                                             AccessibleBrowseBoxObjType _eType,
  41                                             const Reference< XAccessible >& _rParent,
  42                                             BrowseBox& _rBrowseBox,
  43                                             vcl::IAccessibleFactory const & rFactory
  44                                           )
  45     {
  46         Reference< XAccessible > xRet;
  47         BrowseBox::THeaderCellMap::iterator aFind = _raHeaderCells.find(_nPos);
  48         if ( aFind == _raHeaderCells.end() )
  49         {
  50             Reference< XAccessible > xAccessible = rFactory.createAccessibleBrowseBoxHeaderCell(
  51                 _nPos,
  52                 _rParent,
  53                 _rBrowseBox,
  54                 _eType
  55             );
  56             aFind = _raHeaderCells.emplace( _nPos, xAccessible ).first;
  57         }
  58         if ( aFind != _raHeaderCells.end() )
  59             xRet = aFind->second;
  60         return xRet;
  61     }
  62 }
  63
  64 Reference<XAccessible> BrowseBox::getAccessibleHeaderBar(AccessibleBrowseBoxObjType _eObjType)
  65 {
  66     if (m_pAccessible && m_pAccessible->isAlive())
  67         return m_pAccessible->getHeaderBar(_eObjType);
  68     return nullptr;
  69 }
  70
  71 Reference<XAccessible> BrowseBox::getAccessibleTable()
  72 {
  73     if (m_pAccessible && m_pAccessible->isAlive())
  74         return m_pAccessible->getTable();
  75     return nullptr;
  76 }
  77
  78 Reference< XAccessible > BrowseBox::CreateAccessible()
  79 {
  80     vcl::Window* pParent = GetAccessibleParentWindow();
  81     DBG_ASSERT( pParent, "BrowseBox::CreateAccessible - parent not found" );
  82
  83     if (pParent && !m_pAccessible)
  84     {
  85         Reference< XAccessible > xAccParent = pParent->GetAccessible();
  86         if( xAccParent.is() )
  87         {
  88             m_pAccessible = getAccessibleFactory().createAccessibleBrowseBox(
  89                 xAccParent, *this
  90             );
  91         }
  92     }
  93
  94     return m_pAccessible;
  95 }
  96
  97
  98 // Children -------------------------------------------------------------------
  99
 100 Reference< XAccessible > BrowseBox::CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos )
 101 {
 102     // BBINDEX_TABLE must be the table
 103     OSL_ENSURE(m_pAccessible,"Invalid call: Accessible is null");
 104
 105     return m_aFactoryAccess.getFactory().createAccessibleBrowseBoxTableCell(
 106         getAccessibleTable(),
 107         *this,
 108         _nRow,
 109         _nColumnPos,
 110         OFFSET_DEFAULT
 111     );
 112 }
 113
 114
 115 Reference< XAccessible > BrowseBox::CreateAccessibleRowHeader( sal_Int32 _nRow )
 116 {
 117     return svt::getHeaderCell(
 118         m_aRowHeaderCellMap,
 119         _nRow,
 120         AccessibleBrowseBoxObjType::RowHeaderCell,
 121         getAccessibleHeaderBar(AccessibleBrowseBoxObjType::RowHeaderBar),
 122         *this,
 123         m_aFactoryAccess.getFactory()
 124     );
 125 }
 126
 127
 128 Reference< XAccessible > BrowseBox::CreateAccessibleColumnHeader( sal_uInt16 _nColumnPos )
 129 {
 130     return svt::getHeaderCell(
 131             m_aColHeaderCellMap,
 132             _nColumnPos,
 133             AccessibleBrowseBoxObjType::ColumnHeaderCell,
 134             getAccessibleHeaderBar(AccessibleBrowseBoxObjType::ColumnHeaderBar),
 135             *this,
 136             m_aFactoryAccess.getFactory()
 137     );
 138 }
 139
 140
 141 sal_Int32 BrowseBox::GetAccessibleControlCount() const
 142 {
 143     return 0;
 144 }
 145
 146
 147 Reference< XAccessible > BrowseBox::CreateAccessibleControl( sal_Int32 )
 148 {
 149     SAL_WARN( "svtools", "BrowseBox::CreateAccessibleControl: to be overwritten!" );
 150     return nullptr;
 151 }
 152
 153
 154 // Conversions ----------------------------------------------------------------
 155
 156 bool BrowseBox::ConvertPointToCellAddress(
 157         sal_Int32& rnRow, sal_uInt16& rnColumnPos, const Point& rPoint )
 158 {
 159     //! TODO has to be checked
 160     rnRow = GetRowAtYPosPixel(rPoint.Y());
 161     rnColumnPos = GetColumnAtXPosPixel(rPoint.X());
 162     return rnRow != BROWSER_INVALIDID && rnColumnPos != BROWSER_INVALIDID;
 163 }
 164
 165
 166 bool BrowseBox::ConvertPointToRowHeader( sal_Int32& rnRow, const Point& rPoint )
 167 {
 168     rnRow = GetRowAtYPosPixel(rPoint.Y());
 169     //  sal_uInt16 nColumnId = GetColumnAtXPosPixel(rPoint.X());
 170     return rnRow != BROWSER_INVALIDID;// && nColumnId == 0;
 171 }
 172
 173
 174 bool BrowseBox::ConvertPointToColumnHeader( sal_uInt16& _rnColumnPos, const Point& _rPoint )
 175 {
 176     _rnColumnPos = GetColumnAtXPosPixel(_rPoint.X());
 177     return _rnColumnPos != BROWSER_INVALIDID;
 178 }
 179
 180
 181 bool BrowseBox::ConvertPointToControlIndex( sal_Int32& _rnIndex, const Point& _rPoint )
 182 {
 183     //! TODO has to be checked
 184     sal_Int32 nRow = 0;
 185     sal_uInt16 nColumn = 0;
 186     bool bRet = ConvertPointToCellAddress(nRow,nColumn,_rPoint);
 187     if ( bRet )
 188         _rnIndex = nRow * ColCount() + nColumn;
 189
 190     return bRet;
 191 }
 192
 193
 194 // Object data and state ------------------------------------------------------
 195
 196 OUString BrowseBox::GetAccessibleObjectName( AccessibleBrowseBoxObjType eObjType,sal_Int32 _nPosition) const
 197 {
 198     OUString aRetText;
 199     switch( eObjType )
 200     {
 201         case AccessibleBrowseBoxObjType::BrowseBox:
 202             aRetText = "BrowseBox";
 203             break;
 204         case AccessibleBrowseBoxObjType::Table:
 205             aRetText = "Table";
 206             break;
 207         case AccessibleBrowseBoxObjType::RowHeaderBar:
 208             aRetText = "RowHeaderBar";
 209             break;
 210         case AccessibleBrowseBoxObjType::ColumnHeaderBar:
 211             aRetText = "ColumnHeaderBar";
 212             break;
 213         case AccessibleBrowseBoxObjType::TableCell:
 214             if( ColCount() !=0 && GetRowCount()!=0)
 215             {
 216
 217                 sal_Int32 columnId = _nPosition % ColCount() +1;
 218                 aRetText = GetColumnDescription( sal_Int16( columnId ) );
 219                 sal_Int32 rowId = _nPosition / GetRowCount() + 1;
 220                 aRetText += OUString::number(rowId);
 221             }
 222             else
 223                 aRetText = "TableCell";
 224 #if OSL_DEBUG_LEVEL > 0
 225             aRetText += " ["
 226                         + OUString::number(GetCurRow())
 227                         + ","
 228                         + OUString::number(sal_Int32(GetCurColumnId()))
 229                         + "]";
 230 #endif
 231             break;
 232         case AccessibleBrowseBoxObjType::RowHeaderCell:
 233             {
 234                 sal_Int32 rowId = _nPosition + 1;
 235                 aRetText = OUString::number( rowId );
 236             }
 237 #if OSL_DEBUG_LEVEL > 0
 238             aRetText += " ["
 239                         + OUString::number(GetCurRow())
 240                         + ","
 241                         + OUString::number(sal_Int32(GetCurColumnId()))
 242                         + "]";
 243 #endif
 244             break;
 245         case AccessibleBrowseBoxObjType::ColumnHeaderCell:
 246             aRetText = GetColumnDescription( sal_Int16( _nPosition ) );
 247 #if OSL_DEBUG_LEVEL > 0
 248             aRetText += " ["
 249                         + OUString::number(GetCurRow())
 250                         + ","
 251                         + OUString::number(sal_Int32(GetCurColumnId()))
 252                         + "]";
 253 #endif
 254             break;
 255         default:
 256             OSL_FAIL("BrowseBox::GetAccessibleName: invalid enum!");
 257     }
 258     return aRetText;
 259 }
 260
 261
 262 OUString BrowseBox::GetAccessibleObjectDescription( AccessibleBrowseBoxObjType eObjType,sal_Int32 ) const
 263 {
 264     OUString aRetText;
 265     switch( eObjType )
 266     {
 267         case AccessibleBrowseBoxObjType::BrowseBox:
 268             aRetText = "BrowseBox description";
 269             break;
 270         case AccessibleBrowseBoxObjType::Table:
 271             //  aRetText = "TABLE description";
 272             break;
 273         case AccessibleBrowseBoxObjType::RowHeaderBar:
 274             //  aRetText = "ROWHEADERBAR description";
 275             break;
 276         case AccessibleBrowseBoxObjType::ColumnHeaderBar:
 277             //  aRetText = "COLUMNHEADERBAR description";
 278             break;
 279         case AccessibleBrowseBoxObjType::TableCell:
 280             //  aRetText = "TABLECELL description";
 281             break;
 282         case AccessibleBrowseBoxObjType::RowHeaderCell:
 283             //  aRetText = "ROWHEADERCELL description";
 284             break;
 285         case AccessibleBrowseBoxObjType::ColumnHeaderCell:
 286             //  aRetText = "COLUMNHEADERCELL description";
 287             break;
 288         case AccessibleBrowseBoxObjType::CheckBoxCell:
 289             break;
 290     }
 291     return aRetText;
 292 }
 293
 294
 295 OUString BrowseBox::GetRowDescription( sal_Int32 ) const
 296 {
 297     return OUString();
 298 }
 299
 300
 301 OUString BrowseBox::GetColumnDescription( sal_uInt16 _nColumn ) const
 302 {
 303     return GetColumnTitle( GetColumnId( _nColumn ) );
 304 }
 305
 306
 307 void BrowseBox::FillAccessibleStateSet(
 308         sal_Int64& rStateSet,
 309         AccessibleBrowseBoxObjType eObjType ) const
 310 {
 311     switch( eObjType )
 312     {
 313         case AccessibleBrowseBoxObjType::BrowseBox:
 314         case AccessibleBrowseBoxObjType::Table:
 315
 316             rStateSet |= AccessibleStateType::FOCUSABLE;
 317             if ( HasFocus() )
 318                 rStateSet |= AccessibleStateType::FOCUSED;
 319             if ( IsActive() )
 320                 rStateSet |= AccessibleStateType::ACTIVE;
 321             if ( GetUpdateMode() )
 322                 rStateSet |= AccessibleStateType::EDITABLE;
 323             if ( IsEnabled() )
 324             {
 325                 rStateSet |= AccessibleStateType::ENABLED;
 326                 rStateSet |= AccessibleStateType::SENSITIVE;
 327             }
 328             if ( IsReallyVisible() )
 329                 rStateSet |= AccessibleStateType::VISIBLE;
 330             if ( eObjType == AccessibleBrowseBoxObjType::Table )
 331                 rStateSet |= AccessibleStateType::MANAGES_DESCENDANTS;
 332
 333             break;
 334         case AccessibleBrowseBoxObjType::RowHeaderBar:
 335             rStateSet |= AccessibleStateType::FOCUSABLE;
 336             rStateSet |= AccessibleStateType::VISIBLE;
 337             if ( GetSelectRowCount() )
 338                 rStateSet |= AccessibleStateType::FOCUSED;
 339             rStateSet |= AccessibleStateType::MANAGES_DESCENDANTS;
 340             break;
 341         case AccessibleBrowseBoxObjType::ColumnHeaderBar:
 342             rStateSet |= AccessibleStateType::FOCUSABLE;
 343             rStateSet |= AccessibleStateType::VISIBLE;
 344             if ( GetSelectColumnCount() )
 345                 rStateSet |= AccessibleStateType::FOCUSED;
 346             rStateSet |= AccessibleStateType::MANAGES_DESCENDANTS;
 347             break;
 348         case AccessibleBrowseBoxObjType::TableCell:
 349             {
 350                 sal_Int32 nRow = GetCurRow();
 351                 sal_uInt16 nColumn = GetCurColumnId();
 352                 if ( IsFieldVisible(nRow,nColumn) )
 353                     rStateSet |= AccessibleStateType::VISIBLE;
 354                 if ( !IsFrozen( nColumn ) )
 355                     rStateSet |= AccessibleStateType::FOCUSABLE;
 356                 rStateSet |= AccessibleStateType::TRANSIENT;
 357             }
 358             break;
 359         case AccessibleBrowseBoxObjType::RowHeaderCell:
 360         case AccessibleBrowseBoxObjType::ColumnHeaderCell:
 361         case AccessibleBrowseBoxObjType::CheckBoxCell:
 362             OSL_FAIL("Illegal call here!");
 363             break;
 364     }
 365 }
 366
 367 void BrowseBox::FillAccessibleStateSetForCell( sal_Int64& _rStateSet,
 368                                                sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const
 369 {
 370     //! TODO check if the state is valid for table cells
 371     if ( IsCellVisible( _nRow, _nColumnPos ) )
 372         _rStateSet |= AccessibleStateType::VISIBLE;
 373     if ( GetCurrRow() == _nRow && GetCurrColumn() == _nColumnPos )
 374         _rStateSet |= AccessibleStateType::FOCUSED;
 375     else // only transient when column is not focused
 376         _rStateSet |= AccessibleStateType::TRANSIENT;
 377 }
 378
 379
 380 void BrowseBox::GrabTableFocus()
 381 {
 382     GrabFocus();
 383 }
 384
 385 OUString BrowseBox::GetCellText(sal_Int32, sal_uInt16 ) const
 386 {
 387     SAL_WARN("svtools", "This method has to be implemented by the derived classes! BUG!!");
 388     return OUString();
 389 }
 390
 391
 392 void BrowseBox::commitHeaderBarEvent(sal_Int16 nEventId,
 393         const Any& rNewValue, const Any& rOldValue, bool _bColumnHeaderBar )
 394 {
 395     if ( isAccessibleAlive() )
 396         m_pAccessible->commitHeaderBarEvent( nEventId,
 397             rNewValue, rOldValue, _bColumnHeaderBar );
 398 }
 399
 400 void BrowseBox::commitTableEvent( sal_Int16 _nEventId, const Any& _rNewValue, const Any& _rOldValue )
 401 {
 402     if ( isAccessibleAlive() )
 403         m_pAccessible->commitTableEvent(_nEventId, _rNewValue, _rOldValue);
 404 }
 405
 406 void BrowseBox::commitBrowseBoxEvent( sal_Int16 _nEventId, const Any& _rNewValue, const Any& _rOldValue )
 407 {
 408     if ( isAccessibleAlive() )
 409         m_pAccessible->commitEvent( _nEventId, _rNewValue, _rOldValue);
 410 }
 411
 412 ::vcl::IAccessibleFactory& BrowseBox::getAccessibleFactory()
 413 {
 414     return m_aFactoryAccess.getFactory();
 415 }
 416
 417 bool BrowseBox::isAccessibleAlive( ) const
 418 {
 419     return m_pAccessible && m_pAccessible->isAlive();
 420 }
 421
 422 // IAccessibleTableProvider
 423
 424 sal_Int32 BrowseBox::GetCurrRow() const
 425 {
 426     return GetCurRow();
 427 }
 428
 429 sal_uInt16 BrowseBox::GetCurrColumn() const
 430 {
 431     return GetColumnPos( GetCurColumnId() );
 432 }
 433
 434 bool BrowseBox::HasRowHeader() const
 435 {
 436     return ( GetColumnId( 0 ) == HandleColumnId ); // HandleColumn == RowHeader
 437 }
 438
 439 bool BrowseBox::GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumn )
 440 {
 441     return GoToRowColumnId( _nRow, GetColumnId( _nColumn ) );
 442 }
 443
 444 void BrowseBox::SelectColumn( sal_uInt16 _nColumn, bool _bSelect )
 445 {
 446     SelectColumnPos( _nColumn, _bSelect );
 447 }
 448
 449 bool BrowseBox::IsColumnSelected( sal_Int32 _nColumn ) const
 450 {
 451     return ( pColSel && (0 <= _nColumn) && (_nColumn <= 0xFFF) ) &&
 452         pColSel->IsSelected( static_cast< sal_uInt16 >( _nColumn ) );
 453 }
 454
 455 sal_Int32 BrowseBox::GetSelectedRowCount() const
 456 {
 457     return GetSelectRowCount();
 458 }
 459
 460 sal_Int32 BrowseBox::GetSelectedColumnCount() const
 461 {
 462     const MultiSelection* pColumnSel = GetColumnSelection();
 463     return pColumnSel ? pColumnSel->GetSelectCount() : 0;
 464 }
 465
 466 void BrowseBox::GetAllSelectedRows( css::uno::Sequence< sal_Int32 >& _rRows ) const
 467 {
 468     sal_Int32 nCount = GetSelectRowCount();
 469     if( nCount )
 470     {
 471         _rRows.realloc( nCount );
 472         auto pRows = _rRows.getArray();
 473         pRows[ 0 ] = const_cast< BrowseBox* >( this )->FirstSelectedRow();
 474         for( sal_Int32 nIndex = 1; nIndex < nCount; ++nIndex )
 475             pRows[ nIndex ] = const_cast< BrowseBox* >( this )->NextSelectedRow();
 476         DBG_ASSERT( const_cast< BrowseBox* >( this )->NextSelectedRow() == BROWSER_ENDOFSELECTION,
 477                     "BrowseBox::GetAllSelectedRows - too many selected rows found" );
 478     }
 479 }
 480
 481 void BrowseBox::GetAllSelectedColumns( css::uno::Sequence< sal_Int32 >& _rColumns ) const
 482 {
 483     const MultiSelection* pColumnSel = GetColumnSelection();
 484     sal_Int32 nCount = GetSelectedColumnCount();
 485     if( !(pColumnSel && nCount) )
 486         return;
 487
 488     _rColumns.realloc( nCount );
 489     auto pColumns = _rColumns.getArray();
 490
 491     sal_Int32 nIndex = 0;
 492     const size_t nRangeCount = pColumnSel->GetRangeCount();
 493     for( size_t nRange = 0; nRange < nRangeCount; ++nRange )
 494     {
 495         const Range& rRange = pColumnSel->GetRange( nRange );
 496         // loop has to include aRange.Max()
 497         for( sal_Int32 nCol = rRange.Min(); nCol <= static_cast<sal_Int32>(rRange.Max()); ++nCol )
 498         {
 499             DBG_ASSERT( nIndex < nCount,
 500                 "GetAllSelectedColumns - range overflow" );
 501             pColumns[ nIndex ] = nCol;
 502             ++nIndex;
 503         }
 504     }
 505 }
 506
 507 bool BrowseBox::IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const
 508 {
 509     return IsFieldVisible( _nRow, GetColumnId( _nColumnPos ) );
 510 }
 511
 512 OUString BrowseBox::GetAccessibleCellText(sal_Int32 _nRow, sal_uInt16 _nColPos) const
 513 {
 514     return GetCellText( _nRow, GetColumnId( _nColPos ) );
 515 }
 516
 517
 518 bool BrowseBox::GetGlyphBoundRects( const Point& rOrigin, const OUString& rStr, int nIndex, int nLen, std::vector< tools::Rectangle >& rVector )
 519 {
 520     return GetOutDev()->GetGlyphBoundRects( rOrigin, rStr, nIndex, nLen, rVector );
 521 }
 522
 523 AbsoluteScreenPixelRectangle BrowseBox::GetWindowExtentsAbsolute() const
 524 {
 525     return Control::GetWindowExtentsAbsolute();
 526 }
 527
 528 tools::Rectangle BrowseBox::GetWindowExtentsRelative(const vcl::Window& rRelativeWindow) const
 529 {
 530     return Control::GetWindowExtentsRelative( rRelativeWindow );
 531 }
 532
 533 void BrowseBox::GrabFocus()
 534 {
 535     Control::GrabFocus();
 536 }
 537
 538 Reference< XAccessible > BrowseBox::GetAccessible()
 539 {
 540     return Control::GetAccessible();
 541 }
 542
 543 vcl::Window* BrowseBox::GetAccessibleParentWindow() const
 544 {
 545     return Control::GetAccessibleParentWindow();
 546 }
 547
 548 vcl::Window* BrowseBox::GetWindowInstance()
 549 {
 550     return this;
 551 }
 552
 553 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */