sfx2/source/control/thumbnailviewacc.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 "thumbnailviewacc.hxx"
  21
  22 #include <comphelper/servicehelper.hxx>
  23 #include <sfx2/thumbnailview.hxx>
  24 #include <sfx2/thumbnailviewitem.hxx>
  25 #include <unotools/accessiblestatesethelper.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/settings.hxx>
  28 #include <sal/log.hxx>
  29 #include <tools/debug.hxx>
  30
  31 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  32 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  33 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  34 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  35
  36 using namespace ::com::sun::star;
  37
  38 ThumbnailViewAcc::ThumbnailViewAcc( ThumbnailView* pParent ) :
  39     ValueSetAccComponentBase (m_aMutex),
  40     mpParent( pParent ),
  41     mbIsFocused(false)
  42 {
  43 }
  44
  45 ThumbnailViewAcc::~ThumbnailViewAcc()
  46 {
  47 }
  48
  49 void ThumbnailViewAcc::FireAccessibleEvent( short nEventId, const uno::Any& rOldValue, const uno::Any& rNewValue )
  50 {
  51     if( !nEventId )
  52         return;
  53
  54     ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > > aTmpListeners( mxEventListeners );
  55     accessibility::AccessibleEventObject aEvtObject;
  56
  57     aEvtObject.EventId = nEventId;
  58     aEvtObject.Source = static_cast<uno::XWeak*>(this);
  59     aEvtObject.NewValue = rNewValue;
  60     aEvtObject.OldValue = rOldValue;
  61
  62     for (auto const& tmpListener : aTmpListeners)
  63     {
  64         try
  65         {
  66             tmpListener->notifyEvent( aEvtObject );
  67         }
  68         catch(const uno::Exception&)
  69         {
  70         }
  71     }
  72 }
  73
  74 namespace
  75 {
  76     class theValueSetAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theValueSetAccUnoTunnelId > {};
  77 }
  78
  79 const uno::Sequence< sal_Int8 >& ThumbnailViewAcc::getUnoTunnelId()
  80 {
  81     return theValueSetAccUnoTunnelId::get().getSeq();
  82 }
  83
  84 ThumbnailViewAcc* ThumbnailViewAcc::getImplementation( const uno::Reference< uno::XInterface >& rxData )
  85     throw()
  86 {
  87     try
  88     {
  89         return comphelper::getUnoTunnelImplementation<ThumbnailViewAcc>(rxData);
  90     }
  91     catch(const css::uno::Exception&)
  92     {
  93         return nullptr;
  94     }
  95 }
  96
  97 void ThumbnailViewAcc::GetFocus()
  98 {
  99     mbIsFocused = true;
 100
 101     // Broadcast the state change.
 102     css::uno::Any aOldState, aNewState;
 103     aNewState <<= css::accessibility::AccessibleStateType::FOCUSED;
 104     FireAccessibleEvent(
 105         css::accessibility::AccessibleEventId::STATE_CHANGED,
 106         aOldState, aNewState);
 107 }
 108
 109 void ThumbnailViewAcc::LoseFocus()
 110 {
 111     mbIsFocused = false;
 112
 113     // Broadcast the state change.
 114     css::uno::Any aOldState, aNewState;
 115     aOldState <<= css::accessibility::AccessibleStateType::FOCUSED;
 116     FireAccessibleEvent(
 117         css::accessibility::AccessibleEventId::STATE_CHANGED,
 118         aOldState, aNewState);
 119 }
 120
 121 uno::Reference< accessibility::XAccessibleContext > SAL_CALL ThumbnailViewAcc::getAccessibleContext()
 122 {
 123     ThrowIfDisposed();
 124     return this;
 125 }
 126
 127 sal_Int32 SAL_CALL ThumbnailViewAcc::getAccessibleChildCount()
 128 {
 129     const SolarMutexGuard aSolarGuard;
 130     ThrowIfDisposed();
 131
 132     sal_Int32 nCount = mpParent->ImplGetVisibleItemCount();
 133     return nCount;
 134 }
 135
 136 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getAccessibleChild( sal_Int32 i )
 137 {
 138     ThrowIfDisposed();
 139     const SolarMutexGuard aSolarGuard;
 140     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(i));
 141
 142     if( !pItem )
 143         throw lang::IndexOutOfBoundsException();
 144
 145     uno::Reference< accessibility::XAccessible >  xRet = pItem->GetAccessible( /*bIsTransientChildrenDisabled*/false );
 146     return xRet;
 147 }
 148
 149 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getAccessibleParent()
 150 {
 151     ThrowIfDisposed();
 152     const SolarMutexGuard aSolarGuard;
 153     vcl::Window*                                         pParent = mpParent->GetParent();
 154     uno::Reference< accessibility::XAccessible >    xRet;
 155
 156     if( pParent )
 157         xRet = pParent->GetAccessible();
 158
 159     return xRet;
 160 }
 161
 162 sal_Int32 SAL_CALL ThumbnailViewAcc::getAccessibleIndexInParent()
 163 {
 164     ThrowIfDisposed();
 165     const SolarMutexGuard aSolarGuard;
 166     vcl::Window*                 pParent = mpParent->GetParent();
 167     sal_Int32               nRet = 0;
 168
 169     if( pParent )
 170     {
 171         bool bFound = false;
 172
 173         for( sal_uInt16 i = 0, nCount = pParent->GetChildCount(); ( i < nCount ) && !bFound; i++ )
 174         {
 175             if( pParent->GetChild( i ) == mpParent )
 176             {
 177                 nRet = i;
 178                 bFound = true;
 179             }
 180         }
 181     }
 182
 183     return nRet;
 184 }
 185
 186 sal_Int16 SAL_CALL ThumbnailViewAcc::getAccessibleRole()
 187 {
 188     ThrowIfDisposed();
 189     // #i73746# As the Java Access Bridge (v 2.0.1) uses "managesDescendants"
 190     // always if the role is LIST, we need a different role in this case
 191     return accessibility::AccessibleRole::LIST;
 192 }
 193
 194 OUString SAL_CALL ThumbnailViewAcc::getAccessibleDescription()
 195 {
 196     ThrowIfDisposed();
 197     return "ThumbnailView";
 198 }
 199
 200 OUString SAL_CALL ThumbnailViewAcc::getAccessibleName()
 201 {
 202     ThrowIfDisposed();
 203     const SolarMutexGuard aSolarGuard;
 204     OUString aRet;
 205
 206     if ( mpParent )
 207     {
 208         aRet = mpParent->GetAccessibleName();
 209         if (aRet.isEmpty())
 210         {
 211             vcl::Window* pLabel = mpParent->GetAccessibleRelationLabeledBy();
 212             if (pLabel && pLabel != mpParent)
 213                 aRet = OutputDevice::GetNonMnemonicString( pLabel->GetText() );
 214         }
 215     }
 216
 217     return aRet;
 218 }
 219
 220 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL ThumbnailViewAcc::getAccessibleRelationSet()
 221 {
 222     ThrowIfDisposed();
 223     return uno::Reference< accessibility::XAccessibleRelationSet >();
 224 }
 225
 226 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL ThumbnailViewAcc::getAccessibleStateSet()
 227 {
 228     ThrowIfDisposed();
 229     ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper();
 230
 231     // Set some states.
 232     pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
 233     pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
 234     pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
 235     pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
 236     pStateSet->AddState (accessibility::AccessibleStateType::MANAGES_DESCENDANTS);
 237     pStateSet->AddState (accessibility::AccessibleStateType::FOCUSABLE);
 238     if (mbIsFocused)
 239         pStateSet->AddState (accessibility::AccessibleStateType::FOCUSED);
 240
 241     return pStateSet;
 242 }
 243
 244 lang::Locale SAL_CALL ThumbnailViewAcc::getLocale()
 245 {
 246     ThrowIfDisposed();
 247     const SolarMutexGuard aSolarGuard;
 248     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
 249     lang::Locale                                    aRet( "", "", "" );
 250
 251     if( xParent.is() )
 252     {
 253         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 254
 255         if( xParentContext.is() )
 256             aRet = xParentContext->getLocale ();
 257     }
 258
 259     return aRet;
 260 }
 261
 262 void SAL_CALL ThumbnailViewAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 263 {
 264     ThrowIfDisposed();
 265     ::osl::MutexGuard aGuard (m_aMutex);
 266
 267     if( !rxListener.is() )
 268         return;
 269
 270     bool bFound = false;
 271
 272     for (auto const& eventListener : mxEventListeners)
 273     {
 274         if( eventListener == rxListener )
 275         {
 276             bFound = true;
 277             break;
 278         }
 279     }
 280
 281     if (!bFound)
 282         mxEventListeners.push_back( rxListener );
 283 }
 284
 285 void SAL_CALL ThumbnailViewAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 286 {
 287     ThrowIfDisposed();
 288     ::osl::MutexGuard aGuard (m_aMutex);
 289
 290     if( rxListener.is() )
 291     {
 292         std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter =
 293             std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
 294
 295         if (aIter != mxEventListeners.end())
 296             mxEventListeners.erase( aIter );
 297     }
 298 }
 299
 300 sal_Bool SAL_CALL ThumbnailViewAcc::containsPoint( const awt::Point& aPoint )
 301 {
 302     ThrowIfDisposed();
 303     const awt::Rectangle    aRect( getBounds() );
 304     const Point             aSize( aRect.Width, aRect.Height );
 305     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 306
 307     return tools::Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 308 }
 309
 310 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getAccessibleAtPoint( const awt::Point& aPoint )
 311 {
 312     ThrowIfDisposed();
 313     const SolarMutexGuard aSolarGuard;
 314     const sal_uInt16                                    nItemId = mpParent->GetItemId( Point( aPoint.X, aPoint.Y ) );
 315     uno::Reference< accessibility::XAccessible >    xRet;
 316
 317     if ( nItemId )
 318     {
 319         const size_t nItemPos = mpParent->GetItemPos( nItemId );
 320
 321         if( THUMBNAILVIEW_ITEM_NONEITEM != nItemPos )
 322         {
 323             ThumbnailViewItem *const pItem = mpParent->mFilteredItemList[nItemPos];
 324             xRet = pItem->GetAccessible( /*bIsTransientChildrenDisabled*/false );
 325         }
 326     }
 327
 328     return xRet;
 329 }
 330
 331 awt::Rectangle SAL_CALL ThumbnailViewAcc::getBounds()
 332 {
 333     ThrowIfDisposed();
 334     const SolarMutexGuard aSolarGuard;
 335     const Point         aOutPos( mpParent->GetPosPixel() );
 336     const Size          aOutSize( mpParent->GetOutputSizePixel() );
 337     awt::Rectangle      aRet;
 338
 339     aRet.X = aOutPos.X();
 340     aRet.Y = aOutPos.Y();
 341     aRet.Width = aOutSize.Width();
 342     aRet.Height = aOutSize.Height();
 343
 344     return aRet;
 345 }
 346
 347 awt::Point SAL_CALL ThumbnailViewAcc::getLocation()
 348 {
 349     ThrowIfDisposed();
 350     const awt::Rectangle    aRect( getBounds() );
 351     awt::Point              aRet;
 352
 353     aRet.X = aRect.X;
 354     aRet.Y = aRect.Y;
 355
 356     return aRet;
 357 }
 358
 359 awt::Point SAL_CALL ThumbnailViewAcc::getLocationOnScreen()
 360 {
 361     ThrowIfDisposed();
 362     const SolarMutexGuard aSolarGuard;
 363     const Point         aScreenPos( mpParent->OutputToAbsoluteScreenPixel( Point() ) );
 364     awt::Point          aRet;
 365
 366     aRet.X = aScreenPos.X();
 367     aRet.Y = aScreenPos.Y();
 368
 369     return aRet;
 370 }
 371
 372 awt::Size SAL_CALL ThumbnailViewAcc::getSize()
 373 {
 374     ThrowIfDisposed();
 375     const awt::Rectangle    aRect( getBounds() );
 376     awt::Size               aRet;
 377
 378     aRet.Width = aRect.Width;
 379     aRet.Height = aRect.Height;
 380
 381     return aRet;
 382 }
 383
 384 void SAL_CALL ThumbnailViewAcc::grabFocus()
 385 {
 386     ThrowIfDisposed();
 387     const SolarMutexGuard aSolarGuard;
 388     mpParent->GrabFocus();
 389 }
 390
 391 sal_Int32 SAL_CALL ThumbnailViewAcc::getForeground(  )
 392 {
 393     ThrowIfDisposed();
 394     Color nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor();
 395     return static_cast<sal_Int32>(nColor);
 396 }
 397
 398 sal_Int32 SAL_CALL ThumbnailViewAcc::getBackground(  )
 399 {
 400     ThrowIfDisposed();
 401     Color nColor = Application::GetSettings().GetStyleSettings().GetWindowColor();
 402     return static_cast<sal_Int32>(nColor);
 403 }
 404
 405 void SAL_CALL ThumbnailViewAcc::selectAccessibleChild( sal_Int32 nChildIndex )
 406 {
 407     ThrowIfDisposed();
 408     const SolarMutexGuard aSolarGuard;
 409     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 410
 411     if(pItem == nullptr)
 412         throw lang::IndexOutOfBoundsException();
 413
 414     mpParent->SelectItem( pItem->mnId );
 415 }
 416
 417 sal_Bool SAL_CALL ThumbnailViewAcc::isAccessibleChildSelected( sal_Int32 nChildIndex )
 418 {
 419     ThrowIfDisposed();
 420     const SolarMutexGuard aSolarGuard;
 421     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 422
 423     if (pItem == nullptr)
 424         throw lang::IndexOutOfBoundsException();
 425
 426     return mpParent->IsItemSelected( pItem->mnId );
 427 }
 428
 429 void SAL_CALL ThumbnailViewAcc::clearAccessibleSelection()
 430 {
 431     ThrowIfDisposed();
 432 }
 433
 434 void SAL_CALL ThumbnailViewAcc::selectAllAccessibleChildren()
 435 {
 436     ThrowIfDisposed();
 437     // unsupported due to single selection only
 438 }
 439
 440 sal_Int32 SAL_CALL ThumbnailViewAcc::getSelectedAccessibleChildCount()
 441 {
 442     ThrowIfDisposed();
 443     const SolarMutexGuard aSolarGuard;
 444     sal_Int32           nRet = 0;
 445
 446     for( sal_uInt16 i = 0, nCount = getItemCount(); i < nCount; i++ )
 447     {
 448         ThumbnailViewItem* pItem = getItem (i);
 449
 450         if( pItem && mpParent->IsItemSelected( pItem->mnId ) )
 451             ++nRet;
 452     }
 453
 454     return nRet;
 455 }
 456
 457 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 458 {
 459     ThrowIfDisposed();
 460     const SolarMutexGuard aSolarGuard;
 461     uno::Reference< accessibility::XAccessible >    xRet;
 462
 463     for( sal_uInt16 i = 0, nCount = getItemCount(), nSel = 0; ( i < nCount ) && !xRet.is(); i++ )
 464     {
 465         ThumbnailViewItem* pItem = getItem(i);
 466
 467         if( pItem && mpParent->IsItemSelected( pItem->mnId ) && ( nSelectedChildIndex == static_cast< sal_Int32 >( nSel++ ) ) )
 468             xRet = pItem->GetAccessible( /*bIsTransientChildrenDisabled*/false );
 469     }
 470
 471     return xRet;
 472 }
 473
 474 void SAL_CALL ThumbnailViewAcc::deselectAccessibleChild( sal_Int32 )
 475 {
 476     ThrowIfDisposed();
 477     const SolarMutexGuard aSolarGuard;
 478     // Because of the single selection we can reset the whole selection when
 479     // the specified child is currently selected.
 480 //FIXME TODO    if (isAccessibleChildSelected(nChildIndex))
 481 //FIXME TODO        ;
 482 }
 483
 484 sal_Int64 SAL_CALL ThumbnailViewAcc::getSomething( const uno::Sequence< sal_Int8 >& rId )
 485 {
 486     sal_Int64 nRet;
 487
 488     if( isUnoTunnelId<ThumbnailViewAcc>(rId) )
 489         nRet = reinterpret_cast< sal_Int64 >( this );
 490     else
 491         nRet = 0;
 492
 493     return nRet;
 494 }
 495
 496 void SAL_CALL ThumbnailViewAcc::disposing()
 497 {
 498     ::std::vector<uno::Reference<accessibility::XAccessibleEventListener> > aListenerListCopy;
 499
 500     {
 501         // Make a copy of the list and clear the original.
 502         const SolarMutexGuard aSolarGuard;
 503         ::osl::MutexGuard aGuard (m_aMutex);
 504         aListenerListCopy = mxEventListeners;
 505         mxEventListeners.clear();
 506
 507         // Reset the pointer to the parent.  It has to be the one who has
 508         // disposed us because he is dying.
 509         mpParent = nullptr;
 510     }
 511
 512     // Inform all listeners that this objects is disposing.
 513     lang::EventObject aEvent (static_cast<accessibility::XAccessible*>(this));
 514     for (auto const& listener : aListenerListCopy)
 515     {
 516         try
 517         {
 518             listener->disposing (aEvent);
 519         }
 520         catch(const uno::Exception&)
 521         {
 522             // Ignore exceptions.
 523         }
 524     }
 525 }
 526
 527 sal_uInt16 ThumbnailViewAcc::getItemCount() const
 528 {
 529     return mpParent->ImplGetVisibleItemCount();
 530 }
 531
 532 ThumbnailViewItem* ThumbnailViewAcc::getItem (sal_uInt16 nIndex) const
 533 {
 534     return mpParent->ImplGetVisibleItem (nIndex);
 535 }
 536
 537 void ThumbnailViewAcc::ThrowIfDisposed()
 538 {
 539     if (rBHelper.bDisposed || rBHelper.bInDispose)
 540     {
 541         SAL_WARN("sfx", "Calling disposed object. Throwing exception:");
 542         throw lang::DisposedException (
 543             "object has been already disposed",
 544             static_cast<uno::XWeak*>(this));
 545     }
 546     else
 547     {
 548         DBG_ASSERT (mpParent!=nullptr, "ValueSetAcc not disposed but mpParent == NULL");
 549     }
 550 }
 551
 552 SfxThumbnailViewAcc::SfxThumbnailViewAcc( SfxThumbnailView* pParent ) :
 553     ValueSetAccComponentBase (m_aMutex),
 554     mpParent( pParent )
 555 {
 556 }
 557
 558 SfxThumbnailViewAcc::~SfxThumbnailViewAcc()
 559 {
 560 }
 561
 562 namespace
 563 {
 564     class theSfxValueSetAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSfxValueSetAccUnoTunnelId > {};
 565 }
 566
 567 const uno::Sequence< sal_Int8 >& SfxThumbnailViewAcc::getUnoTunnelId()
 568 {
 569     return theSfxValueSetAccUnoTunnelId::get().getSeq();
 570 }
 571
 572 uno::Reference< accessibility::XAccessibleContext > SAL_CALL SfxThumbnailViewAcc::getAccessibleContext()
 573 {
 574     ThrowIfDisposed();
 575     return this;
 576 }
 577
 578 sal_Int32 SAL_CALL SfxThumbnailViewAcc::getAccessibleChildCount()
 579 {
 580     const SolarMutexGuard aSolarGuard;
 581     ThrowIfDisposed();
 582
 583     sal_Int32 nCount = mpParent->ImplGetVisibleItemCount();
 584     return nCount;
 585 }
 586
 587 uno::Reference< accessibility::XAccessible > SAL_CALL SfxThumbnailViewAcc::getAccessibleChild( sal_Int32 i )
 588 {
 589     ThrowIfDisposed();
 590     const SolarMutexGuard aSolarGuard;
 591     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(i));
 592
 593     if( !pItem )
 594         throw lang::IndexOutOfBoundsException();
 595
 596     uno::Reference< accessibility::XAccessible >  xRet = pItem->GetAccessible( /*bIsTransientChildrenDisabled*/false );
 597     return xRet;
 598 }
 599
 600 uno::Reference< accessibility::XAccessible > SAL_CALL SfxThumbnailViewAcc::getAccessibleParent()
 601 {
 602     ThrowIfDisposed();
 603     const SolarMutexGuard aSolarGuard;
 604     return mpParent->GetDrawingArea()->get_accessible_parent();
 605 }
 606
 607 sal_Int32 SAL_CALL SfxThumbnailViewAcc::getAccessibleIndexInParent()
 608 {
 609     ThrowIfDisposed();
 610     const SolarMutexGuard aSolarGuard;
 611
 612     // -1 for child not found/no parent (according to specification)
 613     sal_Int32 nRet = -1;
 614
 615     uno::Reference<accessibility::XAccessible> xParent(getAccessibleParent());
 616     if (!xParent)
 617         return nRet;
 618
 619     try
 620     {
 621         uno::Reference<accessibility::XAccessibleContext> xParentContext(xParent->getAccessibleContext());
 622
 623         //  iterate over parent's children and search for this object
 624         if ( xParentContext.is() )
 625         {
 626             sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
 627             for ( sal_Int32 nChild = 0; ( nChild < nChildCount ) && ( -1 == nRet ); ++nChild )
 628             {
 629                 uno::Reference<XAccessible> xChild(xParentContext->getAccessibleChild(nChild));
 630                 if ( xChild.get() == this )
 631                     nRet = nChild;
 632             }
 633         }
 634     }
 635     catch (const uno::Exception&)
 636     {
 637         OSL_FAIL( "OAccessibleContextHelper::getAccessibleIndexInParent: caught an exception!" );
 638     }
 639
 640     return nRet;
 641 }
 642
 643 sal_Int16 SAL_CALL SfxThumbnailViewAcc::getAccessibleRole()
 644 {
 645     ThrowIfDisposed();
 646     // #i73746# As the Java Access Bridge (v 2.0.1) uses "managesDescendants"
 647     // always if the role is LIST, we need a different role in this case
 648     return accessibility::AccessibleRole::LIST;
 649 }
 650
 651 OUString SAL_CALL SfxThumbnailViewAcc::getAccessibleDescription()
 652 {
 653     ThrowIfDisposed();
 654     return "ThumbnailView";
 655 }
 656
 657 OUString SAL_CALL SfxThumbnailViewAcc::getAccessibleName()
 658 {
 659     ThrowIfDisposed();
 660     const SolarMutexGuard aSolarGuard;
 661     OUString              aRet;
 662
 663     if (mpParent)
 664     {
 665         aRet = mpParent->GetAccessibleName();
 666     }
 667
 668     return aRet;
 669 }
 670
 671 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL SfxThumbnailViewAcc::getAccessibleRelationSet()
 672 {
 673     ThrowIfDisposed();
 674     return uno::Reference< accessibility::XAccessibleRelationSet >();
 675 }
 676
 677 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL SfxThumbnailViewAcc::getAccessibleStateSet()
 678 {
 679     ThrowIfDisposed();
 680     ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper();
 681
 682     // Set some states.
 683     pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
 684     pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
 685     pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
 686     pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
 687     pStateSet->AddState (accessibility::AccessibleStateType::MANAGES_DESCENDANTS);
 688     pStateSet->AddState (accessibility::AccessibleStateType::FOCUSABLE);
 689
 690     return pStateSet;
 691 }
 692
 693 lang::Locale SAL_CALL SfxThumbnailViewAcc::getLocale()
 694 {
 695     ThrowIfDisposed();
 696     const SolarMutexGuard aSolarGuard;
 697     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
 698     lang::Locale                                    aRet( "", "", "" );
 699
 700     if( xParent.is() )
 701     {
 702         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 703
 704         if( xParentContext.is() )
 705             aRet = xParentContext->getLocale ();
 706     }
 707
 708     return aRet;
 709 }
 710
 711 void SAL_CALL SfxThumbnailViewAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 712 {
 713     ThrowIfDisposed();
 714     ::osl::MutexGuard aGuard (m_aMutex);
 715
 716     if( !rxListener.is() )
 717         return;
 718
 719     bool bFound = false;
 720
 721     for (auto const& eventListener : mxEventListeners)
 722     {
 723         if( eventListener == rxListener )
 724         {
 725             bFound = true;
 726             break;
 727         }
 728     }
 729
 730     if (!bFound)
 731         mxEventListeners.push_back( rxListener );
 732 }
 733
 734 void SAL_CALL SfxThumbnailViewAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 735 {
 736     ThrowIfDisposed();
 737     ::osl::MutexGuard aGuard (m_aMutex);
 738
 739     if( rxListener.is() )
 740     {
 741         std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter =
 742             std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
 743
 744         if (aIter != mxEventListeners.end())
 745             mxEventListeners.erase( aIter );
 746     }
 747 }
 748
 749 sal_Bool SAL_CALL SfxThumbnailViewAcc::containsPoint( const awt::Point& aPoint )
 750 {
 751     ThrowIfDisposed();
 752     const awt::Rectangle    aRect( getBounds() );
 753     const Point             aSize( aRect.Width, aRect.Height );
 754     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 755
 756     return tools::Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 757 }
 758
 759 uno::Reference< accessibility::XAccessible > SAL_CALL SfxThumbnailViewAcc::getAccessibleAtPoint( const awt::Point& aPoint )
 760 {
 761     ThrowIfDisposed();
 762     const SolarMutexGuard aSolarGuard;
 763     const sal_uInt16                                    nItemId = mpParent->GetItemId( Point( aPoint.X, aPoint.Y ) );
 764     uno::Reference< accessibility::XAccessible >    xRet;
 765
 766     if ( nItemId )
 767     {
 768         const size_t nItemPos = mpParent->GetItemPos( nItemId );
 769
 770         if( THUMBNAILVIEW_ITEM_NONEITEM != nItemPos )
 771         {
 772             ThumbnailViewItem *const pItem = mpParent->mFilteredItemList[nItemPos];
 773             xRet = pItem->GetAccessible( /*bIsTransientChildrenDisabled*/false );
 774         }
 775     }
 776
 777     return xRet;
 778 }
 779
 780 awt::Rectangle SAL_CALL SfxThumbnailViewAcc::getBounds()
 781 {
 782     ThrowIfDisposed();
 783     const SolarMutexGuard aSolarGuard;
 784     const Point         aOutPos;
 785     const Size          aOutSize( mpParent->GetOutputSizePixel() );
 786     awt::Rectangle      aRet;
 787
 788     aRet.X = aOutPos.X();
 789     aRet.Y = aOutPos.Y();
 790     aRet.Width = aOutSize.Width();
 791     aRet.Height = aOutSize.Height();
 792
 793     return aRet;
 794 }
 795
 796 awt::Point SAL_CALL SfxThumbnailViewAcc::getLocation()
 797 {
 798     ThrowIfDisposed();
 799     const awt::Rectangle    aRect( getBounds() );
 800     awt::Point              aRet;
 801
 802     aRet.X = aRect.X;
 803     aRet.Y = aRect.Y;
 804
 805     return aRet;
 806 }
 807
 808 awt::Point SAL_CALL SfxThumbnailViewAcc::getLocationOnScreen()
 809 {
 810     ThrowIfDisposed();
 811     const SolarMutexGuard aSolarGuard;
 812     awt::Point aScreenLoc(0, 0);
 813
 814     uno::Reference<accessibility::XAccessible> xParent(getAccessibleParent());
 815     if (xParent)
 816     {
 817         uno::Reference<accessibility::XAccessibleContext> xParentContext(xParent->getAccessibleContext());
 818         uno::Reference<accessibility::XAccessibleComponent> xParentComponent(xParentContext, css::uno::UNO_QUERY);
 819         OSL_ENSURE( xParentComponent.is(), "SfxThumbnailViewAcc::getLocationOnScreen: no parent component!" );
 820         if ( xParentComponent.is() )
 821         {
 822             awt::Point aParentScreenLoc( xParentComponent->getLocationOnScreen() );
 823             awt::Point aOwnRelativeLoc( getLocation() );
 824             aScreenLoc.X = aParentScreenLoc.X + aOwnRelativeLoc.X;
 825             aScreenLoc.Y = aParentScreenLoc.Y + aOwnRelativeLoc.Y;
 826         }
 827     }
 828
 829     return aScreenLoc;
 830 }
 831
 832 awt::Size SAL_CALL SfxThumbnailViewAcc::getSize()
 833 {
 834     ThrowIfDisposed();
 835     const awt::Rectangle    aRect( getBounds() );
 836     awt::Size               aRet;
 837
 838     aRet.Width = aRect.Width;
 839     aRet.Height = aRect.Height;
 840
 841     return aRet;
 842 }
 843
 844 void SAL_CALL SfxThumbnailViewAcc::grabFocus()
 845 {
 846     ThrowIfDisposed();
 847     const SolarMutexGuard aSolarGuard;
 848     mpParent->GrabFocus();
 849 }
 850
 851 sal_Int32 SAL_CALL SfxThumbnailViewAcc::getForeground(  )
 852 {
 853     ThrowIfDisposed();
 854     Color nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor();
 855     return static_cast<sal_Int32>(nColor);
 856 }
 857
 858 sal_Int32 SAL_CALL SfxThumbnailViewAcc::getBackground(  )
 859 {
 860     ThrowIfDisposed();
 861     Color nColor = Application::GetSettings().GetStyleSettings().GetWindowColor();
 862     return static_cast<sal_Int32>(nColor);
 863 }
 864
 865 void SAL_CALL SfxThumbnailViewAcc::selectAccessibleChild( sal_Int32 nChildIndex )
 866 {
 867     ThrowIfDisposed();
 868     const SolarMutexGuard aSolarGuard;
 869     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 870
 871     if(pItem == nullptr)
 872         throw lang::IndexOutOfBoundsException();
 873
 874     mpParent->SelectItem( pItem->mnId );
 875 }
 876
 877 sal_Bool SAL_CALL SfxThumbnailViewAcc::isAccessibleChildSelected( sal_Int32 nChildIndex )
 878 {
 879     ThrowIfDisposed();
 880     const SolarMutexGuard aSolarGuard;
 881     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 882
 883     if (pItem == nullptr)
 884         throw lang::IndexOutOfBoundsException();
 885
 886     return mpParent->IsItemSelected( pItem->mnId );
 887 }
 888
 889 void SAL_CALL SfxThumbnailViewAcc::clearAccessibleSelection()
 890 {
 891     ThrowIfDisposed();
 892 }
 893
 894 void SAL_CALL SfxThumbnailViewAcc::selectAllAccessibleChildren()
 895 {
 896     ThrowIfDisposed();
 897     // unsupported due to single selection only
 898 }
 899
 900 sal_Int32 SAL_CALL SfxThumbnailViewAcc::getSelectedAccessibleChildCount()
 901 {
 902     ThrowIfDisposed();
 903     const SolarMutexGuard aSolarGuard;
 904     sal_Int32           nRet = 0;
 905
 906     for( sal_uInt16 i = 0, nCount = getItemCount(); i < nCount; i++ )
 907     {
 908         ThumbnailViewItem* pItem = getItem (i);
 909
 910         if( pItem && mpParent->IsItemSelected( pItem->mnId ) )
 911             ++nRet;
 912     }
 913
 914     return nRet;
 915 }
 916
 917 uno::Reference< accessibility::XAccessible > SAL_CALL SfxThumbnailViewAcc::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 918 {
 919     ThrowIfDisposed();
 920     const SolarMutexGuard aSolarGuard;
 921     uno::Reference< accessibility::XAccessible >    xRet;
 922
 923     for( sal_uInt16 i = 0, nCount = getItemCount(), nSel = 0; ( i < nCount ) && !xRet.is(); i++ )
 924     {
 925         ThumbnailViewItem* pItem = getItem(i);
 926
 927         if( pItem && mpParent->IsItemSelected( pItem->mnId ) && ( nSelectedChildIndex == static_cast< sal_Int32 >( nSel++ ) ) )
 928             xRet = pItem->GetAccessible( /*bIsTransientChildrenDisabled*/false );
 929     }
 930
 931     return xRet;
 932 }
 933
 934 void SAL_CALL SfxThumbnailViewAcc::deselectAccessibleChild( sal_Int32 )
 935 {
 936     ThrowIfDisposed();
 937     const SolarMutexGuard aSolarGuard;
 938     // Because of the single selection we can reset the whole selection when
 939     // the specified child is currently selected.
 940 //FIXME TODO    if (isAccessibleChildSelected(nChildIndex))
 941 //FIXME TODO        ;
 942 }
 943
 944 sal_Int64 SAL_CALL SfxThumbnailViewAcc::getSomething( const uno::Sequence< sal_Int8 >& rId )
 945 {
 946     sal_Int64 nRet;
 947
 948     if( isUnoTunnelId<SfxThumbnailViewAcc>(rId) )
 949         nRet = reinterpret_cast< sal_Int64 >( this );
 950     else
 951         nRet = 0;
 952
 953     return nRet;
 954 }
 955
 956 void SAL_CALL SfxThumbnailViewAcc::disposing()
 957 {
 958     ::std::vector<uno::Reference<accessibility::XAccessibleEventListener> > aListenerListCopy;
 959
 960     {
 961         // Make a copy of the list and clear the original.
 962         const SolarMutexGuard aSolarGuard;
 963         ::osl::MutexGuard aGuard (m_aMutex);
 964         aListenerListCopy = mxEventListeners;
 965         mxEventListeners.clear();
 966
 967         // Reset the pointer to the parent.  It has to be the one who has
 968         // disposed us because he is dying.
 969         mpParent = nullptr;
 970     }
 971
 972     // Inform all listeners that this objects is disposing.
 973     lang::EventObject aEvent (static_cast<accessibility::XAccessible*>(this));
 974     for (auto const& listener : aListenerListCopy)
 975     {
 976         try
 977         {
 978             listener->disposing (aEvent);
 979         }
 980         catch(const uno::Exception&)
 981         {
 982             // Ignore exceptions.
 983         }
 984     }
 985 }
 986
 987 sal_uInt16 SfxThumbnailViewAcc::getItemCount() const
 988 {
 989     return mpParent->ImplGetVisibleItemCount();
 990 }
 991
 992 ThumbnailViewItem* SfxThumbnailViewAcc::getItem (sal_uInt16 nIndex) const
 993 {
 994     return mpParent->ImplGetVisibleItem (nIndex);
 995 }
 996
 997 void SfxThumbnailViewAcc::ThrowIfDisposed()
 998 {
 999     if (rBHelper.bDisposed || rBHelper.bInDispose)
1000     {
1001         SAL_WARN("sfx", "Calling disposed object. Throwing exception:");
1002         throw lang::DisposedException (
1003             "object has been already disposed",
1004             static_cast<uno::XWeak*>(this));
1005     }
1006     else
1007     {
1008         DBG_ASSERT (mpParent!=nullptr, "ValueSetAcc not disposed but mpParent == NULL");
1009     }
1010 }
1011
1012 ThumbnailViewItemAcc::ThumbnailViewItemAcc( ThumbnailViewItem* pParent, bool bIsTransientChildrenDisabled ) :
1013     mpParent( pParent ),
1014     mbIsTransientChildrenDisabled( bIsTransientChildrenDisabled )
1015 {
1016 }
1017
1018 ThumbnailViewItemAcc::~ThumbnailViewItemAcc()
1019 {
1020 }
1021
1022 void ThumbnailViewItemAcc::ParentDestroyed()
1023 {
1024     const ::osl::MutexGuard aGuard( maMutex );
1025     mpParent = nullptr;
1026 }
1027
1028 namespace
1029 {
1030     class theValueItemAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theValueItemAccUnoTunnelId > {};
1031 }
1032
1033 const uno::Sequence< sal_Int8 >& ThumbnailViewItemAcc::getUnoTunnelId()
1034 {
1035     return theValueItemAccUnoTunnelId::get().getSeq();
1036 }
1037
1038 ThumbnailViewItemAcc* ThumbnailViewItemAcc::getImplementation( const uno::Reference< uno::XInterface >& rxData )
1039     throw()
1040 {
1041     try
1042     {
1043         return comphelper::getUnoTunnelImplementation<ThumbnailViewItemAcc>(rxData);
1044     }
1045     catch(const css::uno::Exception&)
1046     {
1047         return nullptr;
1048     }
1049 }
1050
1051 uno::Reference< accessibility::XAccessibleContext > SAL_CALL ThumbnailViewItemAcc::getAccessibleContext()
1052 {
1053     return this;
1054 }
1055
1056 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getAccessibleChildCount()
1057 {
1058     return 0;
1059 }
1060
1061 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewItemAcc::getAccessibleChild( sal_Int32 )
1062 {
1063     throw lang::IndexOutOfBoundsException();
1064 }
1065
1066 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewItemAcc::getAccessibleParent()
1067 {
1068     const SolarMutexGuard aSolarGuard;
1069     uno::Reference< accessibility::XAccessible >    xRet;
1070
1071     if( mpParent )
1072         xRet = mpParent->mrParent.getAccessible();
1073
1074     return xRet;
1075 }
1076
1077 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getAccessibleIndexInParent()
1078 {
1079     const SolarMutexGuard aSolarGuard;
1080     // The index defaults to -1 to indicate the child does not belong to its
1081     // parent.
1082     sal_Int32 nIndexInParent = -1;
1083
1084     if( mpParent )
1085     {
1086         bool bDone = false;
1087
1088         sal_uInt16 nCount = mpParent->mrParent.ImplGetVisibleItemCount();
1089         ThumbnailViewItem* pItem;
1090         for (sal_uInt16 i=0; i<nCount && !bDone; i++)
1091         {
1092             // Guard the retrieval of the i-th child with a try/catch block
1093             // just in case the number of children changes in the meantime.
1094             try
1095             {
1096                 pItem = mpParent->mrParent.ImplGetVisibleItem (i);
1097             }
1098             catch (const lang::IndexOutOfBoundsException&)
1099             {
1100                 pItem = nullptr;
1101             }
1102
1103             // Do not create an accessible object for the test.
1104             if (pItem != nullptr && pItem->mxAcc.is())
1105                 if (pItem->GetAccessible( mbIsTransientChildrenDisabled ).get() == this )
1106                 {
1107                     nIndexInParent = i;
1108                     bDone = true;
1109                 }
1110         }
1111     }
1112
1113     return nIndexInParent;
1114 }
1115
1116 sal_Int16 SAL_CALL ThumbnailViewItemAcc::getAccessibleRole()
1117 {
1118     return accessibility::AccessibleRole::LIST_ITEM;
1119 }
1120
1121 OUString SAL_CALL ThumbnailViewItemAcc::getAccessibleDescription()
1122 {
1123     return OUString();
1124 }
1125
1126 OUString SAL_CALL ThumbnailViewItemAcc::getAccessibleName()
1127 {
1128     const SolarMutexGuard aSolarGuard;
1129     OUString aRet;
1130
1131     if( mpParent )
1132     {
1133         aRet = mpParent->maTitle;
1134
1135         if( aRet.isEmpty() )
1136         {
1137             aRet = "Item " + OUString::number(static_cast<sal_Int32>(mpParent->mnId));
1138         }
1139     }
1140
1141     return aRet;
1142 }
1143
1144 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL ThumbnailViewItemAcc::getAccessibleRelationSet()
1145 {
1146     return uno::Reference< accessibility::XAccessibleRelationSet >();
1147 }
1148
1149 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL ThumbnailViewItemAcc::getAccessibleStateSet()
1150 {
1151     const SolarMutexGuard aSolarGuard;
1152     ::utl::AccessibleStateSetHelper*    pStateSet = new ::utl::AccessibleStateSetHelper;
1153
1154     if( mpParent )
1155     {
1156         pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
1157         pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
1158         pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
1159         pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
1160         if ( !mbIsTransientChildrenDisabled )
1161             pStateSet->AddState (accessibility::AccessibleStateType::TRANSIENT);
1162
1163         // SELECTABLE
1164         pStateSet->AddState( accessibility::AccessibleStateType::SELECTABLE );
1165         //      pStateSet->AddState( accessibility::AccessibleStateType::FOCUSABLE );
1166
1167         // SELECTED
1168         if( mpParent->isSelected() )
1169         {
1170             pStateSet->AddState( accessibility::AccessibleStateType::SELECTED );
1171             //              pStateSet->AddState( accessibility::AccessibleStateType::FOCUSED );
1172         }
1173     }
1174
1175     return pStateSet;
1176 }
1177
1178 lang::Locale SAL_CALL ThumbnailViewItemAcc::getLocale()
1179 {
1180     const SolarMutexGuard aSolarGuard;
1181     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
1182     lang::Locale                                    aRet( "", "", "" );
1183
1184     if( xParent.is() )
1185     {
1186         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
1187
1188         if( xParentContext.is() )
1189             aRet = xParentContext->getLocale();
1190     }
1191
1192     return aRet;
1193 }
1194
1195 void SAL_CALL ThumbnailViewItemAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
1196 {
1197     const ::osl::MutexGuard aGuard( maMutex );
1198
1199     if( !rxListener.is() )
1200         return;
1201
1202     bool bFound = false;
1203
1204     for (auto const& eventListener : mxEventListeners)
1205     {
1206         if( eventListener == rxListener )
1207         {
1208             bFound = true;
1209             break;
1210         }
1211     }
1212
1213     if (!bFound)
1214         mxEventListeners.push_back( rxListener );
1215 }
1216
1217 void SAL_CALL ThumbnailViewItemAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
1218 {
1219     const ::osl::MutexGuard aGuard( maMutex );
1220
1221     if( rxListener.is() )
1222     {
1223         std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter =
1224             std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
1225
1226         if (aIter != mxEventListeners.end())
1227             mxEventListeners.erase( aIter );
1228     }
1229 }
1230
1231 sal_Bool SAL_CALL ThumbnailViewItemAcc::containsPoint( const awt::Point& aPoint )
1232 {
1233     const awt::Rectangle    aRect( getBounds() );
1234     const Point             aSize( aRect.Width, aRect.Height );
1235     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
1236
1237     return tools::Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
1238 }
1239
1240 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewItemAcc::getAccessibleAtPoint( const awt::Point& )
1241 {
1242     uno::Reference< accessibility::XAccessible > xRet;
1243     return xRet;
1244 }
1245
1246 awt::Rectangle SAL_CALL ThumbnailViewItemAcc::getBounds()
1247 {
1248     const SolarMutexGuard aSolarGuard;
1249     awt::Rectangle      aRet;
1250
1251     if( mpParent )
1252     {
1253         tools::Rectangle   aRect( mpParent->getDrawArea() );
1254         tools::Rectangle   aParentRect;
1255
1256         // get position of the accessible parent in screen coordinates
1257         uno::Reference< XAccessible > xParent = getAccessibleParent();
1258         if ( xParent.is() )
1259         {
1260             uno::Reference<XAccessibleComponent> xParentComponent(xParent->getAccessibleContext(), uno::UNO_QUERY);
1261             if (xParentComponent.is())
1262             {
1263                 awt::Size aParentSize = xParentComponent->getSize();
1264                 aParentRect = tools::Rectangle(0, 0, aParentSize.Width, aParentSize.Height);
1265             }
1266         }
1267
1268         aRect.Intersection( aParentRect );
1269
1270         aRet.X = aRect.Left();
1271         aRet.Y = aRect.Top();
1272         aRet.Width = aRect.GetWidth();
1273         aRet.Height = aRect.GetHeight();
1274     }
1275
1276     return aRet;
1277 }
1278
1279 awt::Point SAL_CALL ThumbnailViewItemAcc::getLocation()
1280 {
1281     const awt::Rectangle    aRect( getBounds() );
1282     awt::Point              aRet;
1283
1284     aRet.X = aRect.X;
1285     aRet.Y = aRect.Y;
1286
1287     return aRet;
1288 }
1289
1290 awt::Point SAL_CALL ThumbnailViewItemAcc::getLocationOnScreen()
1291 {
1292     const SolarMutexGuard aSolarGuard;
1293     awt::Point          aRet;
1294
1295     if( mpParent )
1296     {
1297         const Point aPos = mpParent->getDrawArea().TopLeft();
1298
1299         aRet.X = aPos.X();
1300         aRet.Y = aPos.Y();
1301
1302         // get position of the accessible parent in screen coordinates
1303         uno::Reference< XAccessible > xParent = getAccessibleParent();
1304         if ( xParent.is() )
1305         {
1306             uno::Reference<XAccessibleComponent> xParentComponent(xParent->getAccessibleContext(), uno::UNO_QUERY);
1307             if (xParentComponent.is())
1308             {
1309                 awt::Point aParentScreenLoc = xParentComponent->getLocationOnScreen();
1310                 aRet.X += aParentScreenLoc.X;
1311                 aRet.Y += aParentScreenLoc.Y;
1312             }
1313         }
1314     }
1315
1316     return aRet;
1317 }
1318
1319 awt::Size SAL_CALL ThumbnailViewItemAcc::getSize()
1320 {
1321     const awt::Rectangle    aRect( getBounds() );
1322     awt::Size               aRet;
1323
1324     aRet.Width = aRect.Width;
1325     aRet.Height = aRect.Height;
1326
1327     return aRet;
1328 }
1329
1330 void SAL_CALL ThumbnailViewItemAcc::grabFocus()
1331 {
1332     // nothing to do
1333 }
1334
1335 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getForeground(  )
1336 {
1337     Color nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor();
1338     return static_cast<sal_Int32>(nColor);
1339 }
1340
1341 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getBackground(  )
1342 {
1343     return static_cast<sal_Int32>(Application::GetSettings().GetStyleSettings().GetWindowColor());
1344 }
1345
1346 sal_Int64 SAL_CALL ThumbnailViewItemAcc::getSomething( const uno::Sequence< sal_Int8 >& rId )
1347 {
1348     sal_Int64 nRet;
1349
1350     if( isUnoTunnelId<ThumbnailViewItemAcc>(rId) )
1351         nRet = reinterpret_cast< sal_Int64 >( this );
1352     else
1353         nRet = 0;
1354
1355     return nRet;
1356 }
1357
1358 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */