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
  29 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  30 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  31 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  32
  33 using namespace ::com::sun::star;
  34
  35 ThumbnailViewAcc::ThumbnailViewAcc( ThumbnailView* pParent, bool bIsTransientChildrenDisabled ) :
  36     ValueSetAccComponentBase (m_aMutex),
  37     mpParent( pParent ),
  38     mbIsTransientChildrenDisabled( bIsTransientChildrenDisabled ),
  39     mbIsFocused(false)
  40 {
  41 }
  42
  43 ThumbnailViewAcc::~ThumbnailViewAcc()
  44 {
  45 }
  46
  47 void ThumbnailViewAcc::FireAccessibleEvent( short nEventId, const uno::Any& rOldValue, const uno::Any& rNewValue )
  48 {
  49     if( nEventId )
  50     {
  51         ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > > aTmpListeners( mxEventListeners );
  52         accessibility::AccessibleEventObject aEvtObject;
  53
  54         aEvtObject.EventId = nEventId;
  55         aEvtObject.Source = static_cast<uno::XWeak*>(this);
  56         aEvtObject.NewValue = rNewValue;
  57         aEvtObject.OldValue = rOldValue;
  58
  59         for (::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter( aTmpListeners.begin() ), aEnd( aTmpListeners.end() );
  60             aIter != aEnd ; ++aIter)
  61         {
  62             try
  63             {
  64                 (*aIter)->notifyEvent( aEvtObject );
  65             }
  66             catch(const uno::Exception&)
  67             {
  68             }
  69         }
  70     }
  71 }
  72
  73 namespace
  74 {
  75     class theValueSetAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theValueSetAccUnoTunnelId > {};
  76 }
  77
  78 const uno::Sequence< sal_Int8 >& ThumbnailViewAcc::getUnoTunnelId()
  79 {
  80     return theValueSetAccUnoTunnelId::get().getSeq();
  81 }
  82
  83 ThumbnailViewAcc* ThumbnailViewAcc::getImplementation( const uno::Reference< uno::XInterface >& rxData )
  84     throw()
  85 {
  86     try
  87     {
  88         uno::Reference< lang::XUnoTunnel > xUnoTunnel( rxData, uno::UNO_QUERY );
  89         return( xUnoTunnel.is() ? reinterpret_cast<ThumbnailViewAcc*>(sal::static_int_cast<sal_IntPtr>(xUnoTunnel->getSomething( ThumbnailViewAcc::getUnoTunnelId() ))) : NULL );
  90     }
  91     catch(const ::com::sun::star::uno::Exception&)
  92     {
  93         return NULL;
  94     }
  95 }
  96
  97 void ThumbnailViewAcc::GetFocus()
  98 {
  99     mbIsFocused = true;
 100
 101     // Broadcast the state change.
 102     ::com::sun::star::uno::Any aOldState, aNewState;
 103     aNewState <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
 104     FireAccessibleEvent(
 105         ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED,
 106         aOldState, aNewState);
 107 }
 108
 109 void ThumbnailViewAcc::LoseFocus()
 110 {
 111     mbIsFocused = false;
 112
 113     // Broadcast the state change.
 114     ::com::sun::star::uno::Any aOldState, aNewState;
 115     aOldState <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
 116     FireAccessibleEvent(
 117         ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED,
 118         aOldState, aNewState);
 119 }
 120
 121 uno::Reference< accessibility::XAccessibleContext > SAL_CALL ThumbnailViewAcc::getAccessibleContext()
 122     throw (uno::RuntimeException, std::exception)
 123 {
 124     ThrowIfDisposed();
 125     return this;
 126 }
 127
 128 sal_Int32 SAL_CALL ThumbnailViewAcc::getAccessibleChildCount()
 129     throw (uno::RuntimeException, std::exception)
 130 {
 131     const SolarMutexGuard aSolarGuard;
 132     ThrowIfDisposed();
 133
 134     sal_Int32 nCount = mpParent->ImplGetVisibleItemCount();
 135     return nCount;
 136 }
 137
 138 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getAccessibleChild( sal_Int32 i )
 139     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 140 {
 141     ThrowIfDisposed();
 142     const SolarMutexGuard aSolarGuard;
 143     uno::Reference< accessibility::XAccessible >    xRet;
 144     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(i));
 145
 146     if( pItem )
 147         xRet = pItem->GetAccessible( mbIsTransientChildrenDisabled );
 148     else
 149         throw lang::IndexOutOfBoundsException();
 150
 151     return xRet;
 152 }
 153
 154 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getAccessibleParent()
 155     throw (uno::RuntimeException, std::exception)
 156 {
 157     ThrowIfDisposed();
 158     const SolarMutexGuard aSolarGuard;
 159     vcl::Window*                                         pParent = mpParent->GetParent();
 160     uno::Reference< accessibility::XAccessible >    xRet;
 161
 162     if( pParent )
 163         xRet = pParent->GetAccessible();
 164
 165     return xRet;
 166 }
 167
 168 sal_Int32 SAL_CALL ThumbnailViewAcc::getAccessibleIndexInParent()
 169     throw (uno::RuntimeException, std::exception)
 170 {
 171     ThrowIfDisposed();
 172     const SolarMutexGuard aSolarGuard;
 173     vcl::Window*                 pParent = mpParent->GetParent();
 174     sal_Int32               nRet = 0;
 175
 176     if( pParent )
 177     {
 178         bool bFound = false;
 179
 180         for( sal_uInt16 i = 0, nCount = pParent->GetChildCount(); ( i < nCount ) && !bFound; i++ )
 181         {
 182             if( pParent->GetChild( i ) == mpParent )
 183             {
 184                 nRet = i;
 185                 bFound = true;
 186             }
 187         }
 188     }
 189
 190     return nRet;
 191 }
 192
 193 sal_Int16 SAL_CALL ThumbnailViewAcc::getAccessibleRole()
 194     throw (uno::RuntimeException, std::exception)
 195 {
 196     ThrowIfDisposed();
 197     // #i73746# As the Java Access Bridge (v 2.0.1) uses "managesDescendants"
 198     // always if the role is LIST, we need a different role in this case
 199     return (mbIsTransientChildrenDisabled
 200             ? accessibility::AccessibleRole::PANEL
 201             : accessibility::AccessibleRole::LIST );
 202 }
 203
 204 OUString SAL_CALL ThumbnailViewAcc::getAccessibleDescription()
 205     throw (uno::RuntimeException, std::exception)
 206 {
 207     ThrowIfDisposed();
 208     const SolarMutexGuard aSolarGuard;
 209     return OUString("ThumbnailView");
 210 }
 211
 212 OUString SAL_CALL ThumbnailViewAcc::getAccessibleName()
 213     throw (uno::RuntimeException, std::exception)
 214 {
 215     ThrowIfDisposed();
 216     const SolarMutexGuard aSolarGuard;
 217     OUString aRet;
 218
 219     if ( mpParent )
 220     {
 221         aRet = mpParent->GetAccessibleName();
 222         if (aRet.isEmpty())
 223         {
 224             vcl::Window* pLabel = mpParent->GetAccessibleRelationLabeledBy();
 225             if (pLabel && pLabel != mpParent)
 226                 aRet = OutputDevice::GetNonMnemonicString( pLabel->GetText() );
 227         }
 228     }
 229
 230     return aRet;
 231 }
 232
 233 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL ThumbnailViewAcc::getAccessibleRelationSet()
 234     throw (uno::RuntimeException, std::exception)
 235 {
 236     ThrowIfDisposed();
 237     return uno::Reference< accessibility::XAccessibleRelationSet >();
 238 }
 239
 240 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL ThumbnailViewAcc::getAccessibleStateSet()
 241     throw (uno::RuntimeException, std::exception)
 242 {
 243     ThrowIfDisposed();
 244     ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper();
 245
 246     // Set some states.
 247     pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
 248     pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
 249     pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
 250     pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
 251     if ( !mbIsTransientChildrenDisabled )
 252         pStateSet->AddState (accessibility::AccessibleStateType::MANAGES_DESCENDANTS);
 253     pStateSet->AddState (accessibility::AccessibleStateType::FOCUSABLE);
 254     if (mbIsFocused)
 255         pStateSet->AddState (accessibility::AccessibleStateType::FOCUSED);
 256
 257     return pStateSet;
 258 }
 259
 260 lang::Locale SAL_CALL ThumbnailViewAcc::getLocale()
 261     throw (accessibility::IllegalAccessibleComponentStateException, uno::RuntimeException, std::exception)
 262 {
 263     ThrowIfDisposed();
 264     const SolarMutexGuard aSolarGuard;
 265     const OUString                           aEmptyStr;
 266     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
 267     lang::Locale                                    aRet( aEmptyStr, aEmptyStr, aEmptyStr );
 268
 269     if( xParent.is() )
 270     {
 271         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 272
 273         if( xParentContext.is() )
 274             aRet = xParentContext->getLocale ();
 275     }
 276
 277     return aRet;
 278 }
 279
 280 void SAL_CALL ThumbnailViewAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 281     throw (uno::RuntimeException, std::exception)
 282 {
 283     ThrowIfDisposed();
 284     ::osl::MutexGuard aGuard (m_aMutex);
 285
 286     if( rxListener.is() )
 287     {
 288         std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter = mxEventListeners.begin();
 289         bool bFound = false;
 290
 291         while( !bFound && ( aIter != mxEventListeners.end() ) )
 292         {
 293             if( *aIter == rxListener )
 294                 bFound = true;
 295             else
 296                 ++aIter;
 297         }
 298
 299         if (!bFound)
 300             mxEventListeners.push_back( rxListener );
 301     }
 302 }
 303
 304 void SAL_CALL ThumbnailViewAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 305     throw (uno::RuntimeException, std::exception)
 306 {
 307     ThrowIfDisposed();
 308     ::osl::MutexGuard aGuard (m_aMutex);
 309
 310     if( rxListener.is() )
 311     {
 312         std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter =
 313             std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
 314
 315         if (aIter != mxEventListeners.end())
 316             mxEventListeners.erase( aIter );
 317     }
 318 }
 319
 320 sal_Bool SAL_CALL ThumbnailViewAcc::containsPoint( const awt::Point& aPoint )
 321     throw (uno::RuntimeException, std::exception)
 322 {
 323     ThrowIfDisposed();
 324     const awt::Rectangle    aRect( getBounds() );
 325     const Point             aSize( aRect.Width, aRect.Height );
 326     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 327
 328     return Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 329 }
 330
 331 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getAccessibleAtPoint( const awt::Point& aPoint )
 332     throw (uno::RuntimeException, std::exception)
 333 {
 334     ThrowIfDisposed();
 335     const SolarMutexGuard aSolarGuard;
 336     const sal_uInt16                                    nItemId = mpParent->GetItemId( Point( aPoint.X, aPoint.Y ) );
 337     uno::Reference< accessibility::XAccessible >    xRet;
 338
 339     if ( nItemId )
 340     {
 341         const size_t nItemPos = mpParent->GetItemPos( nItemId );
 342
 343         if( THUMBNAILVIEW_ITEM_NONEITEM != nItemPos )
 344         {
 345             ThumbnailViewItem *const pItem = mpParent->mFilteredItemList[nItemPos];
 346             xRet = pItem->GetAccessible( mbIsTransientChildrenDisabled );
 347         }
 348     }
 349
 350     return xRet;
 351 }
 352
 353 awt::Rectangle SAL_CALL ThumbnailViewAcc::getBounds()
 354     throw (uno::RuntimeException, std::exception)
 355 {
 356     ThrowIfDisposed();
 357     const SolarMutexGuard aSolarGuard;
 358     const Point         aOutPos( mpParent->GetPosPixel() );
 359     const Size          aOutSize( mpParent->GetOutputSizePixel() );
 360     awt::Rectangle      aRet;
 361
 362     aRet.X = aOutPos.X();
 363     aRet.Y = aOutPos.Y();
 364     aRet.Width = aOutSize.Width();
 365     aRet.Height = aOutSize.Height();
 366
 367     return aRet;
 368 }
 369
 370 awt::Point SAL_CALL ThumbnailViewAcc::getLocation()
 371     throw (uno::RuntimeException, std::exception)
 372 {
 373     ThrowIfDisposed();
 374     const awt::Rectangle    aRect( getBounds() );
 375     awt::Point              aRet;
 376
 377     aRet.X = aRect.X;
 378     aRet.Y = aRect.Y;
 379
 380     return aRet;
 381 }
 382
 383 awt::Point SAL_CALL ThumbnailViewAcc::getLocationOnScreen()
 384     throw (uno::RuntimeException, std::exception)
 385 {
 386     ThrowIfDisposed();
 387     const SolarMutexGuard aSolarGuard;
 388     const Point         aScreenPos( mpParent->OutputToAbsoluteScreenPixel( Point() ) );
 389     awt::Point          aRet;
 390
 391     aRet.X = aScreenPos.X();
 392     aRet.Y = aScreenPos.Y();
 393
 394     return aRet;
 395 }
 396
 397 awt::Size SAL_CALL ThumbnailViewAcc::getSize()
 398     throw (uno::RuntimeException, std::exception)
 399 {
 400     ThrowIfDisposed();
 401     const awt::Rectangle    aRect( getBounds() );
 402     awt::Size               aRet;
 403
 404     aRet.Width = aRect.Width;
 405     aRet.Height = aRect.Height;
 406
 407     return aRet;
 408 }
 409
 410 void SAL_CALL ThumbnailViewAcc::grabFocus()
 411     throw (uno::RuntimeException, std::exception)
 412 {
 413     ThrowIfDisposed();
 414     const SolarMutexGuard aSolarGuard;
 415     mpParent->GrabFocus();
 416 }
 417
 418 sal_Int32 SAL_CALL ThumbnailViewAcc::getForeground(  )
 419     throw (uno::RuntimeException, std::exception)
 420 {
 421     ThrowIfDisposed();
 422     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor().GetColor();
 423     return static_cast<sal_Int32>(nColor);
 424 }
 425
 426 sal_Int32 SAL_CALL ThumbnailViewAcc::getBackground(  )
 427     throw (uno::RuntimeException, std::exception)
 428 {
 429     ThrowIfDisposed();
 430     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor();
 431     return static_cast<sal_Int32>(nColor);
 432 }
 433
 434 void SAL_CALL ThumbnailViewAcc::selectAccessibleChild( sal_Int32 nChildIndex )
 435     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 436 {
 437     ThrowIfDisposed();
 438     const SolarMutexGuard aSolarGuard;
 439     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 440
 441     if(pItem != NULL)
 442     {
 443         mpParent->SelectItem( pItem->mnId );
 444     }
 445     else
 446         throw lang::IndexOutOfBoundsException();
 447 }
 448
 449 sal_Bool SAL_CALL ThumbnailViewAcc::isAccessibleChildSelected( sal_Int32 nChildIndex )
 450     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 451 {
 452     ThrowIfDisposed();
 453     const SolarMutexGuard aSolarGuard;
 454     ThumbnailViewItem* pItem = getItem (sal::static_int_cast< sal_uInt16 >(nChildIndex));
 455     bool            bRet = false;
 456
 457     if (pItem != NULL)
 458         bRet = mpParent->IsItemSelected( pItem->mnId );
 459     else
 460         throw lang::IndexOutOfBoundsException();
 461
 462     return bRet;
 463 }
 464
 465 void SAL_CALL ThumbnailViewAcc::clearAccessibleSelection()
 466     throw (uno::RuntimeException, std::exception)
 467 {
 468     ThrowIfDisposed();
 469     const SolarMutexGuard aSolarGuard;
 470 }
 471
 472 void SAL_CALL ThumbnailViewAcc::selectAllAccessibleChildren()
 473     throw (uno::RuntimeException, std::exception)
 474 {
 475     ThrowIfDisposed();
 476     // unsupported due to single selection only
 477 }
 478
 479 sal_Int32 SAL_CALL ThumbnailViewAcc::getSelectedAccessibleChildCount()
 480     throw (uno::RuntimeException, std::exception)
 481 {
 482     ThrowIfDisposed();
 483     const SolarMutexGuard aSolarGuard;
 484     sal_Int32           nRet = 0;
 485
 486     for( sal_uInt16 i = 0, nCount = getItemCount(); i < nCount; i++ )
 487     {
 488         ThumbnailViewItem* pItem = getItem (i);
 489
 490         if( pItem && mpParent->IsItemSelected( pItem->mnId ) )
 491             ++nRet;
 492     }
 493
 494     return nRet;
 495 }
 496
 497 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewAcc::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 498     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 499 {
 500     ThrowIfDisposed();
 501     const SolarMutexGuard aSolarGuard;
 502     uno::Reference< accessibility::XAccessible >    xRet;
 503
 504     for( sal_uInt16 i = 0, nCount = getItemCount(), nSel = 0; ( i < nCount ) && !xRet.is(); i++ )
 505     {
 506         ThumbnailViewItem* pItem = getItem(i);
 507
 508         if( pItem && mpParent->IsItemSelected( pItem->mnId ) && ( nSelectedChildIndex == static_cast< sal_Int32 >( nSel++ ) ) )
 509             xRet = pItem->GetAccessible( mbIsTransientChildrenDisabled );
 510     }
 511
 512     return xRet;
 513 }
 514
 515 void SAL_CALL ThumbnailViewAcc::deselectAccessibleChild( sal_Int32 nChildIndex )
 516     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 517 {
 518     ThrowIfDisposed();
 519     const SolarMutexGuard aSolarGuard;
 520     // Because of the single selection we can reset the whole selection when
 521     // the specified child is currently selected.
 522 //FIXME TODO    if (isAccessibleChildSelected(nChildIndex))
 523 //FIXME TODO        ;
 524     (void) nChildIndex;
 525 }
 526
 527 sal_Int64 SAL_CALL ThumbnailViewAcc::getSomething( const uno::Sequence< sal_Int8 >& rId ) throw( uno::RuntimeException, std::exception )
 528 {
 529     sal_Int64 nRet;
 530
 531     if( ( rId.getLength() == 16 ) && ( 0 == memcmp( ThumbnailViewAcc::getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 532         nRet = reinterpret_cast< sal_Int64 >( this );
 533     else
 534         nRet = 0;
 535
 536     return nRet;
 537 }
 538
 539 void SAL_CALL ThumbnailViewAcc::disposing()
 540 {
 541     ::std::vector<uno::Reference<accessibility::XAccessibleEventListener> > aListenerListCopy;
 542
 543     {
 544         // Make a copy of the list and clear the original.
 545         const SolarMutexGuard aSolarGuard;
 546         ::osl::MutexGuard aGuard (m_aMutex);
 547         aListenerListCopy = mxEventListeners;
 548         mxEventListeners.clear();
 549
 550         // Reset the pointer to the parent.  It has to be the one who has
 551         // disposed us because he is dying.
 552         mpParent = NULL;
 553     }
 554
 555     // Inform all listeners that this objects is disposing.
 556     ::std::vector<uno::Reference<accessibility::XAccessibleEventListener> >::const_iterator
 557           aListenerIterator (aListenerListCopy.begin());
 558     lang::EventObject aEvent (static_cast<accessibility::XAccessible*>(this));
 559     while (aListenerIterator != aListenerListCopy.end())
 560     {
 561         try
 562         {
 563             (*aListenerIterator)->disposing (aEvent);
 564         }
 565         catch(const uno::Exception&)
 566         {
 567             // Ignore exceptions.
 568         }
 569
 570         ++aListenerIterator;
 571     }
 572 }
 573
 574 sal_uInt16 ThumbnailViewAcc::getItemCount() const
 575 {
 576     return mpParent->ImplGetVisibleItemCount();
 577 }
 578
 579 ThumbnailViewItem* ThumbnailViewAcc::getItem (sal_uInt16 nIndex) const
 580 {
 581     return mpParent->ImplGetVisibleItem (static_cast<sal_uInt16>(nIndex));
 582 }
 583
 584 void ThumbnailViewAcc::ThrowIfDisposed()
 585     throw (::com::sun::star::lang::DisposedException)
 586 {
 587     if (rBHelper.bDisposed || rBHelper.bInDispose)
 588     {
 589         OSL_TRACE ("Calling disposed object. Throwing exception:");
 590         throw lang::DisposedException (
 591             OUString("object has been already disposed"),
 592             static_cast<uno::XWeak*>(this));
 593     }
 594     else
 595     {
 596         DBG_ASSERT (mpParent!=nullptr, "ValueSetAcc not disposed but mpParent == NULL");
 597     }
 598 }
 599
 600 ThumbnailViewItemAcc::ThumbnailViewItemAcc( ThumbnailViewItem* pParent, bool bIsTransientChildrenDisabled ) :
 601     mpParent( pParent ),
 602     mbIsTransientChildrenDisabled( bIsTransientChildrenDisabled )
 603 {
 604 }
 605
 606 ThumbnailViewItemAcc::~ThumbnailViewItemAcc()
 607 {
 608 }
 609
 610 void ThumbnailViewItemAcc::FireAccessibleEvent( short nEventId, const uno::Any& rOldValue, const uno::Any& rNewValue )
 611 {
 612     if( nEventId )
 613     {
 614         ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > > aTmpListeners( mxEventListeners );
 615         accessibility::AccessibleEventObject aEvtObject;
 616
 617         aEvtObject.EventId = nEventId;
 618         aEvtObject.Source = static_cast<uno::XWeak*>(this);
 619         aEvtObject.NewValue = rNewValue;
 620         aEvtObject.OldValue = rOldValue;
 621
 622         for (::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter( aTmpListeners.begin() ), aEnd( aTmpListeners.end() );
 623             aIter != aEnd ; ++aIter)
 624         {
 625             try
 626             {
 627                 (*aIter)->notifyEvent( aEvtObject );
 628             }
 629             catch(const uno::Exception&)
 630             {
 631             }
 632         }
 633     }
 634 }
 635
 636 void ThumbnailViewItemAcc::ParentDestroyed()
 637 {
 638     const ::osl::MutexGuard aGuard( maMutex );
 639     mpParent = NULL;
 640 }
 641
 642 namespace
 643 {
 644     class theValueItemAccUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theValueItemAccUnoTunnelId > {};
 645 }
 646
 647 const uno::Sequence< sal_Int8 >& ThumbnailViewItemAcc::getUnoTunnelId()
 648 {
 649     return theValueItemAccUnoTunnelId::get().getSeq();
 650 }
 651
 652 ThumbnailViewItemAcc* ThumbnailViewItemAcc::getImplementation( const uno::Reference< uno::XInterface >& rxData )
 653     throw()
 654 {
 655     try
 656     {
 657         uno::Reference< lang::XUnoTunnel > xUnoTunnel( rxData, uno::UNO_QUERY );
 658         return( xUnoTunnel.is() ?
 659                 reinterpret_cast<ThumbnailViewItemAcc*>(sal::static_int_cast<sal_IntPtr>(
 660                         xUnoTunnel->getSomething( ThumbnailViewItemAcc::getUnoTunnelId() ))) :
 661                 NULL );
 662     }
 663     catch(const ::com::sun::star::uno::Exception&)
 664     {
 665         return NULL;
 666     }
 667 }
 668
 669 uno::Reference< accessibility::XAccessibleContext > SAL_CALL ThumbnailViewItemAcc::getAccessibleContext()
 670     throw (uno::RuntimeException, std::exception)
 671 {
 672     return this;
 673 }
 674
 675 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getAccessibleChildCount()
 676     throw (uno::RuntimeException, std::exception)
 677 {
 678     return 0;
 679 }
 680
 681 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewItemAcc::getAccessibleChild( sal_Int32 )
 682     throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 683 {
 684     throw lang::IndexOutOfBoundsException();
 685 }
 686
 687 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewItemAcc::getAccessibleParent()
 688     throw (uno::RuntimeException, std::exception)
 689 {
 690     const SolarMutexGuard aSolarGuard;
 691     uno::Reference< accessibility::XAccessible >    xRet;
 692
 693     if( mpParent )
 694         xRet = mpParent->mrParent.GetAccessible();
 695
 696     return xRet;
 697 }
 698
 699 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getAccessibleIndexInParent()
 700     throw (uno::RuntimeException, std::exception)
 701 {
 702     const SolarMutexGuard aSolarGuard;
 703     // The index defaults to -1 to indicate the child does not belong to its
 704     // parent.
 705     sal_Int32 nIndexInParent = -1;
 706
 707     if( mpParent )
 708     {
 709         bool bDone = false;
 710
 711         sal_uInt16 nCount = mpParent->mrParent.ImplGetVisibleItemCount();
 712         ThumbnailViewItem* pItem;
 713         for (sal_uInt16 i=0; i<nCount && !bDone; i++)
 714         {
 715             // Guard the retrieval of the i-th child with a try/catch block
 716             // just in case the number of children changes in the mean time.
 717             try
 718             {
 719                 pItem = mpParent->mrParent.ImplGetVisibleItem (i);
 720             }
 721             catch (const lang::IndexOutOfBoundsException&)
 722             {
 723                 pItem = NULL;
 724             }
 725
 726             // Do not create an accessible object for the test.
 727             if (pItem != NULL && pItem->mpxAcc != NULL)
 728                 if (pItem->GetAccessible( mbIsTransientChildrenDisabled ).get() == this )
 729                 {
 730                     nIndexInParent = i;
 731                     bDone = true;
 732                 }
 733         }
 734     }
 735
 736     return nIndexInParent;
 737 }
 738
 739 sal_Int16 SAL_CALL ThumbnailViewItemAcc::getAccessibleRole()
 740     throw (uno::RuntimeException, std::exception)
 741 {
 742     return accessibility::AccessibleRole::LIST_ITEM;
 743 }
 744
 745 OUString SAL_CALL ThumbnailViewItemAcc::getAccessibleDescription()
 746     throw (uno::RuntimeException, std::exception)
 747 {
 748     return OUString();
 749 }
 750
 751 OUString SAL_CALL ThumbnailViewItemAcc::getAccessibleName()
 752     throw (uno::RuntimeException, std::exception)
 753 {
 754     const SolarMutexGuard aSolarGuard;
 755     OUString aRet;
 756
 757     if( mpParent )
 758     {
 759         aRet = mpParent->maTitle;
 760
 761         if( aRet.isEmpty() )
 762         {
 763             OUStringBuffer aBuffer("Item ");
 764             aBuffer.append(static_cast<sal_Int32>(mpParent->mnId));
 765             aRet = aBuffer.makeStringAndClear();
 766         }
 767     }
 768
 769     return aRet;
 770 }
 771
 772 uno::Reference< accessibility::XAccessibleRelationSet > SAL_CALL ThumbnailViewItemAcc::getAccessibleRelationSet()
 773     throw (uno::RuntimeException, std::exception)
 774 {
 775     return uno::Reference< accessibility::XAccessibleRelationSet >();
 776 }
 777
 778 uno::Reference< accessibility::XAccessibleStateSet > SAL_CALL ThumbnailViewItemAcc::getAccessibleStateSet()
 779     throw (uno::RuntimeException, std::exception)
 780 {
 781     const SolarMutexGuard aSolarGuard;
 782     ::utl::AccessibleStateSetHelper*    pStateSet = new ::utl::AccessibleStateSetHelper;
 783
 784     if( mpParent )
 785     {
 786         pStateSet->AddState (accessibility::AccessibleStateType::ENABLED);
 787         pStateSet->AddState (accessibility::AccessibleStateType::SENSITIVE);
 788         pStateSet->AddState (accessibility::AccessibleStateType::SHOWING);
 789         pStateSet->AddState (accessibility::AccessibleStateType::VISIBLE);
 790         if ( !mbIsTransientChildrenDisabled )
 791             pStateSet->AddState (accessibility::AccessibleStateType::TRANSIENT);
 792
 793         // SELECTABLE
 794         pStateSet->AddState( accessibility::AccessibleStateType::SELECTABLE );
 795         //      pStateSet->AddState( accessibility::AccessibleStateType::FOCUSABLE );
 796
 797         // SELECTED
 798         if( mpParent->isSelected() )
 799         {
 800             pStateSet->AddState( accessibility::AccessibleStateType::SELECTED );
 801             //              pStateSet->AddState( accessibility::AccessibleStateType::FOCUSED );
 802         }
 803     }
 804
 805     return pStateSet;
 806 }
 807
 808 lang::Locale SAL_CALL ThumbnailViewItemAcc::getLocale()
 809     throw (accessibility::IllegalAccessibleComponentStateException, uno::RuntimeException, std::exception)
 810 {
 811     const SolarMutexGuard aSolarGuard;
 812     const OUString                           aEmptyStr;
 813     uno::Reference< accessibility::XAccessible >    xParent( getAccessibleParent() );
 814     lang::Locale                                    aRet( aEmptyStr, aEmptyStr, aEmptyStr );
 815
 816     if( xParent.is() )
 817     {
 818         uno::Reference< accessibility::XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 819
 820         if( xParentContext.is() )
 821             aRet = xParentContext->getLocale();
 822     }
 823
 824     return aRet;
 825 }
 826
 827 void SAL_CALL ThumbnailViewItemAcc::addAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 828     throw (uno::RuntimeException, std::exception)
 829 {
 830     const ::osl::MutexGuard aGuard( maMutex );
 831
 832     if( rxListener.is() )
 833     {
 834            ::std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::const_iterator aIter = mxEventListeners.begin();
 835         bool bFound = false;
 836
 837         while( !bFound && ( aIter != mxEventListeners.end() ) )
 838         {
 839             if( *aIter == rxListener )
 840                 bFound = true;
 841             else
 842                 ++aIter;
 843         }
 844
 845         if (!bFound)
 846             mxEventListeners.push_back( rxListener );
 847     }
 848 }
 849
 850 void SAL_CALL ThumbnailViewItemAcc::removeAccessibleEventListener( const uno::Reference< accessibility::XAccessibleEventListener >& rxListener )
 851     throw (uno::RuntimeException, std::exception)
 852 {
 853     const ::osl::MutexGuard aGuard( maMutex );
 854
 855     if( rxListener.is() )
 856     {
 857         std::vector< uno::Reference< accessibility::XAccessibleEventListener > >::iterator aIter =
 858             std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
 859
 860         if (aIter != mxEventListeners.end())
 861             mxEventListeners.erase( aIter );
 862     }
 863 }
 864
 865 sal_Bool SAL_CALL ThumbnailViewItemAcc::containsPoint( const awt::Point& aPoint )
 866     throw (uno::RuntimeException, std::exception)
 867 {
 868     const awt::Rectangle    aRect( getBounds() );
 869     const Point             aSize( aRect.Width, aRect.Height );
 870     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 871
 872     return Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 873 }
 874
 875 uno::Reference< accessibility::XAccessible > SAL_CALL ThumbnailViewItemAcc::getAccessibleAtPoint( const awt::Point& )
 876     throw (uno::RuntimeException, std::exception)
 877 {
 878     uno::Reference< accessibility::XAccessible > xRet;
 879     return xRet;
 880 }
 881
 882 awt::Rectangle SAL_CALL ThumbnailViewItemAcc::getBounds()
 883     throw (uno::RuntimeException, std::exception)
 884 {
 885     const SolarMutexGuard aSolarGuard;
 886     awt::Rectangle      aRet;
 887
 888     if( mpParent )
 889     {
 890         Rectangle   aRect( mpParent->getDrawArea() );
 891         Point       aOrigin;
 892         Rectangle   aParentRect( aOrigin, mpParent->mrParent.GetOutputSizePixel() );
 893
 894         aRect.Intersection( aParentRect );
 895
 896         aRet.X = aRect.Left();
 897         aRet.Y = aRect.Top();
 898         aRet.Width = aRect.GetWidth();
 899         aRet.Height = aRect.GetHeight();
 900     }
 901
 902     return aRet;
 903 }
 904
 905 awt::Point SAL_CALL ThumbnailViewItemAcc::getLocation()
 906     throw (uno::RuntimeException, std::exception)
 907 {
 908     const awt::Rectangle    aRect( getBounds() );
 909     awt::Point              aRet;
 910
 911     aRet.X = aRect.X;
 912     aRet.Y = aRect.Y;
 913
 914     return aRet;
 915 }
 916
 917 awt::Point SAL_CALL ThumbnailViewItemAcc::getLocationOnScreen()
 918     throw (uno::RuntimeException, std::exception)
 919 {
 920     const SolarMutexGuard aSolarGuard;
 921     awt::Point          aRet;
 922
 923     if( mpParent )
 924     {
 925         const Point aPos = mpParent->getDrawArea().TopLeft();
 926         const Point aScreenPos( mpParent->mrParent.OutputToAbsoluteScreenPixel( aPos ) );
 927
 928         aRet.X = aScreenPos.X();
 929         aRet.Y = aScreenPos.Y();
 930     }
 931
 932     return aRet;
 933 }
 934
 935 awt::Size SAL_CALL ThumbnailViewItemAcc::getSize()
 936     throw (uno::RuntimeException, std::exception)
 937 {
 938     const awt::Rectangle    aRect( getBounds() );
 939     awt::Size               aRet;
 940
 941     aRet.Width = aRect.Width;
 942     aRet.Height = aRect.Height;
 943
 944     return aRet;
 945 }
 946
 947 void SAL_CALL ThumbnailViewItemAcc::grabFocus()
 948     throw (uno::RuntimeException, std::exception)
 949 {
 950     // nothing to do
 951 }
 952
 953 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getForeground(  )
 954     throw (uno::RuntimeException, std::exception)
 955 {
 956     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor().GetColor();
 957     return static_cast<sal_Int32>(nColor);
 958 }
 959
 960 sal_Int32 SAL_CALL ThumbnailViewItemAcc::getBackground(  )
 961     throw (uno::RuntimeException, std::exception)
 962 {
 963     return static_cast<sal_Int32>(Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor());
 964 }
 965
 966 sal_Int64 SAL_CALL ThumbnailViewItemAcc::getSomething( const uno::Sequence< sal_Int8 >& rId ) throw( uno::RuntimeException, std::exception )
 967 {
 968     sal_Int64 nRet;
 969
 970     if( ( rId.getLength() == 16 ) && ( 0 == memcmp( ThumbnailViewItemAcc::getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 971         nRet = reinterpret_cast< sal_Int64 >( this );
 972     else
 973         nRet = 0;
 974
 975     return nRet;
 976 }
 977
 978 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */