sc/source/ui/Accessibility/AccessiblePreviewTable.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
  21 #include "scitems.hxx"
  22 #include "AccessiblePreviewTable.hxx"
  23 #include "AccessiblePreviewCell.hxx"
  24 #include "AccessiblePreviewHeaderCell.hxx"
  25 #include "AccessibilityHints.hxx"
  26 #include "prevwsh.hxx"
  27 #include "miscuno.hxx"
  28 #include "prevloc.hxx"
  29 #include "attrib.hxx"
  30 #include "document.hxx"
  31 #include "scresid.hxx"
  32 #include "sc.hrc"
  33
  34 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  35 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  36 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  37
  38 #include <vcl/window.hxx>
  39 #include <vcl/svapp.hxx>
  40 #include <svl/smplhint.hxx>
  41 #include <unotools/accessiblestatesethelper.hxx>
  42 #include <comphelper/sequence.hxx>
  43 #include <comphelper/servicehelper.hxx>
  44
  45 using namespace ::com::sun::star;
  46 using namespace ::com::sun::star::accessibility;
  47
  48 //=====  internal  ============================================================
  49
  50 ScAccessiblePreviewTable::ScAccessiblePreviewTable( const ::com::sun::star::uno::Reference<
  51                                 ::com::sun::star::accessibility::XAccessible>& rxParent,
  52                             ScPreviewShell* pViewShell, sal_Int32 nIndex ) :
  53     ScAccessibleContextBase( rxParent, AccessibleRole::TABLE ),
  54     mpViewShell( pViewShell ),
  55     mnIndex( nIndex ),
  56     mpTableInfo( NULL )
  57 {
  58     if (mpViewShell)
  59         mpViewShell->AddAccessibilityObject(*this);
  60 }
  61
  62 ScAccessiblePreviewTable::~ScAccessiblePreviewTable()
  63 {
  64     if (!ScAccessibleContextBase::IsDefunc() && !rBHelper.bInDispose)
  65     {
  66         // increment refcount to prevent double call off dtor
  67         osl_atomic_increment( &m_refCount );
  68         dispose();
  69     }
  70 }
  71
  72 void SAL_CALL ScAccessiblePreviewTable::disposing()
  73 {
  74     SolarMutexGuard aGuard;
  75     if (mpViewShell)
  76     {
  77         mpViewShell->RemoveAccessibilityObject(*this);
  78         mpViewShell = NULL;
  79     }
  80
  81     if (mpTableInfo)
  82         DELETEZ (mpTableInfo);
  83
  84     ScAccessibleContextBase::disposing();
  85 }
  86
  87 //=====  SfxListener  =====================================================
  88
  89 void ScAccessiblePreviewTable::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
  90 {
  91     if (rHint.ISA( SfxSimpleHint ))
  92     {
  93         const SfxSimpleHint& rRef = (const SfxSimpleHint&)rHint;
  94         sal_uLong nId = rRef.GetId();
  95         if ( nId == SFX_HINT_DATACHANGED )
  96         {
  97             //  column / row layout may change with any document change,
  98             //  so it must be invalidated
  99             DELETEZ( mpTableInfo );
 100         }
 101         else if (rRef.GetId() == SC_HINT_ACC_VISAREACHANGED)
 102         {
 103             AccessibleEventObject aEvent;
 104             aEvent.EventId = AccessibleEventId::VISIBLE_DATA_CHANGED;
 105             aEvent.Source = uno::Reference< XAccessibleContext >(this);
 106             CommitChange(aEvent);
 107         }
 108     }
 109
 110     ScAccessibleContextBase::Notify(rBC, rHint);
 111 }
 112
 113 //=====  XInterface  =====================================================
 114
 115 uno::Any SAL_CALL ScAccessiblePreviewTable::queryInterface( uno::Type const & rType )
 116     throw (uno::RuntimeException, std::exception)
 117 {
 118     uno::Any aAny (ScAccessiblePreviewTableImpl::queryInterface(rType));
 119     return aAny.hasValue() ? aAny : ScAccessibleContextBase::queryInterface(rType);
 120 }
 121
 122 void SAL_CALL ScAccessiblePreviewTable::acquire()
 123     throw ()
 124 {
 125     ScAccessibleContextBase::acquire();
 126 }
 127
 128 void SAL_CALL ScAccessiblePreviewTable::release()
 129     throw ()
 130 {
 131     ScAccessibleContextBase::release();
 132 }
 133
 134 //=====  XAccessibleTable  ================================================
 135
 136 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleRowCount()
 137     throw (uno::RuntimeException, std::exception)
 138 {
 139     SolarMutexGuard aGuard;
 140     IsObjectValid();
 141
 142     FillTableInfo();
 143
 144     sal_Int32 nRet = 0;
 145     if ( mpTableInfo )
 146         nRet = mpTableInfo->GetRows();
 147     return nRet;
 148 }
 149
 150 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleColumnCount()
 151     throw (uno::RuntimeException, std::exception)
 152 {
 153     SolarMutexGuard aGuard;
 154     IsObjectValid();
 155
 156     FillTableInfo();
 157
 158     sal_Int32 nRet = 0;
 159     if ( mpTableInfo )
 160         nRet = mpTableInfo->GetCols();
 161     return nRet;
 162 }
 163
 164 OUString SAL_CALL ScAccessiblePreviewTable::getAccessibleRowDescription( sal_Int32 nRow )
 165     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 166 {
 167     SolarMutexGuard aGuard;
 168     FillTableInfo();
 169     if ( nRow < 0 || (mpTableInfo && nRow >= mpTableInfo->GetRows()) )
 170         throw lang::IndexOutOfBoundsException();
 171
 172     return OUString();
 173 }
 174
 175 OUString SAL_CALL ScAccessiblePreviewTable::getAccessibleColumnDescription( sal_Int32 nColumn )
 176     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 177 {
 178     SolarMutexGuard aGuard;
 179     FillTableInfo();
 180     if ( nColumn < 0 || (mpTableInfo && nColumn >= mpTableInfo->GetCols()) )
 181         throw lang::IndexOutOfBoundsException();
 182
 183     return OUString();
 184 }
 185
 186 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn )
 187     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 188 {
 189     SolarMutexGuard aGuard;
 190     IsObjectValid();
 191
 192     FillTableInfo();
 193
 194     sal_Int32 nRows = 1;
 195     if ( mpViewShell && mpTableInfo && nColumn >= 0 && nRow >= 0 &&
 196             nColumn < mpTableInfo->GetCols() && nRow < mpTableInfo->GetRows() )
 197     {
 198         const ScPreviewColRowInfo& rColInfo = mpTableInfo->GetColInfo()[nColumn];
 199         const ScPreviewColRowInfo& rRowInfo = mpTableInfo->GetRowInfo()[nRow];
 200
 201         if ( rColInfo.bIsHeader || rRowInfo.bIsHeader )
 202         {
 203             //  header cells only span a single cell
 204         }
 205         else
 206         {
 207             ScDocument* pDoc = mpViewShell->GetDocument();
 208             const ScMergeAttr* pItem = (const ScMergeAttr*)pDoc->GetAttr(
 209                 static_cast<SCCOL>(rColInfo.nDocIndex), static_cast<SCROW>(rRowInfo.nDocIndex), mpTableInfo->GetTab(), ATTR_MERGE );
 210             if ( pItem && pItem->GetRowMerge() > 0 )
 211                 nRows = pItem->GetRowMerge();
 212         }
 213     }
 214     else
 215         throw lang::IndexOutOfBoundsException();
 216
 217     return nRows;
 218 }
 219
 220 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn )
 221     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 222 {
 223     SolarMutexGuard aGuard;
 224     IsObjectValid();
 225
 226     FillTableInfo();
 227
 228     sal_Int32 nColumns = 1;
 229     if ( mpViewShell && mpTableInfo && nColumn >= 0 && nRow >= 0 &&
 230             nColumn < mpTableInfo->GetCols() && nRow < mpTableInfo->GetRows() )
 231     {
 232         const ScPreviewColRowInfo& rColInfo = mpTableInfo->GetColInfo()[nColumn];
 233         const ScPreviewColRowInfo& rRowInfo = mpTableInfo->GetRowInfo()[nRow];
 234
 235         if ( rColInfo.bIsHeader || rRowInfo.bIsHeader )
 236         {
 237             //  header cells only span a single cell
 238         }
 239         else
 240         {
 241             ScDocument* pDoc = mpViewShell->GetDocument();
 242             const ScMergeAttr* pItem = (const ScMergeAttr*)pDoc->GetAttr(
 243                 static_cast<SCCOL>(rColInfo.nDocIndex), static_cast<SCROW>(rRowInfo.nDocIndex), mpTableInfo->GetTab(), ATTR_MERGE );
 244             if ( pItem && pItem->GetColMerge() > 0 )
 245                 nColumns = pItem->GetColMerge();
 246         }
 247     }
 248     else
 249         throw lang::IndexOutOfBoundsException();
 250
 251     return nColumns;
 252 }
 253
 254 uno::Reference< XAccessibleTable > SAL_CALL ScAccessiblePreviewTable::getAccessibleRowHeaders() throw (uno::RuntimeException, std::exception)
 255 {
 256     //! missing
 257     return NULL;
 258 }
 259
 260 uno::Reference< XAccessibleTable > SAL_CALL ScAccessiblePreviewTable::getAccessibleColumnHeaders() throw (uno::RuntimeException, std::exception)
 261 {
 262     //! missing
 263     return NULL;
 264 }
 265
 266 uno::Sequence< sal_Int32 > SAL_CALL ScAccessiblePreviewTable::getSelectedAccessibleRows() throw (uno::RuntimeException, std::exception)
 267 {
 268     //  in the page preview, there is no selection
 269     return uno::Sequence<sal_Int32>(0);
 270 }
 271
 272 uno::Sequence< sal_Int32 > SAL_CALL ScAccessiblePreviewTable::getSelectedAccessibleColumns() throw (uno::RuntimeException, std::exception)
 273 {
 274     //  in the page preview, there is no selection
 275     return uno::Sequence<sal_Int32>(0);
 276 }
 277
 278 sal_Bool SAL_CALL ScAccessiblePreviewTable::isAccessibleRowSelected( sal_Int32 nRow )
 279     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 280 {
 281     //  in the page preview, there is no selection
 282
 283     SolarMutexGuard aGuard;
 284     FillTableInfo();
 285     if ( nRow < 0 || (mpTableInfo && nRow >= mpTableInfo->GetRows()) )
 286         throw lang::IndexOutOfBoundsException();
 287
 288     return false;
 289 }
 290
 291 sal_Bool SAL_CALL ScAccessiblePreviewTable::isAccessibleColumnSelected( sal_Int32 nColumn )
 292     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 293 {
 294     //  in the page preview, there is no selection
 295
 296     SolarMutexGuard aGuard;
 297     FillTableInfo();
 298     if ( nColumn < 0 || (mpTableInfo && nColumn >= mpTableInfo->GetCols()) )
 299         throw lang::IndexOutOfBoundsException();
 300
 301     return false;
 302 }
 303
 304 uno::Reference< XAccessible > SAL_CALL ScAccessiblePreviewTable::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn )
 305     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 306 {
 307     SolarMutexGuard aGuard;
 308     IsObjectValid();
 309
 310     FillTableInfo();
 311
 312     uno::Reference<XAccessible> xRet;
 313     if ( mpTableInfo && nColumn >= 0 && nRow >= 0 && nColumn < mpTableInfo->GetCols() && nRow < mpTableInfo->GetRows() )
 314     {
 315         //  index iterates horizontally
 316         long nNewIndex = nRow * mpTableInfo->GetCols() + nColumn;
 317
 318         const ScPreviewColRowInfo& rColInfo = mpTableInfo->GetColInfo()[nColumn];
 319         const ScPreviewColRowInfo& rRowInfo = mpTableInfo->GetRowInfo()[nRow];
 320
 321         ScAddress aCellPos( static_cast<SCCOL>(rColInfo.nDocIndex), static_cast<SCROW>(rRowInfo.nDocIndex), mpTableInfo->GetTab() );
 322         if ( rColInfo.bIsHeader || rRowInfo.bIsHeader )
 323         {
 324             ScAccessiblePreviewHeaderCell* pHeaderCell = new ScAccessiblePreviewHeaderCell( this, mpViewShell, aCellPos,
 325                                         rRowInfo.bIsHeader, rColInfo.bIsHeader, nNewIndex );
 326             xRet = pHeaderCell;
 327             pHeaderCell->Init();
 328         }
 329         else
 330         {
 331             ScAccessiblePreviewCell* pCell = new ScAccessiblePreviewCell( this, mpViewShell, aCellPos, nNewIndex );
 332             xRet = pCell;
 333             pCell->Init();
 334         }
 335     }
 336
 337     if ( !xRet.is() )
 338         throw lang::IndexOutOfBoundsException();
 339
 340     return xRet;
 341 }
 342
 343 uno::Reference< XAccessible > SAL_CALL ScAccessiblePreviewTable::getAccessibleCaption() throw (uno::RuntimeException, std::exception)
 344 {
 345     //! missing
 346     return NULL;
 347 }
 348
 349 uno::Reference< XAccessible > SAL_CALL ScAccessiblePreviewTable::getAccessibleSummary() throw (uno::RuntimeException, std::exception)
 350 {
 351     //! missing
 352     return NULL;
 353 }
 354
 355 sal_Bool SAL_CALL ScAccessiblePreviewTable::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn )
 356     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 357 {
 358     //  in the page preview, there is no selection
 359     SolarMutexGuard aGuard;
 360     IsObjectValid();
 361
 362     FillTableInfo();
 363
 364     if ( mpTableInfo && nColumn >= 0 && nRow >= 0 && nColumn < mpTableInfo->GetCols() && nRow < mpTableInfo->GetRows() )
 365     {
 366         //  index iterates horizontally
 367     }
 368     else
 369         throw lang::IndexOutOfBoundsException();
 370
 371     return false;
 372 }
 373
 374 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn )
 375     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 376 {
 377     SolarMutexGuard aGuard;
 378     IsObjectValid();
 379
 380     FillTableInfo();
 381
 382     sal_Int32 nRet = 0;
 383     if ( mpTableInfo && nColumn >= 0 && nRow >= 0 && nColumn < mpTableInfo->GetCols() && nRow < mpTableInfo->GetRows() )
 384     {
 385         //  index iterates horizontally
 386         nRet = nRow * mpTableInfo->GetCols() + nColumn;
 387     }
 388     else
 389         throw lang::IndexOutOfBoundsException();
 390
 391     return nRet;
 392 }
 393
 394 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleRow( sal_Int32 nChildIndex )
 395     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 396 {
 397     SolarMutexGuard aGuard;
 398     IsObjectValid();
 399
 400     FillTableInfo();
 401
 402     sal_Int32 nRow = 0;
 403     if ( mpTableInfo && nChildIndex >= 0 && nChildIndex < static_cast<sal_Int32>(mpTableInfo->GetRows()) * mpTableInfo->GetCols() )
 404     {
 405         nRow = nChildIndex / mpTableInfo->GetCols();
 406     }
 407     else
 408         throw lang::IndexOutOfBoundsException();
 409
 410     return nRow;
 411 }
 412
 413 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleColumn( sal_Int32 nChildIndex )
 414     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 415 {
 416     SolarMutexGuard aGuard;
 417     IsObjectValid();
 418
 419     FillTableInfo();
 420
 421     sal_Int32 nCol = 0;
 422     if ( mpTableInfo && nChildIndex >= 0 && nChildIndex < static_cast<sal_Int32>(mpTableInfo->GetRows()) * mpTableInfo->GetCols() )
 423     {
 424         nCol = nChildIndex % static_cast<sal_Int32>(mpTableInfo->GetCols());
 425     }
 426     else
 427         throw lang::IndexOutOfBoundsException();
 428
 429     return nCol;
 430 }
 431
 432 //=====  XAccessibleComponent  ============================================
 433
 434 uno::Reference< XAccessible > SAL_CALL ScAccessiblePreviewTable::getAccessibleAtPoint( const awt::Point& aPoint )
 435     throw (uno::RuntimeException, std::exception)
 436 {
 437     uno::Reference<XAccessible> xRet;
 438     if (containsPoint(aPoint))
 439     {
 440         SolarMutexGuard aGuard;
 441         IsObjectValid();
 442
 443         FillTableInfo();
 444
 445         if ( mpTableInfo )
 446         {
 447             SCCOL nCols = mpTableInfo->GetCols();
 448             SCROW nRows = mpTableInfo->GetRows();
 449             const ScPreviewColRowInfo* pColInfo = mpTableInfo->GetColInfo();
 450             const ScPreviewColRowInfo* pRowInfo = mpTableInfo->GetRowInfo();
 451
 452             Rectangle aScreenRect(GetBoundingBox());
 453
 454             awt::Point aMovedPoint = aPoint;
 455             aMovedPoint.X += aScreenRect.Left();
 456             aMovedPoint.Y += aScreenRect.Top();
 457
 458             if ( nCols > 0 && nRows > 0 && aMovedPoint.X >= pColInfo[0].nPixelStart && aMovedPoint.Y >= pRowInfo[0].nPixelStart )
 459             {
 460                 SCCOL nColIndex = 0;
 461                 while ( nColIndex < nCols && aMovedPoint.X > pColInfo[nColIndex].nPixelEnd )
 462                     ++nColIndex;
 463                 SCROW nRowIndex = 0;
 464                 while ( nRowIndex < nRows && aMovedPoint.Y > pRowInfo[nRowIndex].nPixelEnd )
 465                     ++nRowIndex;
 466                 if ( nColIndex < nCols && nRowIndex < nRows )
 467                 {
 468                     try
 469                     {
 470                         xRet = getAccessibleCellAt( nRowIndex, nColIndex );
 471                     }
 472                     catch (uno::Exception&)
 473                     {
 474                     }
 475                 }
 476             }
 477         }
 478     }
 479
 480     return xRet;
 481 }
 482
 483 void SAL_CALL ScAccessiblePreviewTable::grabFocus() throw (uno::RuntimeException, std::exception)
 484 {
 485      SolarMutexGuard aGuard;
 486     IsObjectValid();
 487     if (getAccessibleParent().is())
 488     {
 489         uno::Reference<XAccessibleComponent> xAccessibleComponent(getAccessibleParent()->getAccessibleContext(), uno::UNO_QUERY);
 490         if (xAccessibleComponent.is())
 491             xAccessibleComponent->grabFocus();
 492     }
 493 }
 494
 495 //=====  XAccessibleContext  ==============================================
 496
 497 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleChildCount()
 498     throw (uno::RuntimeException, std::exception)
 499 {
 500     SolarMutexGuard aGuard;
 501     IsObjectValid();
 502
 503     FillTableInfo();
 504
 505     long nRet = 0;
 506     if ( mpTableInfo )
 507         nRet = static_cast<sal_Int32>(mpTableInfo->GetCols()) * mpTableInfo->GetRows();
 508     return nRet;
 509 }
 510
 511 uno::Reference< XAccessible > SAL_CALL ScAccessiblePreviewTable::getAccessibleChild( sal_Int32 nIndex )
 512     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 513 {
 514     SolarMutexGuard aGuard;
 515     IsObjectValid();
 516
 517     FillTableInfo();
 518
 519     uno::Reference<XAccessible> xRet;
 520     if ( mpTableInfo )
 521     {
 522         long nColumns = mpTableInfo->GetCols();
 523         if ( nColumns > 0 )
 524         {
 525             // nCol, nRow are within the visible table, not the document
 526             long nCol = nIndex % nColumns;
 527             long nRow = nIndex / nColumns;
 528
 529             xRet = getAccessibleCellAt( nRow, nCol );
 530         }
 531     }
 532
 533     if ( !xRet.is() )
 534         throw lang::IndexOutOfBoundsException();
 535
 536     return xRet;
 537 }
 538
 539 sal_Int32 SAL_CALL ScAccessiblePreviewTable::getAccessibleIndexInParent() throw (uno::RuntimeException, std::exception)
 540 {
 541     return mnIndex;
 542 }
 543
 544 uno::Reference< XAccessibleStateSet > SAL_CALL ScAccessiblePreviewTable::getAccessibleStateSet()
 545                                 throw (uno::RuntimeException, std::exception)
 546 {
 547     SolarMutexGuard aGuard;
 548     uno::Reference<XAccessibleStateSet> xParentStates;
 549     if (getAccessibleParent().is())
 550     {
 551         uno::Reference<XAccessibleContext> xParentContext = getAccessibleParent()->getAccessibleContext();
 552         xParentStates = xParentContext->getAccessibleStateSet();
 553     }
 554     utl::AccessibleStateSetHelper* pStateSet = new utl::AccessibleStateSetHelper();
 555     if (IsDefunc(xParentStates))
 556         pStateSet->AddState(AccessibleStateType::DEFUNC);
 557     else
 558     {
 559         pStateSet->AddState(AccessibleStateType::MANAGES_DESCENDANTS);
 560         pStateSet->AddState(AccessibleStateType::ENABLED);
 561         pStateSet->AddState(AccessibleStateType::OPAQUE);
 562         if (isShowing())
 563             pStateSet->AddState(AccessibleStateType::SHOWING);
 564         if (isVisible())
 565             pStateSet->AddState(AccessibleStateType::VISIBLE);
 566     }
 567     return pStateSet;
 568 }
 569
 570 //=====  XServiceInfo  ====================================================
 571
 572 OUString SAL_CALL ScAccessiblePreviewTable::getImplementationName() throw(uno::RuntimeException, std::exception)
 573 {
 574     return OUString("ScAccessiblePreviewTable");
 575 }
 576
 577 uno::Sequence<OUString> SAL_CALL ScAccessiblePreviewTable::getSupportedServiceNames()
 578                                                     throw(uno::RuntimeException, std::exception)
 579 {
 580     uno::Sequence< OUString > aSequence = ScAccessibleContextBase::getSupportedServiceNames();
 581     sal_Int32 nOldSize(aSequence.getLength());
 582     aSequence.realloc(nOldSize + 1);
 583
 584     aSequence[nOldSize] = "com.sun.star.table.AccessibleTableView";
 585
 586     return aSequence;
 587 }
 588
 589 //=====  XTypeProvider  ===================================================
 590
 591 uno::Sequence< uno::Type > SAL_CALL ScAccessiblePreviewTable::getTypes()
 592         throw (uno::RuntimeException, std::exception)
 593 {
 594     return comphelper::concatSequences(ScAccessiblePreviewTableImpl::getTypes(), ScAccessibleContextBase::getTypes());
 595 }
 596
 597 uno::Sequence<sal_Int8> SAL_CALL ScAccessiblePreviewTable::getImplementationId()
 598                                                     throw(uno::RuntimeException, std::exception)
 599 {
 600     return css::uno::Sequence<sal_Int8>();
 601 }
 602
 603 //====  internal  =========================================================
 604
 605 OUString SAL_CALL ScAccessiblePreviewTable::createAccessibleDescription(void)
 606                     throw (uno::RuntimeException)
 607 {
 608     OUString sDesc(ScResId(STR_ACC_TABLE_DESCR));
 609     return sDesc;
 610 }
 611
 612 OUString SAL_CALL ScAccessiblePreviewTable::createAccessibleName()
 613     throw (uno::RuntimeException, std::exception)
 614 {
 615     OUString sName(SC_RESSTR(STR_ACC_TABLE_NAME));
 616
 617     if (mpViewShell && mpViewShell->GetDocument())
 618     {
 619         FillTableInfo();
 620
 621         if ( mpTableInfo )
 622         {
 623             OUString sCoreName;
 624             if (mpViewShell->GetDocument()->GetName( mpTableInfo->GetTab(), sCoreName ))
 625                 sName = sName.replaceFirst("%1", sCoreName);
 626         }
 627     }
 628
 629     return sName;
 630 }
 631
 632 Rectangle ScAccessiblePreviewTable::GetBoundingBoxOnScreen() const throw (uno::RuntimeException, std::exception)
 633 {
 634     Rectangle aCellRect(GetBoundingBox());
 635     if (mpViewShell)
 636     {
 637         Window* pWindow = mpViewShell->GetWindow();
 638         if (pWindow)
 639         {
 640             Rectangle aRect = pWindow->GetWindowExtentsRelative(NULL);
 641             aCellRect.setX(aCellRect.getX() + aRect.getX());
 642             aCellRect.setY(aCellRect.getY() + aRect.getY());
 643         }
 644     }
 645     return aCellRect;
 646 }
 647
 648 Rectangle ScAccessiblePreviewTable::GetBoundingBox() const
 649     throw (uno::RuntimeException, std::exception)
 650 {
 651     FillTableInfo();
 652
 653     Rectangle aRect;
 654     if ( mpTableInfo )
 655     {
 656         SCCOL nColumns = mpTableInfo->GetCols();
 657         SCROW nRows = mpTableInfo->GetRows();
 658         if ( nColumns > 0 && nRows > 0 )
 659         {
 660             const ScPreviewColRowInfo* pColInfo = mpTableInfo->GetColInfo();
 661             const ScPreviewColRowInfo* pRowInfo = mpTableInfo->GetRowInfo();
 662
 663             aRect = Rectangle( pColInfo[0].nPixelStart,
 664                                pRowInfo[0].nPixelStart,
 665                                pColInfo[nColumns-1].nPixelEnd,
 666                                pRowInfo[nRows-1].nPixelEnd );
 667         }
 668     }
 669     return aRect;
 670 }
 671
 672 bool ScAccessiblePreviewTable::IsDefunc( const uno::Reference<XAccessibleStateSet>& rxParentStates )
 673 {
 674     return ScAccessibleContextBase::IsDefunc() || (mpViewShell == NULL) || !getAccessibleParent().is() ||
 675         (rxParentStates.is() && rxParentStates->contains(AccessibleStateType::DEFUNC));
 676 }
 677
 678 void ScAccessiblePreviewTable::FillTableInfo() const
 679 {
 680     if ( mpViewShell && !mpTableInfo )
 681     {
 682         Size aOutputSize;
 683         Window* pWindow = mpViewShell->GetWindow();
 684         if ( pWindow )
 685             aOutputSize = pWindow->GetOutputSizePixel();
 686         Point aPoint;
 687         Rectangle aVisRect( aPoint, aOutputSize );
 688
 689         mpTableInfo = new ScPreviewTableInfo;
 690         mpViewShell->GetLocationData().GetTableInfo( aVisRect, *mpTableInfo );
 691     }
 692 }
 693
 694 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */