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 )
 122 {
 123     ::osl::MutexGuard aGuard( getOslMutex() );
 124     ensureIsAlive();
 125     return mxParent;
 126 }
 127
 128 sal_Int32 SAL_CALL AccessibleBrowseBoxBase::getAccessibleIndexInParent()
 129     throw ( uno::RuntimeException )
 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 = xChild.query( xParentContext->getAccessibleChild( nChild ) );
 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 )
 166 {
 167     ::osl::MutexGuard aGuard( getOslMutex() );
 168     ensureIsAlive();
 169     return maDescription;
 170 }
 171
 172 OUString SAL_CALL AccessibleBrowseBoxBase::getAccessibleName()
 173     throw ( uno::RuntimeException )
 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 )
 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 )
 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 )
 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 )
 218 {
 219     return Rectangle( Point(), getBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 220 }
 221
 222 awt::Rectangle SAL_CALL AccessibleBrowseBoxBase::getBounds()
 223     throw ( uno::RuntimeException )
 224 {
 225     return AWTRectangle( getBoundingBox() );
 226 }
 227
 228 awt::Point SAL_CALL AccessibleBrowseBoxBase::getLocation()
 229     throw ( uno::RuntimeException )
 230 {
 231     return AWTPoint( getBoundingBox().TopLeft() );
 232 }
 233
 234 awt::Point SAL_CALL AccessibleBrowseBoxBase::getLocationOnScreen()
 235     throw ( uno::RuntimeException )
 236 {
 237     return AWTPoint( getBoundingBoxOnScreen().TopLeft() );
 238 }
 239
 240 awt::Size SAL_CALL AccessibleBrowseBoxBase::getSize()
 241     throw ( uno::RuntimeException )
 242 {
 243     return AWTSize( getBoundingBox().GetSize() );
 244 }
 245
 246 sal_Bool SAL_CALL AccessibleBrowseBoxBase::isShowing()
 247     throw ( uno::RuntimeException )
 248 {
 249     SolarMutexGuard aSolarGuard;
 250     ::osl::MutexGuard aGuard( getOslMutex() );
 251     ensureIsAlive();
 252     return implIsShowing();
 253 }
 254
 255 sal_Bool SAL_CALL AccessibleBrowseBoxBase::isVisible()
 256     throw ( uno::RuntimeException )
 257 {
 258     Reference< XAccessibleStateSet > xStateSet = getAccessibleStateSet();
 259     return xStateSet.is() ?
 260         xStateSet->contains( AccessibleStateType::VISIBLE ) : sal_False;
 261 }
 262
 263 sal_Bool SAL_CALL AccessibleBrowseBoxBase::isFocusTraversable()
 264     throw ( uno::RuntimeException )
 265 {
 266     Reference< XAccessibleStateSet > xStateSet = getAccessibleStateSet();
 267     return xStateSet.is() ?
 268         xStateSet->contains( AccessibleStateType::FOCUSABLE ) : sal_False;
 269 }
 270
 271 void SAL_CALL AccessibleBrowseBoxBase::focusGained( const ::com::sun::star::awt::FocusEvent& ) throw (::com::sun::star::uno::RuntimeException)
 272 {
 273     com::sun::star::uno::Any aFocused;
 274     com::sun::star::uno::Any aEmpty;
 275     aFocused <<= FOCUSED;
 276
 277     commitEvent(AccessibleEventId::STATE_CHANGED,aFocused,aEmpty);
 278 }
 279 // -----------------------------------------------------------------------------
 280
 281 void SAL_CALL AccessibleBrowseBoxBase::focusLost( const ::com::sun::star::awt::FocusEvent& ) throw (::com::sun::star::uno::RuntimeException)
 282 {
 283     com::sun::star::uno::Any aFocused;
 284     com::sun::star::uno::Any aEmpty;
 285     aFocused <<= FOCUSED;
 286
 287     commitEvent(AccessibleEventId::STATE_CHANGED,aEmpty,aFocused);
 288 }
 289 // XAccessibleEventBroadcaster ------------------------------------------------
 290
 291 void SAL_CALL AccessibleBrowseBoxBase::addAccessibleEventListener(
 292         const Reference< XAccessibleEventListener>& _rxListener )
 293     throw ( uno::RuntimeException )
 294 {
 295     if ( _rxListener.is() )
 296     {
 297         ::osl::MutexGuard aGuard( getOslMutex() );
 298         if ( !getClientId( ) )
 299             setClientId( AccessibleEventNotifier::registerClient( ) );
 300
 301         AccessibleEventNotifier::addEventListener( getClientId( ), _rxListener );
 302     }
 303 }
 304
 305 void SAL_CALL AccessibleBrowseBoxBase::removeAccessibleEventListener(
 306         const Reference< XAccessibleEventListener>& _rxListener )
 307     throw ( uno::RuntimeException )
 308 {
 309     if( _rxListener.is() && getClientId( ) )
 310     {
 311         ::osl::MutexGuard aGuard( getOslMutex() );
 312         sal_Int32 nListenerCount = AccessibleEventNotifier::removeEventListener( getClientId( ), _rxListener );
 313         if ( !nListenerCount )
 314         {
 315             // no listeners anymore
 316             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 317             // and at least to us not firing any events anymore, in case somebody calls
 318             // NotifyAccessibleEvent, again
 319
 320             AccessibleEventNotifier::TClientId nId( getClientId( ) );
 321             setClientId( 0 );
 322             AccessibleEventNotifier::revokeClient( nId );
 323         }
 324     }
 325 }
 326
 327 // XTypeProvider --------------------------------------------------------------
 328
 329 namespace
 330 {
 331     class theAccessibleBrowseBoxBaseImplementationId : public rtl::Static< UnoTunnelIdInit, theAccessibleBrowseBoxBaseImplementationId > {};
 332 }
 333
 334 Sequence< sal_Int8 > SAL_CALL AccessibleBrowseBoxBase::getImplementationId()
 335     throw ( uno::RuntimeException )
 336 {
 337     return theAccessibleBrowseBoxBaseImplementationId::get().getSeq();
 338 }
 339
 340 // XServiceInfo ---------------------------------------------------------------
 341
 342 sal_Bool SAL_CALL AccessibleBrowseBoxBase::supportsService(
 343         const OUString& rServiceName )
 344     throw ( uno::RuntimeException )
 345 {
 346     return cppu::supportsService(this, rServiceName);
 347 }
 348
 349 Sequence< OUString > SAL_CALL AccessibleBrowseBoxBase::getSupportedServiceNames()
 350     throw ( uno::RuntimeException )
 351 {
 352     const OUString aServiceName( "com.sun.star.accessibility.AccessibleContext" );
 353     return Sequence< OUString >( &aServiceName, 1 );
 354 }
 355
 356 // other public methods -------------------------------------------------------
 357
 358 void AccessibleBrowseBoxBase::setAccessibleName( const OUString& rName )
 359 {
 360     ::osl::ClearableMutexGuard aGuard( getOslMutex() );
 361     Any aOld;
 362     aOld <<= maName;
 363     maName = rName;
 364
 365     aGuard.clear();
 366
 367     commitEvent(
 368         AccessibleEventId::NAME_CHANGED,
 369         uno::makeAny( maName ),
 370         aOld );
 371 }
 372
 373 void AccessibleBrowseBoxBase::setAccessibleDescription( const OUString& rDescription )
 374 {
 375     ::osl::ClearableMutexGuard aGuard( getOslMutex() );
 376     Any aOld;
 377     aOld <<= maDescription;
 378     maDescription = rDescription;
 379
 380     aGuard.clear();
 381
 382     commitEvent(
 383         AccessibleEventId::DESCRIPTION_CHANGED,
 384         uno::makeAny( maDescription ),
 385         aOld );
 386 }
 387
 388 // internal virtual methods ---------------------------------------------------
 389
 390 sal_Bool AccessibleBrowseBoxBase::implIsShowing()
 391 {
 392     sal_Bool bShowing = sal_False;
 393     if( mxParent.is() )
 394     {
 395         Reference< XAccessibleComponent >
 396             xParentComp( mxParent->getAccessibleContext(), uno::UNO_QUERY );
 397         if( xParentComp.is() )
 398             bShowing = implGetBoundingBox().IsOver(
 399                 VCLRectangle( xParentComp->getBounds() ) );
 400     }
 401     return bShowing;
 402 }
 403
 404 ::utl::AccessibleStateSetHelper* AccessibleBrowseBoxBase::implCreateStateSetHelper()
 405 {
 406     ::utl::AccessibleStateSetHelper*
 407         pStateSetHelper = new ::utl::AccessibleStateSetHelper;
 408
 409     if( isAlive() )
 410     {
 411         // SHOWING done with mxParent
 412         if( implIsShowing() )
 413             pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 414         // BrowseBox fills StateSet with states depending on object type
 415         mpBrowseBox->FillAccessibleStateSet( *pStateSetHelper, getType() );
 416     }
 417     else
 418         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 419
 420     return pStateSetHelper;
 421 }
 422
 423 // internal helper methods ----------------------------------------------------
 424
 425 sal_Bool AccessibleBrowseBoxBase::isAlive() const
 426 {
 427     return !rBHelper.bDisposed && !rBHelper.bInDispose && mpBrowseBox;
 428 }
 429
 430 void AccessibleBrowseBoxBase::ensureIsAlive() const
 431     throw ( lang::DisposedException )
 432 {
 433     if( !isAlive() )
 434         throw lang::DisposedException();
 435 }
 436
 437 Rectangle AccessibleBrowseBoxBase::getBoundingBox()
 438     throw ( lang::DisposedException )
 439 {
 440     SolarMutexGuard aSolarGuard;
 441     ::osl::MutexGuard aGuard( getOslMutex() );
 442     ensureIsAlive();
 443     Rectangle aRect = implGetBoundingBox();
 444     if ( 0 == aRect.Left() && 0 == aRect.Top() && 0 == aRect.Right() && 0 == aRect.Bottom() )
 445     {
 446         SAL_WARN( "accessibility", "rectangle doesn't exist" );
 447     }
 448     return aRect;
 449 }
 450
 451 Rectangle AccessibleBrowseBoxBase::getBoundingBoxOnScreen()
 452     throw ( lang::DisposedException )
 453 {
 454     SolarMutexGuard aSolarGuard;
 455     ::osl::MutexGuard aGuard( getOslMutex() );
 456     ensureIsAlive();
 457     Rectangle aRect = implGetBoundingBoxOnScreen();
 458     if ( 0 == aRect.Left() && 0 == aRect.Top() && 0 == aRect.Right() && 0 == aRect.Bottom() )
 459     {
 460         SAL_WARN( "accessibility", "rectangle doesn't exist" );
 461     }
 462     return aRect;
 463 }
 464
 465 void AccessibleBrowseBoxBase::commitEvent(
 466         sal_Int16 _nEventId, const Any& _rNewValue, const Any& _rOldValue )
 467 {
 468     ::osl::ClearableMutexGuard aGuard( getOslMutex() );
 469     if ( !getClientId( ) )
 470             // if we don't have a client id for the notifier, then we don't have listeners, then
 471             // we don't need to notify anything
 472             return;
 473
 474     // build an event object
 475     AccessibleEventObject aEvent;
 476     aEvent.Source = *this;
 477     aEvent.EventId = _nEventId;
 478     aEvent.OldValue = _rOldValue;
 479     aEvent.NewValue = _rNewValue;
 480
 481     // let the notifier handle this event
 482
 483     AccessibleEventNotifier::addEvent( getClientId( ), aEvent );
 484 }
 485
 486 sal_Int16 SAL_CALL AccessibleBrowseBoxBase::getAccessibleRole()
 487     throw ( uno::RuntimeException )
 488 {
 489     ensureIsAlive();
 490     sal_Int16 nRole = AccessibleRole::UNKNOWN;
 491     switch ( meObjType )
 492     {
 493         case BBTYPE_ROWHEADERCELL:
 494             nRole = AccessibleRole::ROW_HEADER;
 495             break;
 496         case BBTYPE_COLUMNHEADERCELL:
 497             nRole = AccessibleRole::COLUMN_HEADER;
 498             break;
 499         case BBTYPE_COLUMNHEADERBAR:
 500         case BBTYPE_ROWHEADERBAR:
 501         case BBTYPE_TABLE:
 502             nRole = AccessibleRole::TABLE;
 503             break;
 504         case BBTYPE_TABLECELL:
 505             nRole = AccessibleRole::TABLE_CELL;
 506             break;
 507         case BBTYPE_BROWSEBOX:
 508             nRole = AccessibleRole::PANEL;
 509             break;
 510         case BBTYPE_CHECKBOXCELL:
 511             nRole = AccessibleRole::CHECK_BOX;
 512             break;
 513     }
 514     return nRole;
 515 }
 516 // -----------------------------------------------------------------------------
 517 Any SAL_CALL AccessibleBrowseBoxBase::getAccessibleKeyBinding()
 518         throw ( uno::RuntimeException )
 519 {
 520     return Any();
 521 }
 522 // -----------------------------------------------------------------------------
 523 Reference<XAccessible > SAL_CALL AccessibleBrowseBoxBase::getAccessibleAtPoint( const ::com::sun::star::awt::Point& )
 524         throw ( uno::RuntimeException )
 525 {
 526     return NULL;
 527 }
 528 // -----------------------------------------------------------------------------
 529 void SAL_CALL AccessibleBrowseBoxBase::disposing( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException)
 530 {
 531     m_xFocusWindow = NULL;
 532 }
 533 // -----------------------------------------------------------------------------
 534 sal_Int32 SAL_CALL AccessibleBrowseBoxBase::getForeground(  ) throw (::com::sun::star::uno::RuntimeException)
 535 {
 536     SolarMutexGuard aSolarGuard;
 537     ::osl::MutexGuard aGuard( getOslMutex() );
 538     ensureIsAlive();
 539
 540     sal_Int32 nColor = 0;
 541     Window* pInst = mpBrowseBox->GetWindowInstance();
 542     if ( pInst )
 543     {
 544         if ( pInst->IsControlForeground() )
 545             nColor = pInst->GetControlForeground().GetColor();
 546         else
 547         {
 548             Font aFont;
 549             if ( pInst->IsControlFont() )
 550                 aFont = pInst->GetControlFont();
 551             else
 552                 aFont = pInst->GetFont();
 553             nColor = aFont.GetColor().GetColor();
 554         }
 555     }
 556
 557     return nColor;
 558 }
 559 // -----------------------------------------------------------------------------
 560 sal_Int32 SAL_CALL AccessibleBrowseBoxBase::getBackground(  ) throw (::com::sun::star::uno::RuntimeException)
 561 {
 562     SolarMutexGuard aSolarGuard;
 563     ::osl::MutexGuard aGuard( getOslMutex() );
 564     ensureIsAlive();
 565     sal_Int32 nColor = 0;
 566     Window* pInst = mpBrowseBox->GetWindowInstance();
 567     if ( pInst )
 568     {
 569         if ( pInst->IsControlBackground() )
 570             nColor = pInst->GetControlBackground().GetColor();
 571         else
 572             nColor = pInst->GetBackground().GetColor().GetColor();
 573     }
 574
 575     return nColor;
 576 }
 577
 578 // ============================================================================
 579 // XInterface -----------------------------------------------------------------
 580 IMPLEMENT_FORWARD_XINTERFACE2( BrowseBoxAccessibleElement, AccessibleBrowseBoxBase, BrowseBoxAccessibleElement_Base )
 581
 582 // XTypeProvider --------------------------------------------------------------
 583 IMPLEMENT_FORWARD_XTYPEPROVIDER2( BrowseBoxAccessibleElement, AccessibleBrowseBoxBase, BrowseBoxAccessibleElement_Base )
 584
 585 // XAccessible ----------------------------------------------------------------
 586
 587 Reference< XAccessibleContext > SAL_CALL BrowseBoxAccessibleElement::getAccessibleContext() throw ( uno::RuntimeException )
 588 {
 589     ensureIsAlive();
 590     return this;
 591 }
 592
 593 // ----------------------------------------------------------------------------
 594 BrowseBoxAccessibleElement::BrowseBoxAccessibleElement( const Reference< XAccessible >& rxParent, IAccessibleTableProvider& rBrowseBox,
 595         const Reference< awt::XWindow >& _xFocusWindow, AccessibleBrowseBoxObjType  eObjType )
 596     :AccessibleBrowseBoxBase( rxParent, rBrowseBox, _xFocusWindow, eObjType )
 597 {
 598 }
 599
 600 // ----------------------------------------------------------------------------
 601 BrowseBoxAccessibleElement::BrowseBoxAccessibleElement( const Reference< XAccessible >& rxParent, IAccessibleTableProvider& rBrowseBox,
 602         const Reference< awt::XWindow >& _xFocusWindow, AccessibleBrowseBoxObjType  eObjType,
 603         const OUString& rName, const OUString& rDescription )
 604     :AccessibleBrowseBoxBase( rxParent, rBrowseBox, _xFocusWindow, eObjType, rName, rDescription )
 605 {
 606 }
 607
 608 // ----------------------------------------------------------------------------
 609 BrowseBoxAccessibleElement::~BrowseBoxAccessibleElement( )
 610 {
 611 }
 612
 613 // ============================================================================
 614
 615 } // namespace accessibility
 616
 617 // ============================================================================
 618
 619 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */