accessibility/source/extended/AccessibleBrowseBoxBase.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 "accessibility/extended/AccessibleBrowseBoxBase.hxx"
  21 #include <svtools/accessibletableprovider.hxx>
  22 #include <comphelper/servicehelper.hxx>
  23 #include <cppuhelper/supportsservice.hxx>
  24
  25 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  26 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  27 #include <unotools/accessiblerelationsethelper.hxx>
  28
  29
  30
  31 using ::com::sun::star::uno::Reference;
  32 using ::com::sun::star::uno::Sequence;
  33 using ::com::sun::star::uno::Any;
  34
  35 using namespace ::com::sun::star;
  36 using namespace ::com::sun::star::accessibility;
  37 using namespace ::comphelper;
  38 using namespace ::svt;
  39
  40
  41
  42
  43 namespace accessibility {
  44
  45 using namespace com::sun::star::accessibility::AccessibleStateType;
  46
  47
  48 // Ctor/Dtor/disposing --------------------------------------------------------
  49
  50 AccessibleBrowseBoxBase::AccessibleBrowseBoxBase(
  51         const Reference< XAccessible >& rxParent,
  52         IAccessibleTableProvider&                      rBrowseBox,
  53         const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& _xFocusWindow,
  54         AccessibleBrowseBoxObjType      eObjType ) :
  55     AccessibleBrowseBoxImplHelper( m_aMutex ),
  56     mxParent( rxParent ),
  57     mpBrowseBox( &rBrowseBox ),
  58     m_xFocusWindow(_xFocusWindow),
  59     maName( rBrowseBox.GetAccessibleObjectName( eObjType ) ),
  60     maDescription( rBrowseBox.GetAccessibleObjectDescription( eObjType ) ),
  61     meObjType( eObjType ),
  62     m_aClientId(0)
  63 {
  64     if ( m_xFocusWindow.is() )
  65         m_xFocusWindow->addFocusListener( this );
  66 }
  67
  68 AccessibleBrowseBoxBase::AccessibleBrowseBoxBase(
  69         const Reference< XAccessible >& rxParent,
  70         IAccessibleTableProvider&                      rBrowseBox,
  71         const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& _xFocusWindow,
  72         AccessibleBrowseBoxObjType      eObjType,
  73         const OUString&          rName,
  74         const OUString&          rDescription ) :
  75     AccessibleBrowseBoxImplHelper( m_aMutex ),
  76     mxParent( rxParent ),
  77     mpBrowseBox( &rBrowseBox ),
  78     m_xFocusWindow(_xFocusWindow),
  79     maName( rName ),
  80     maDescription( rDescription ),
  81     meObjType( eObjType ),
  82     m_aClientId(0)
  83 {
  84     if ( m_xFocusWindow.is() )
  85         m_xFocusWindow->addFocusListener( this );
  86 }
  87
  88 AccessibleBrowseBoxBase::~AccessibleBrowseBoxBase()
  89 {
  90     if( isAlive() )
  91     {
  92         // increment ref count to prevent double call of Dtor
  93         osl_atomic_increment( &m_refCount );
  94         dispose();
  95     }
  96 }
  97
  98 void SAL_CALL AccessibleBrowseBoxBase::disposing()
  99 {
 100     ::osl::MutexGuard aGuard( getOslMutex() );
 101     if ( m_xFocusWindow.is() )
 102     {
 103         SolarMutexGuard aSolarGuard;
 104         m_xFocusWindow->removeFocusListener( this );
 105     }
 106
 107     if ( getClientId( ) )
 108     {
 109         AccessibleEventNotifier::TClientId nId( getClientId( ) );
 110         setClientId( 0 );
 111         AccessibleEventNotifier::revokeClientNotifyDisposing( nId, *this );
 112     }
 113
 114     mxParent = NULL;
 115     mpBrowseBox = NULL;
 116 }
 117
 118 // XAccessibleContext ---------------------------------------------------------
 119
 120 Reference< XAccessible > SAL_CALL AccessibleBrowseBoxBase::getAccessibleParent()
 121     throw ( uno::RuntimeException, std::exception )
 122 {
 123     ::osl::MutexGuard aGuard( getOslMutex() );
 124     ensureIsAlive();
 125     return mxParent;
 126 }
 127
 128 sal_Int32 SAL_CALL AccessibleBrowseBoxBase::getAccessibleIndexInParent()
 129     throw ( uno::RuntimeException, std::exception )
 130 {
 131     ::osl::MutexGuard aGuard( getOslMutex() );
 132     ensureIsAlive();
 133
 134     // -1 for child not found/no parent (according to specification)
 135     sal_Int32 nRet = -1;
 136
 137     Reference< uno::XInterface > xMeMyselfAndI( static_cast< XAccessibleContext* >( this ), uno::UNO_QUERY );
 138
 139     //  iterate over parent's children and search for this object
 140     if( mxParent.is() )
 141     {
 142         Reference< XAccessibleContext >
 143             xParentContext( mxParent->getAccessibleContext() );
 144         if( xParentContext.is() )
 145         {
 146             Reference< uno::XInterface > xChild;
 147
 148             sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
 149             for( sal_Int32 nChild = 0; nChild < nChildCount; ++nChild )
 150             {
 151                 xChild.set(xParentContext->getAccessibleChild( nChild ), css::uno::UNO_QUERY);
 152
 153                 if ( xMeMyselfAndI.get() == xChild.get() )
 154                 {
 155                     nRet = nChild;
 156                     break;
 157                 }
 158             }
 159         }
 160    }
 161    return nRet;
 162 }
 163
 164 OUString SAL_CALL AccessibleBrowseBoxBase::getAccessibleDescription()
 165     throw ( uno::RuntimeException, std::exception )
 166 {
 167     ::osl::MutexGuard aGuard( getOslMutex() );
 168     ensureIsAlive();
 169     return maDescription;
 170 }
 171
 172 OUString SAL_CALL AccessibleBrowseBoxBase::getAccessibleName()
 173     throw ( uno::RuntimeException, std::exception )
 174 {
 175     ::osl::MutexGuard aGuard( getOslMutex() );
 176     ensureIsAlive();
 177     return maName;
 178 }
 179
 180 Reference< XAccessibleRelationSet > SAL_CALL
 181 AccessibleBrowseBoxBase::getAccessibleRelationSet()
 182     throw ( uno::RuntimeException, std::exception )
 183 {
 184     ensureIsAlive();
 185     // BrowseBox does not have relations.
 186        return new utl::AccessibleRelationSetHelper;
 187 }
 188
 189 Reference< XAccessibleStateSet > SAL_CALL
 190 AccessibleBrowseBoxBase::getAccessibleStateSet()
 191     throw ( uno::RuntimeException, std::exception )
 192 {
 193     SolarMutexGuard aSolarGuard;
 194     ::osl::MutexGuard aGuard( getOslMutex() );
 195     // don't check whether alive -> StateSet may contain DEFUNC
 196     return implCreateStateSetHelper();
 197 }
 198
 199 lang::Locale SAL_CALL AccessibleBrowseBoxBase::getLocale()
 200     throw ( IllegalAccessibleComponentStateException, uno::RuntimeException, std::exception )
 201 {
 202     ::osl::MutexGuard aGuard( getOslMutex() );
 203     ensureIsAlive();
 204     if( mxParent.is() )
 205     {
 206         Reference< XAccessibleContext >
 207             xParentContext( mxParent->getAccessibleContext() );
 208         if( xParentContext.is() )
 209             return xParentContext->getLocale();
 210     }
 211     throw IllegalAccessibleComponentStateException();
 212 }
 213
 214 // XAccessibleComponent -------------------------------------------------------
 215
 216 sal_Bool SAL_CALL AccessibleBrowseBoxBase::containsPoint( const awt::Point& rPoint )
 217     throw ( uno::RuntimeException, std::exception )
 218 {
 219     return Rectangle( Point(), getBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 220 }
 221
 222 awt::Rectangle SAL_CALL AccessibleBrowseBoxBase::getBounds()
 223     throw ( uno::RuntimeException, std::exception )
 224 {
 225     return AWTRectangle( getBoundingBox() );
 226 }
 227
 228 awt::Point SAL_CALL AccessibleBrowseBoxBase::getLocation()
 229     throw ( uno::RuntimeException, std::exception )
 230 {
 231     return AWTPoint( getBoundingBox().TopLeft() );
 232 }
 233
 234 awt::Point SAL_CALL AccessibleBrowseBoxBase::getLocationOnScreen()
 235     throw ( uno::RuntimeException, std::exception )
 236 {
 237     return AWTPoint( getBoundingBoxOnScreen().TopLeft() );
 238 }
 239
 240 awt::Size SAL_CALL AccessibleBrowseBoxBase::getSize()
 241     throw ( uno::RuntimeException, std::exception )
 242 {
 243     return AWTSize( getBoundingBox().GetSize() );
 244 }
 245
 246 void SAL_CALL AccessibleBrowseBoxBase::focusGained( const ::com::sun::star::awt::FocusEvent& ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 247 {
 248     com::sun::star::uno::Any aFocused;
 249     com::sun::star::uno::Any aEmpty;
 250     aFocused <<= FOCUSED;
 251
 252     commitEvent(AccessibleEventId::STATE_CHANGED,aFocused,aEmpty);
 253 }
 254
 255
 256 void SAL_CALL AccessibleBrowseBoxBase::focusLost( const ::com::sun::star::awt::FocusEvent& ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 257 {
 258     com::sun::star::uno::Any aFocused;
 259     com::sun::star::uno::Any aEmpty;
 260     aFocused <<= FOCUSED;
 261
 262     commitEvent(AccessibleEventId::STATE_CHANGED,aEmpty,aFocused);
 263 }
 264 // XAccessibleEventBroadcaster ------------------------------------------------
 265
 266 void SAL_CALL AccessibleBrowseBoxBase::addAccessibleEventListener(
 267         const Reference< XAccessibleEventListener>& _rxListener )
 268     throw ( uno::RuntimeException, std::exception )
 269 {
 270     if ( _rxListener.is() )
 271     {
 272         ::osl::MutexGuard aGuard( getOslMutex() );
 273         if ( !getClientId( ) )
 274             setClientId( AccessibleEventNotifier::registerClient( ) );
 275
 276         AccessibleEventNotifier::addEventListener( getClientId( ), _rxListener );
 277     }
 278 }
 279
 280 void SAL_CALL AccessibleBrowseBoxBase::removeAccessibleEventListener(
 281         const Reference< XAccessibleEventListener>& _rxListener )
 282     throw ( uno::RuntimeException, std::exception )
 283 {
 284     if( _rxListener.is() && getClientId( ) )
 285     {
 286         ::osl::MutexGuard aGuard( getOslMutex() );
 287         sal_Int32 nListenerCount = AccessibleEventNotifier::removeEventListener( getClientId( ), _rxListener );
 288         if ( !nListenerCount )
 289         {
 290             // no listeners anymore
 291             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 292             // and at least to us not firing any events anymore, in case somebody calls
 293             // NotifyAccessibleEvent, again
 294
 295             AccessibleEventNotifier::TClientId nId( getClientId( ) );
 296             setClientId( 0 );
 297             AccessibleEventNotifier::revokeClient( nId );
 298         }
 299     }
 300 }
 301
 302 // XTypeProvider --------------------------------------------------------------
 303
 304 Sequence< sal_Int8 > SAL_CALL AccessibleBrowseBoxBase::getImplementationId()
 305     throw ( uno::RuntimeException, std::exception )
 306 {
 307     return css::uno::Sequence<sal_Int8>();
 308 }
 309
 310 // XServiceInfo ---------------------------------------------------------------
 311
 312 sal_Bool SAL_CALL AccessibleBrowseBoxBase::supportsService(
 313         const OUString& rServiceName )
 314     throw ( uno::RuntimeException, std::exception )
 315 {
 316     return cppu::supportsService(this, rServiceName);
 317 }
 318
 319 Sequence< OUString > SAL_CALL AccessibleBrowseBoxBase::getSupportedServiceNames()
 320     throw ( uno::RuntimeException, std::exception )
 321 {
 322     const OUString aServiceName( "com.sun.star.accessibility.AccessibleContext" );
 323     return Sequence< OUString >( &aServiceName, 1 );
 324 }
 325
 326 // other public methods -------------------------------------------------------
 327
 328 void AccessibleBrowseBoxBase::setAccessibleName( const OUString& rName )
 329 {
 330     ::osl::ClearableMutexGuard aGuard( getOslMutex() );
 331     Any aOld;
 332     aOld <<= maName;
 333     maName = rName;
 334
 335     aGuard.clear();
 336
 337     commitEvent(
 338         AccessibleEventId::NAME_CHANGED,
 339         uno::makeAny( maName ),
 340         aOld );
 341 }
 342
 343 void AccessibleBrowseBoxBase::setAccessibleDescription( const OUString& rDescription )
 344 {
 345     ::osl::ClearableMutexGuard aGuard( getOslMutex() );
 346     Any aOld;
 347     aOld <<= maDescription;
 348     maDescription = rDescription;
 349
 350     aGuard.clear();
 351
 352     commitEvent(
 353         AccessibleEventId::DESCRIPTION_CHANGED,
 354         uno::makeAny( maDescription ),
 355         aOld );
 356 }
 357
 358 // internal virtual methods ---------------------------------------------------
 359
 360 bool AccessibleBrowseBoxBase::implIsShowing()
 361 {
 362     bool bShowing = false;
 363     if( mxParent.is() )
 364     {
 365         Reference< XAccessibleComponent >
 366             xParentComp( mxParent->getAccessibleContext(), uno::UNO_QUERY );
 367         if( xParentComp.is() )
 368             bShowing = implGetBoundingBox().IsOver(
 369                 VCLRectangle( xParentComp->getBounds() ) );
 370     }
 371     return bShowing;
 372 }
 373
 374 ::utl::AccessibleStateSetHelper* AccessibleBrowseBoxBase::implCreateStateSetHelper()
 375 {
 376     ::utl::AccessibleStateSetHelper*
 377         pStateSetHelper = new ::utl::AccessibleStateSetHelper;
 378
 379     if( isAlive() )
 380     {
 381         // SHOWING done with mxParent
 382         if( implIsShowing() )
 383             pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 384         // BrowseBox fills StateSet with states depending on object type
 385         mpBrowseBox->FillAccessibleStateSet( *pStateSetHelper, getType() );
 386     }
 387     else
 388         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 389
 390     return pStateSetHelper;
 391 }
 392
 393 // internal helper methods ----------------------------------------------------
 394
 395 bool AccessibleBrowseBoxBase::isAlive() const
 396 {
 397     return !rBHelper.bDisposed && !rBHelper.bInDispose && mpBrowseBox;
 398 }
 399
 400 void AccessibleBrowseBoxBase::ensureIsAlive() const
 401     throw ( lang::DisposedException )
 402 {
 403     if( !isAlive() )
 404         throw lang::DisposedException();
 405 }
 406
 407 Rectangle AccessibleBrowseBoxBase::getBoundingBox()
 408     throw ( lang::DisposedException )
 409 {
 410     SolarMutexGuard aSolarGuard;
 411     ::osl::MutexGuard aGuard( getOslMutex() );
 412     ensureIsAlive();
 413     Rectangle aRect = implGetBoundingBox();
 414     if ( 0 == aRect.Left() && 0 == aRect.Top() && 0 == aRect.Right() && 0 == aRect.Bottom() )
 415     {
 416         SAL_WARN( "accessibility", "rectangle doesn't exist" );
 417     }
 418     return aRect;
 419 }
 420
 421 Rectangle AccessibleBrowseBoxBase::getBoundingBoxOnScreen()
 422     throw ( lang::DisposedException )
 423 {
 424     SolarMutexGuard aSolarGuard;
 425     ::osl::MutexGuard aGuard( getOslMutex() );
 426     ensureIsAlive();
 427     Rectangle aRect = implGetBoundingBoxOnScreen();
 428     if ( 0 == aRect.Left() && 0 == aRect.Top() && 0 == aRect.Right() && 0 == aRect.Bottom() )
 429     {
 430         SAL_WARN( "accessibility", "rectangle doesn't exist" );
 431     }
 432     return aRect;
 433 }
 434
 435 void AccessibleBrowseBoxBase::commitEvent(
 436         sal_Int16 _nEventId, const Any& _rNewValue, const Any& _rOldValue )
 437 {
 438     ::osl::ClearableMutexGuard aGuard( getOslMutex() );
 439     if ( !getClientId( ) )
 440             // if we don't have a client id for the notifier, then we don't have listeners, then
 441             // we don't need to notify anything
 442             return;
 443
 444     // build an event object
 445     AccessibleEventObject aEvent;
 446     aEvent.Source = *this;
 447     aEvent.EventId = _nEventId;
 448     aEvent.OldValue = _rOldValue;
 449     aEvent.NewValue = _rNewValue;
 450
 451     // let the notifier handle this event
 452
 453     AccessibleEventNotifier::addEvent( getClientId( ), aEvent );
 454 }
 455
 456 sal_Int16 SAL_CALL AccessibleBrowseBoxBase::getAccessibleRole()
 457     throw ( uno::RuntimeException, std::exception )
 458 {
 459     ensureIsAlive();
 460     sal_Int16 nRole = AccessibleRole::UNKNOWN;
 461     switch ( meObjType )
 462     {
 463         case BBTYPE_ROWHEADERCELL:
 464             nRole = AccessibleRole::ROW_HEADER;
 465             break;
 466         case BBTYPE_COLUMNHEADERCELL:
 467             nRole = AccessibleRole::COLUMN_HEADER;
 468             break;
 469         case BBTYPE_COLUMNHEADERBAR:
 470         case BBTYPE_ROWHEADERBAR:
 471         case BBTYPE_TABLE:
 472             nRole = AccessibleRole::TABLE;
 473             break;
 474         case BBTYPE_TABLECELL:
 475             nRole = AccessibleRole::TABLE_CELL;
 476             break;
 477         case BBTYPE_BROWSEBOX:
 478             nRole = AccessibleRole::PANEL;
 479             break;
 480         case BBTYPE_CHECKBOXCELL:
 481             nRole = AccessibleRole::CHECK_BOX;
 482             break;
 483     }
 484     return nRole;
 485 }
 486
 487 Reference<XAccessible > SAL_CALL AccessibleBrowseBoxBase::getAccessibleAtPoint( const ::com::sun::star::awt::Point& )
 488         throw ( uno::RuntimeException, std::exception )
 489 {
 490     return NULL;
 491 }
 492
 493 void SAL_CALL AccessibleBrowseBoxBase::disposing( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 494 {
 495     m_xFocusWindow = NULL;
 496 }
 497
 498 sal_Int32 SAL_CALL AccessibleBrowseBoxBase::getForeground(  ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 499 {
 500     SolarMutexGuard aSolarGuard;
 501     ::osl::MutexGuard aGuard( getOslMutex() );
 502     ensureIsAlive();
 503
 504     sal_Int32 nColor = 0;
 505     vcl::Window* pInst = mpBrowseBox->GetWindowInstance();
 506     if ( pInst )
 507     {
 508         if ( pInst->IsControlForeground() )
 509             nColor = pInst->GetControlForeground().GetColor();
 510         else
 511         {
 512             vcl::Font aFont;
 513             if ( pInst->IsControlFont() )
 514                 aFont = pInst->GetControlFont();
 515             else
 516                 aFont = pInst->GetFont();
 517             nColor = aFont.GetColor().GetColor();
 518         }
 519     }
 520
 521     return nColor;
 522 }
 523
 524 sal_Int32 SAL_CALL AccessibleBrowseBoxBase::getBackground(  ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 525 {
 526     SolarMutexGuard aSolarGuard;
 527     ::osl::MutexGuard aGuard( getOslMutex() );
 528     ensureIsAlive();
 529     sal_Int32 nColor = 0;
 530     vcl::Window* pInst = mpBrowseBox->GetWindowInstance();
 531     if ( pInst )
 532     {
 533         if ( pInst->IsControlBackground() )
 534             nColor = pInst->GetControlBackground().GetColor();
 535         else
 536             nColor = pInst->GetBackground().GetColor().GetColor();
 537     }
 538
 539     return nColor;
 540 }
 541
 542
 543 // XInterface -----------------------------------------------------------------
 544 IMPLEMENT_FORWARD_XINTERFACE2( BrowseBoxAccessibleElement, AccessibleBrowseBoxBase, BrowseBoxAccessibleElement_Base )
 545
 546 // XTypeProvider --------------------------------------------------------------
 547 IMPLEMENT_FORWARD_XTYPEPROVIDER2( BrowseBoxAccessibleElement, AccessibleBrowseBoxBase, BrowseBoxAccessibleElement_Base )
 548
 549 // XAccessible ----------------------------------------------------------------
 550
 551 Reference< XAccessibleContext > SAL_CALL BrowseBoxAccessibleElement::getAccessibleContext() throw ( uno::RuntimeException, std::exception )
 552 {
 553     ensureIsAlive();
 554     return this;
 555 }
 556
 557
 558 BrowseBoxAccessibleElement::BrowseBoxAccessibleElement( const Reference< XAccessible >& rxParent, IAccessibleTableProvider& rBrowseBox,
 559         const Reference< awt::XWindow >& _xFocusWindow, AccessibleBrowseBoxObjType  eObjType )
 560     :AccessibleBrowseBoxBase( rxParent, rBrowseBox, _xFocusWindow, eObjType )
 561 {
 562 }
 563
 564
 565 BrowseBoxAccessibleElement::BrowseBoxAccessibleElement( const Reference< XAccessible >& rxParent, IAccessibleTableProvider& rBrowseBox,
 566         const Reference< awt::XWindow >& _xFocusWindow, AccessibleBrowseBoxObjType  eObjType,
 567         const OUString& rName, const OUString& rDescription )
 568     :AccessibleBrowseBoxBase( rxParent, rBrowseBox, _xFocusWindow, eObjType, rName, rDescription )
 569 {
 570 }
 571
 572
 573 BrowseBoxAccessibleElement::~BrowseBoxAccessibleElement( )
 574 {
 575 }
 576
 577
 578
 579 } // namespace accessibility
 580
 581
 582
 583 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */