svx/source/accessibility/svxrectctaccessiblecontext.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 "svxrectctaccessiblecontext.hxx"
  21 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  22 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  23 #include <unotools/accessiblestatesethelper.hxx>
  24 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  25 #include <com/sun/star/beans/PropertyChangeEvent.hpp>
  26 #include <com/sun/star/awt/XWindow.hpp>
  27 #include <cppuhelper/typeprovider.hxx>
  28 #include <toolkit/helper/vclunohelper.hxx>
  29 #include <toolkit/helper/convert.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <osl/mutex.hxx>
  32 #include <tools/debug.hxx>
  33 #include <tools/gen.hxx>
  34
  35 #include <svx/dialogs.hrc>
  36 #include "accessibility.hrc"
  37 #include <svx/dlgctrl.hxx>
  38 #include <svx/dialmgr.hxx>
  39 #include <comphelper/accessibleeventnotifier.hxx>
  40
  41
  42 using namespace ::cppu;
  43 using namespace ::osl;
  44 using namespace ::com::sun::star;
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::accessibility;
  47
  48
  49 #define MAX_NUM_OF_CHILDREN   9
  50 #define NOCHILDSELECTED     -1
  51
  52
  53 DBG_NAME( SvxRectCtlAccessibleContext )
  54
  55
  56 //=====  internal  ============================================================
  57
  58 namespace
  59 {
  60     struct ChildIndexToPointData
  61     {
  62         short       nResIdName;
  63         short       nResIdDescr;
  64         RECT_POINT  ePoint;
  65     };
  66 }
  67
  68
  69 static const ChildIndexToPointData* IndexToPoint( long nIndex, bool bAngleControl )
  70 {
  71     DBG_ASSERT( nIndex < ( bAngleControl? 8 : 9 ) && nIndex >= 0, "-IndexToPoint(): invalid child index! You have been warned..." );
  72
  73     // angles are counted reverse counter clock wise
  74     static const ChildIndexToPointData  pAngleData[] =
  75     {                                                   // index
  76         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A000,   RID_SVXSTR_RECTCTL_ACC_CHLD_A000,   RP_RM },    //  0
  77         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A045,   RID_SVXSTR_RECTCTL_ACC_CHLD_A045,   RP_RT },    //  1
  78         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A090,   RID_SVXSTR_RECTCTL_ACC_CHLD_A090,   RP_MT },    //  2
  79         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A135,   RID_SVXSTR_RECTCTL_ACC_CHLD_A135,   RP_LT },    //  3
  80         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A180,   RID_SVXSTR_RECTCTL_ACC_CHLD_A180,   RP_LM },    //  4
  81         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A225,   RID_SVXSTR_RECTCTL_ACC_CHLD_A225,   RP_LB },    //  5
  82         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A270,   RID_SVXSTR_RECTCTL_ACC_CHLD_A270,   RP_MB },    //  6
  83         {   RID_SVXSTR_RECTCTL_ACC_CHLD_A315,   RID_SVXSTR_RECTCTL_ACC_CHLD_A315,   RP_RB }     //  7
  84     };
  85
  86     // corners are counted from left to right and top to bottom
  87     static const ChildIndexToPointData  pCornerData[] =
  88     {                                                                   // index
  89         {   RID_SVXSTR_RECTCTL_ACC_CHLD_LT, RID_SVXSTR_RECTCTL_ACC_CHLD_LT, RP_LT },    //  0
  90         {   RID_SVXSTR_RECTCTL_ACC_CHLD_MT, RID_SVXSTR_RECTCTL_ACC_CHLD_MT, RP_MT },    //  1
  91         {   RID_SVXSTR_RECTCTL_ACC_CHLD_RT, RID_SVXSTR_RECTCTL_ACC_CHLD_RT, RP_RT },    //  2
  92         {   RID_SVXSTR_RECTCTL_ACC_CHLD_LM, RID_SVXSTR_RECTCTL_ACC_CHLD_LM, RP_LM },    //  3
  93         {   RID_SVXSTR_RECTCTL_ACC_CHLD_MM, RID_SVXSTR_RECTCTL_ACC_CHLD_MM, RP_MM },    //  4
  94         {   RID_SVXSTR_RECTCTL_ACC_CHLD_RM, RID_SVXSTR_RECTCTL_ACC_CHLD_RM, RP_RM },    //  5
  95         {   RID_SVXSTR_RECTCTL_ACC_CHLD_LB, RID_SVXSTR_RECTCTL_ACC_CHLD_LB, RP_LB },    //  6
  96         {   RID_SVXSTR_RECTCTL_ACC_CHLD_MB, RID_SVXSTR_RECTCTL_ACC_CHLD_MB, RP_MB },    //  7
  97         {   RID_SVXSTR_RECTCTL_ACC_CHLD_RB, RID_SVXSTR_RECTCTL_ACC_CHLD_RB, RP_RB }     //  8
  98     };
  99
 100     return ( bAngleControl? pAngleData : pCornerData ) + nIndex;
 101 }
 102
 103
 104 static long PointToIndex( RECT_POINT ePoint, bool bAngleControl )
 105 {
 106     long    nRet( (long) ePoint );
 107     if( bAngleControl )
 108     {   // angle control
 109         // angles are counted reverse counter clock wise
 110         switch( ePoint )
 111         {
 112             case RP_LT: nRet = 3;               break;
 113             case RP_MT: nRet = 2;               break;
 114             case RP_RT: nRet = 1;               break;
 115             case RP_LM: nRet = 4;               break;
 116             case RP_MM: nRet = NOCHILDSELECTED; break;
 117             case RP_RM: nRet = 0;               break;
 118             case RP_LB: nRet = 5;               break;
 119             case RP_MB: nRet = 6;               break;
 120             case RP_RB: nRet = 7;               break;
 121         }
 122     }
 123     else
 124     {   // corner control
 125         // corners are counted from left to right and top to bottom
 126         DBG_ASSERT( RP_LT == 0 && RP_MT == 1 && RP_RT == 2 && RP_LM == 3 && RP_MM == 4 && RP_RM == 5 &&
 127                     RP_LB == 6 && RP_MB == 7 && RP_RB == 8, "*PointToIndex(): unexpected enum value!" );
 128
 129         nRet = ( long ) ePoint;
 130     }
 131
 132     return nRet;
 133 }
 134
 135
 136 SvxRectCtlAccessibleContext::SvxRectCtlAccessibleContext(
 137     const Reference< XAccessible >&     rxParent,
 138     SvxRectCtl&                         rRepr,
 139     const OUString*                      pName,
 140     const OUString*                      pDesc ) :
 141
 142     SvxRectCtlAccessibleContext_Base( m_aMutex ),
 143     mxParent( rxParent ),
 144     mpRepr( &rRepr ),
 145     mpChildren( NULL ),
 146     mnClientId( 0 ),
 147     mnSelectedChild( NOCHILDSELECTED ),
 148     mbAngleMode( rRepr.GetNumOfChildren() == 8 )
 149 {
 150     DBG_CTOR( SvxRectCtlAccessibleContext, NULL );
 151
 152     if( pName )
 153         msName = *pName;
 154     else
 155     {
 156         ::SolarMutexGuard aSolarGuard;
 157         msName = SVX_RESSTR( mbAngleMode? RID_SVXSTR_RECTCTL_ACC_ANGL_NAME : RID_SVXSTR_RECTCTL_ACC_CORN_NAME );
 158     }
 159
 160     if( pDesc )
 161         msDescription = *pDesc;
 162     else
 163     {
 164         ::SolarMutexGuard aSolarGuard;
 165         msDescription = SVX_RESSTR( mbAngleMode? RID_SVXSTR_RECTCTL_ACC_ANGL_DESCR : RID_SVXSTR_RECTCTL_ACC_CORN_DESCR );
 166     }
 167
 168     mpChildren = new SvxRectCtlChildAccessibleContext*[ MAX_NUM_OF_CHILDREN ];
 169
 170     SvxRectCtlChildAccessibleContext**  p = mpChildren;
 171     for( int i = MAX_NUM_OF_CHILDREN ; i ; --i, ++p )
 172         *p = NULL;
 173 }
 174
 175
 176 SvxRectCtlAccessibleContext::~SvxRectCtlAccessibleContext()
 177 {
 178     DBG_DTOR( SvxRectCtlAccessibleContext, NULL );
 179
 180     if( IsAlive() )
 181     {
 182         osl_atomic_increment( &m_refCount );
 183         dispose();      // set mpRepr = NULL & release all children
 184     }
 185 }
 186
 187 //=====  XAccessible  =========================================================
 188
 189 Reference< XAccessibleContext > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleContext( void ) throw( RuntimeException )
 190 {
 191     return this;
 192 }
 193
 194 //=====  XAccessibleComponent  ================================================
 195
 196 sal_Bool SAL_CALL SvxRectCtlAccessibleContext::containsPoint( const awt::Point& rPoint ) throw( RuntimeException )
 197 {
 198     // no guard -> done in getBounds()
 199 //  return GetBoundingBox().IsInside( VCLPoint( rPoint ) );
 200     return Rectangle( Point( 0, 0 ), GetBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 201 }
 202
 203 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleAtPoint( const awt::Point& rPoint ) throw( RuntimeException )
 204 {
 205     ::osl::MutexGuard           aGuard( m_aMutex );
 206
 207     ThrowExceptionIfNotAlive();
 208
 209     Reference< XAccessible >    xRet;
 210
 211     long                        nChild = PointToIndex( mpRepr->GetApproxRPFromPixPt( rPoint ), mbAngleMode );
 212
 213     if( nChild != NOCHILDSELECTED )
 214         xRet = getAccessibleChild( nChild );
 215
 216     return xRet;
 217 }
 218
 219 awt::Rectangle SAL_CALL SvxRectCtlAccessibleContext::getBounds() throw( RuntimeException )
 220 {
 221     // no guard -> done in GetBoundingBox()
 222     return AWTRectangle( GetBoundingBox() );
 223 }
 224
 225 awt::Point SAL_CALL SvxRectCtlAccessibleContext::getLocation() throw( RuntimeException )
 226 {
 227     // no guard -> done in GetBoundingBox()
 228     return AWTPoint( GetBoundingBox().TopLeft() );
 229 }
 230
 231 awt::Point SAL_CALL SvxRectCtlAccessibleContext::getLocationOnScreen() throw( RuntimeException )
 232 {
 233     // no guard -> done in GetBoundingBoxOnScreen()
 234     return AWTPoint( GetBoundingBoxOnScreen().TopLeft() );
 235 }
 236
 237 awt::Size SAL_CALL SvxRectCtlAccessibleContext::getSize() throw( RuntimeException )
 238 {
 239     // no guard -> done in GetBoundingBox()
 240     return AWTSize( GetBoundingBox().GetSize() );
 241 }
 242
 243 sal_Bool SAL_CALL SvxRectCtlAccessibleContext::isShowing() throw( RuntimeException )
 244 {
 245     return sal_True;
 246 }
 247
 248 sal_Bool SAL_CALL SvxRectCtlAccessibleContext::isVisible() throw( RuntimeException )
 249 {
 250     ::osl::MutexGuard           aGuard( m_aMutex );
 251
 252     ThrowExceptionIfNotAlive();
 253
 254     return mpRepr->IsVisible();
 255 }
 256
 257 sal_Bool SAL_CALL SvxRectCtlAccessibleContext::isFocusTraversable() throw( RuntimeException )
 258 {
 259     return sal_True;
 260 }
 261
 262 //=====  XAccessibleContext  ==================================================
 263
 264 sal_Int32 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleChildCount( void ) throw( RuntimeException )
 265 {
 266     ::osl::MutexGuard   aGuard( m_aMutex );
 267
 268     ThrowExceptionIfNotAlive();
 269
 270     return mpRepr->GetNumOfChildren();
 271 }
 272
 273 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleChild( sal_Int32 nIndex )
 274     throw( RuntimeException, lang::IndexOutOfBoundsException )
 275 {
 276     checkChildIndex( nIndex );
 277
 278     Reference< XAccessible >    xChild = mpChildren[ nIndex ];
 279     if( !xChild.is() )
 280     {
 281         ::SolarMutexGuard aSolarGuard;
 282
 283         ::osl::MutexGuard   aGuard( m_aMutex );
 284
 285         ThrowExceptionIfNotAlive();
 286
 287         xChild = mpChildren[ nIndex ];
 288
 289         if( !xChild.is() )
 290         {
 291             const ChildIndexToPointData*    p = IndexToPoint( nIndex, mbAngleMode );
 292             OUString aName(SVX_RESSTR(p->nResIdName));
 293             OUString aDescr(SVX_RESSTR(p->nResIdDescr));
 294
 295             Rectangle       aFocusRect( mpRepr->CalculateFocusRectangle( p->ePoint ) );
 296
 297             SvxRectCtlChildAccessibleContext*   pChild = new SvxRectCtlChildAccessibleContext(
 298                                                     this, *mpRepr, aName, aDescr, aFocusRect, nIndex );
 299             xChild = mpChildren[ nIndex ] = pChild;
 300             pChild->acquire();
 301
 302             // set actual state
 303             if( mnSelectedChild == nIndex )
 304                 pChild->setStateChecked( true );
 305         }
 306     }
 307
 308     return xChild;
 309 }
 310
 311 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleParent( void ) throw( RuntimeException )
 312 {
 313     return mxParent;
 314 }
 315
 316 sal_Int32 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleIndexInParent( void ) throw( RuntimeException )
 317 {
 318     ::osl::MutexGuard   aGuard( m_aMutex );
 319     //  Use a simple but slow solution for now.  Optimize later.
 320
 321     //  Iterate over all the parent's children and search for this object.
 322     if( mxParent.is() )
 323     {
 324         Reference< XAccessibleContext >     xParentContext( mxParent->getAccessibleContext() );
 325         if( xParentContext.is() )
 326         {
 327             sal_Int32                       nChildCount = xParentContext->getAccessibleChildCount();
 328             for( sal_Int32 i = 0 ; i < nChildCount ; ++i )
 329             {
 330                 Reference< XAccessible >    xChild( xParentContext->getAccessibleChild( i ) );
 331                 if( xChild.get() == ( XAccessible* ) this )
 332                     return i;
 333             }
 334         }
 335    }
 336
 337    //   Return -1 to indicate that this object's parent does not know about the
 338    //   object.
 339    return -1;
 340 }
 341
 342 sal_Int16 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRole( void ) throw( RuntimeException )
 343 {
 344     return AccessibleRole::PANEL;
 345 }
 346
 347 OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleDescription( void ) throw( RuntimeException )
 348 {
 349     ::osl::MutexGuard   aGuard( m_aMutex );
 350     return msDescription;
 351 }
 352
 353 OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleName( void ) throw( RuntimeException )
 354 {
 355     ::osl::MutexGuard   aGuard( m_aMutex );
 356     return msName;
 357 }
 358
 359 /** Return empty reference to indicate that the relation set is not
 360     supported.
 361 */
 362 Reference< XAccessibleRelationSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRelationSet( void ) throw( RuntimeException )
 363 {
 364     return Reference< XAccessibleRelationSet >();
 365 }
 366
 367 Reference< XAccessibleStateSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleStateSet( void ) throw( RuntimeException )
 368 {
 369     ::osl::MutexGuard                       aGuard( m_aMutex );
 370     utl::AccessibleStateSetHelper*          pStateSetHelper = new utl::AccessibleStateSetHelper;
 371
 372     if( IsAlive() )
 373     {
 374         pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE );
 375         if( mpRepr->HasFocus() )
 376             pStateSetHelper->AddState( AccessibleStateType::FOCUSED );
 377         pStateSetHelper->AddState( AccessibleStateType::OPAQUE );
 378
 379         if( isShowing() )
 380             pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 381
 382         if( isVisible() )
 383             pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
 384     }
 385     else
 386         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 387
 388     return pStateSetHelper;
 389 }
 390
 391 lang::Locale SAL_CALL SvxRectCtlAccessibleContext::getLocale( void ) throw( IllegalAccessibleComponentStateException, RuntimeException )
 392 {
 393     ::osl::MutexGuard                           aGuard( m_aMutex );
 394     if( mxParent.is() )
 395     {
 396         Reference< XAccessibleContext > xParentContext( mxParent->getAccessibleContext() );
 397         if( xParentContext.is() )
 398             return xParentContext->getLocale();
 399     }
 400
 401     //  No parent.  Therefore throw exception to indicate this cluelessness.
 402     throw IllegalAccessibleComponentStateException();
 403 }
 404
 405 void SAL_CALL SvxRectCtlAccessibleContext::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 406     throw( RuntimeException )
 407 {
 408     if (xListener.is())
 409     {
 410         ::osl::MutexGuard   aGuard( m_aMutex );
 411         if (!mnClientId)
 412             mnClientId = comphelper::AccessibleEventNotifier::registerClient( );
 413         comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
 414     }
 415 }
 416
 417 void SAL_CALL SvxRectCtlAccessibleContext::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 418     throw( RuntimeException )
 419 {
 420     if (xListener.is())
 421     {
 422         ::osl::MutexGuard   aGuard( m_aMutex );
 423
 424         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener );
 425         if ( !nListenerCount )
 426         {
 427             // no listeners anymore
 428             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 429             // and at least to us not firing any events anymore, in case somebody calls
 430             // NotifyAccessibleEvent, again
 431             comphelper::AccessibleEventNotifier::revokeClient( mnClientId );
 432             mnClientId = 0;
 433         }
 434     }
 435 }
 436
 437 void SAL_CALL SvxRectCtlAccessibleContext::addFocusListener( const Reference< awt::XFocusListener >& xListener )
 438     throw( RuntimeException )
 439 {
 440     if( xListener.is() )
 441     {
 442         ::osl::MutexGuard   aGuard( m_aMutex );
 443
 444         ThrowExceptionIfNotAlive();
 445
 446         Reference< awt::XWindow >   xWindow = VCLUnoHelper::GetInterface( mpRepr );
 447         if( xWindow.is() )
 448             xWindow->addFocusListener( xListener );
 449     }
 450 }
 451
 452 void SAL_CALL SvxRectCtlAccessibleContext::removeFocusListener( const Reference< awt::XFocusListener >& xListener )
 453     throw (RuntimeException)
 454 {
 455     if( xListener.is() )
 456     {
 457         ::osl::MutexGuard   aGuard( m_aMutex );
 458
 459         ThrowExceptionIfNotAlive();
 460
 461         Reference< awt::XWindow >   xWindow = VCLUnoHelper::GetInterface( mpRepr );
 462         if( xWindow.is() )
 463             xWindow->removeFocusListener( xListener );
 464     }
 465 }
 466
 467 void SAL_CALL SvxRectCtlAccessibleContext::grabFocus() throw( RuntimeException )
 468 {
 469     ::SolarMutexGuard aSolarGuard;
 470     ::osl::MutexGuard   aGuard( m_aMutex );
 471
 472     ThrowExceptionIfNotAlive();
 473
 474     mpRepr->GrabFocus();
 475 }
 476
 477 Any SAL_CALL SvxRectCtlAccessibleContext::getAccessibleKeyBinding() throw( RuntimeException )
 478 {
 479     // here is no implementation, because here are no KeyBindings for every object
 480     return Any();
 481 }
 482
 483 sal_Int32 SvxRectCtlAccessibleContext::getForeground(  )
 484         throw (::com::sun::star::uno::RuntimeException)
 485 {
 486     ::SolarMutexGuard aSolarGuard;
 487     ::osl::MutexGuard   aGuard( m_aMutex );
 488     ThrowExceptionIfNotAlive();
 489
 490     return mpRepr->GetControlForeground().GetColor();
 491 }
 492 sal_Int32 SvxRectCtlAccessibleContext::getBackground(  )
 493         throw (::com::sun::star::uno::RuntimeException)
 494 {
 495     ::SolarMutexGuard aSolarGuard;
 496     ::osl::MutexGuard   aGuard( m_aMutex );
 497     ThrowExceptionIfNotAlive();
 498
 499     return mpRepr->GetControlBackground().GetColor();
 500 }
 501
 502 //=====  XServiceInfo  ========================================================
 503
 504 OUString SAL_CALL SvxRectCtlAccessibleContext::getImplementationName( void ) throw( RuntimeException )
 505 {
 506     return OUString( "com.sun.star.comp.ui.SvxRectCtlAccessibleContext" );
 507 }
 508
 509 sal_Bool SAL_CALL SvxRectCtlAccessibleContext::supportsService( const OUString& sServiceName ) throw( RuntimeException )
 510 {
 511     ::osl::MutexGuard   aGuard( m_aMutex );
 512     //  Iterate over all supported service names and return true if on of them
 513     //  matches the given name.
 514     Sequence< OUString > aSupportedServices( getSupportedServiceNames() );
 515     int                     nLength = aSupportedServices.getLength();
 516     const OUString*          pStr = aSupportedServices.getConstArray();
 517
 518     for( int i = nLength ; i ; --i, ++pStr )
 519     {
 520         if( sServiceName == *pStr )
 521             return sal_True;
 522     }
 523
 524     return sal_False;
 525 }
 526
 527 Sequence< OUString > SAL_CALL SvxRectCtlAccessibleContext::getSupportedServiceNames( void ) throw( RuntimeException )
 528 {
 529     const OUString sServiceName( "com.sun.star.accessibility.AccessibleContext" );
 530     return Sequence< OUString >( &sServiceName, 1 );
 531 }
 532
 533 //=====  XTypeProvider  =======================================================
 534
 535 Sequence< sal_Int8 > SAL_CALL SvxRectCtlAccessibleContext::getImplementationId( void ) throw( RuntimeException )
 536 {
 537     return getUniqueId();
 538 }
 539
 540 //=====  XAccessibleSelection =============================================
 541
 542 void SAL_CALL SvxRectCtlAccessibleContext::selectAccessibleChild( sal_Int32 nIndex ) throw( lang::IndexOutOfBoundsException, RuntimeException )
 543 {
 544     ::SolarMutexGuard aSolarGuard;
 545
 546     ::osl::MutexGuard   aGuard( m_aMutex );
 547
 548     checkChildIndex( nIndex );
 549
 550     ThrowExceptionIfNotAlive();
 551
 552     const ChildIndexToPointData*    pData = IndexToPoint( nIndex, mbAngleMode );
 553
 554     DBG_ASSERT( pData,
 555         "SvxRectCtlAccessibleContext::selectAccessibleChild(): this is an impossible state! Or at least should be..." );
 556
 557     // this does all what is needed, including the change of the child's state!
 558     mpRepr->SetActualRP( pData->ePoint );
 559 }
 560
 561 sal_Bool SAL_CALL SvxRectCtlAccessibleContext::isAccessibleChildSelected( sal_Int32 nIndex ) throw( lang::IndexOutOfBoundsException, RuntimeException )
 562 {
 563     ::osl::MutexGuard   aGuard( m_aMutex );
 564
 565     checkChildIndex( nIndex );
 566
 567     return nIndex == mnSelectedChild;
 568 }
 569
 570 void SAL_CALL SvxRectCtlAccessibleContext::clearAccessibleSelection() throw( RuntimeException )
 571 {
 572     DBG_ASSERT( sal_False, "SvxRectCtlAccessibleContext::clearAccessibleSelection() is not possible!" );
 573 }
 574
 575 void SAL_CALL SvxRectCtlAccessibleContext::selectAllAccessibleChildren() throw( RuntimeException )
 576 {
 577     // guard in selectAccessibleChild()!
 578
 579     selectAccessibleChild( 0 );     // default per definition
 580 }
 581
 582 sal_Int32 SAL_CALL SvxRectCtlAccessibleContext::getSelectedAccessibleChildCount() throw( RuntimeException )
 583 {
 584     ::osl::MutexGuard   aGuard( m_aMutex );
 585
 586     return mnSelectedChild == NOCHILDSELECTED? 0 : 1;
 587 }
 588
 589 Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getSelectedAccessibleChild( sal_Int32 nIndex )
 590     throw( lang::IndexOutOfBoundsException, RuntimeException )
 591 {
 592     ::osl::MutexGuard   aGuard( m_aMutex );
 593
 594     checkChildIndexOnSelection( nIndex );
 595
 596     return getAccessibleChild( mnSelectedChild );
 597 }
 598
 599 void SAL_CALL SvxRectCtlAccessibleContext::deselectAccessibleChild( sal_Int32 /*nIndex*/ ) throw( lang::IndexOutOfBoundsException, RuntimeException )
 600 {
 601     OUString aMessage( "deselectAccessibleChild is not possible in this context" );
 602
 603     DBG_ASSERT( sal_False, "SvxRectCtlAccessibleContext::deselectAccessibleChild() is not possible!" );
 604
 605     throw lang::IndexOutOfBoundsException( aMessage, *this );   // never possible
 606 }
 607
 608 //=====  internals ========================================================
 609
 610 void SvxRectCtlAccessibleContext::checkChildIndex( long nIndex ) throw( lang::IndexOutOfBoundsException )
 611 {
 612     if( nIndex < 0 || nIndex >= getAccessibleChildCount() )
 613         throw lang::IndexOutOfBoundsException();
 614 }
 615
 616 void SvxRectCtlAccessibleContext::checkChildIndexOnSelection( long nIndex ) throw( lang::IndexOutOfBoundsException )
 617 {
 618     if( nIndex || mnSelectedChild == NOCHILDSELECTED )
 619         // in our case only for the first (0) _selected_ child this is a valid request
 620         throw lang::IndexOutOfBoundsException();
 621 }
 622
 623 void SvxRectCtlAccessibleContext::selectChild( long nNew )
 624 {
 625     ::osl::MutexGuard   aGuard( m_aMutex );
 626     if( nNew != mnSelectedChild )
 627     {
 628         long    nNumOfChildren = getAccessibleChildCount();
 629         if( nNew < nNumOfChildren )
 630         {   // valid index
 631             SvxRectCtlChildAccessibleContext*   pChild;
 632             if( mnSelectedChild != NOCHILDSELECTED )
 633             {   // deselect old selected child if one is selected
 634                 pChild = mpChildren[ mnSelectedChild ];
 635                 if( pChild )
 636                     pChild->setStateChecked( false );
 637             }
 638
 639             // select new child
 640             mnSelectedChild = nNew;
 641
 642             if( nNew != NOCHILDSELECTED )
 643             {
 644                 pChild = mpChildren[ nNew ];
 645                 if( pChild )
 646                     pChild->setStateChecked( true );
 647             }
 648         }
 649         else
 650             mnSelectedChild = NOCHILDSELECTED;
 651     }
 652 }
 653
 654 void SvxRectCtlAccessibleContext::selectChild( RECT_POINT eButton )
 655 {
 656     // no guard -> is done in next selectChild
 657     selectChild( PointToIndex( eButton, mbAngleMode ) );
 658 }
 659
 660 void SAL_CALL SvxRectCtlAccessibleContext::disposing()
 661 {
 662     if( !rBHelper.bDisposed )
 663     {
 664         {
 665             ::osl::MutexGuard   aGuard( m_aMutex );
 666             mpRepr = NULL;      // object dies with representation
 667
 668             SvxRectCtlChildAccessibleContext**  p = mpChildren;
 669             for( int i = MAX_NUM_OF_CHILDREN ; i ; --i, ++p )
 670             {
 671                 SvxRectCtlChildAccessibleContext*   pChild = *p;
 672                 if( pChild )
 673                 {
 674                     pChild->dispose();
 675                     pChild->release();
 676                     *p = NULL;
 677                 }
 678             }
 679
 680             delete[] mpChildren;
 681             mpChildren = NULL;
 682         }
 683
 684         {
 685             ::osl::MutexGuard   aGuard( m_aMutex );
 686
 687             // Send a disposing to all listeners.
 688             if ( mnClientId )
 689             {
 690                 comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this );
 691                 mnClientId =  0;
 692             }
 693
 694             mxParent = Reference< XAccessible >();
 695         }
 696     }
 697 }
 698
 699 Rectangle SvxRectCtlAccessibleContext::GetBoundingBoxOnScreen( void ) throw( RuntimeException )
 700 {
 701     ::SolarMutexGuard aSolarGuard;
 702     ::osl::MutexGuard   aGuard( m_aMutex );
 703
 704     ThrowExceptionIfNotAlive();
 705
 706     return Rectangle( mpRepr->GetParent()->OutputToScreenPixel( mpRepr->GetPosPixel() ), mpRepr->GetSizePixel() );
 707 }
 708
 709 Rectangle SvxRectCtlAccessibleContext::GetBoundingBox( void ) throw( RuntimeException )
 710 {
 711     ::SolarMutexGuard aSolarGuard;
 712     ::osl::MutexGuard   aGuard( m_aMutex );
 713
 714     ThrowExceptionIfNotAlive();
 715
 716     return Rectangle( mpRepr->GetPosPixel(), mpRepr->GetSizePixel() );
 717 }
 718
 719 Sequence< sal_Int8 > SvxRectCtlAccessibleContext::getUniqueId( void )
 720 {
 721     static OImplementationId*   pId = 0;
 722     if( !pId )
 723     {
 724         MutexGuard                      aGuard( Mutex::getGlobalMutex() );
 725         if( !pId)
 726         {
 727             static OImplementationId    aId;
 728             pId = &aId;
 729         }
 730     }
 731     return pId->getImplementationId();
 732 }
 733
 734 void SvxRectCtlAccessibleContext::ThrowExceptionIfNotAlive( void ) throw( lang::DisposedException )
 735 {
 736     if( IsNotAlive() )
 737         throw lang::DisposedException();
 738 }
 739
 740 // -------------------------------------------------------------------------------------------------
 741
 742
 743 DBG_NAME( SvxRectCtlChildAccessibleContext )
 744
 745
 746 SvxRectCtlChildAccessibleContext::SvxRectCtlChildAccessibleContext(
 747     const Reference<XAccessible>&   rxParent,
 748     const Window&                       rParentWindow,
 749     const OUString&              rName,
 750     const OUString&              rDescription,
 751     const Rectangle&                    rBoundingBox,
 752     long                                nIndexInParent ) :
 753
 754     SvxRectCtlChildAccessibleContext_Base( maMutex ),
 755     msDescription( rDescription ),
 756     msName( rName ),
 757     mxParent(rxParent),
 758     mpBoundingBox( new Rectangle( rBoundingBox ) ),
 759     mrParentWindow( rParentWindow ),
 760     mnClientId( 0 ),
 761     mnIndexInParent( nIndexInParent ),
 762     mbIsChecked( false )
 763 {
 764     DBG_CTOR( SvxRectCtlChildAccessibleContext, NULL );
 765 }
 766
 767
 768 SvxRectCtlChildAccessibleContext::~SvxRectCtlChildAccessibleContext()
 769 {
 770     DBG_DTOR( SvxRectCtlChildAccessibleContext, NULL );
 771
 772     if( IsAlive() )
 773     {
 774         osl_atomic_increment( &m_refCount );
 775         dispose();      // set mpRepr = NULL & release all children
 776     }
 777 }
 778
 779 //=====  XAccessible  =========================================================
 780
 781 Reference< XAccessibleContext> SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleContext( void ) throw( RuntimeException )
 782 {
 783     return this;
 784 }
 785
 786 //=====  XAccessibleComponent  ================================================
 787
 788 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::containsPoint( const awt::Point& rPoint ) throw( RuntimeException )
 789 {
 790     // no guard -> done in getBounds()
 791     return Rectangle( Point( 0, 0 ), GetBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 792 }
 793
 794 Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleAtPoint( const awt::Point& /*rPoint*/ ) throw( RuntimeException )
 795 {
 796     return Reference< XAccessible >();
 797 }
 798
 799 awt::Rectangle SAL_CALL SvxRectCtlChildAccessibleContext::getBounds() throw( RuntimeException )
 800 {
 801     // no guard -> done in getBoundingBox()
 802     return AWTRectangle( GetBoundingBox() );
 803 }
 804
 805 awt::Point SAL_CALL SvxRectCtlChildAccessibleContext::getLocation() throw( RuntimeException )
 806 {
 807     // no guard -> done in getBoundingBox()
 808     return AWTPoint( GetBoundingBox().TopLeft() );
 809 }
 810
 811 awt::Point SAL_CALL SvxRectCtlChildAccessibleContext::getLocationOnScreen() throw( RuntimeException )
 812 {
 813     // no guard -> done in getBoundingBoxOnScreen()
 814     return AWTPoint( GetBoundingBoxOnScreen().TopLeft() );
 815 }
 816
 817 awt::Size SAL_CALL SvxRectCtlChildAccessibleContext::getSize() throw( RuntimeException )
 818 {
 819     // no guard -> done in getBoundingBox()
 820     return AWTSize( GetBoundingBox().GetSize() );
 821 }
 822
 823 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::isShowing() throw( RuntimeException )
 824 {
 825     return sal_True;
 826 }
 827
 828 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::isVisible() throw( RuntimeException )
 829 {
 830     ::osl::MutexGuard                   aGuard( maMutex );
 831
 832     ThrowExceptionIfNotAlive();
 833
 834     return mxParent.is()? ( static_cast< SvxRectCtlAccessibleContext* >( mxParent.get() ) )->isVisible() : sal_False;
 835 }
 836
 837 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::isFocusTraversable() throw( RuntimeException )
 838 {
 839     return sal_False;
 840 }
 841
 842 void SAL_CALL SvxRectCtlChildAccessibleContext::addFocusListener( const Reference< awt::XFocusListener >& /*xListener*/ )
 843     throw( RuntimeException )
 844 {
 845     OSL_FAIL( "SvxRectCtlChildAccessibleContext::addFocusListener: not implemented" );
 846 }
 847
 848 void SAL_CALL SvxRectCtlChildAccessibleContext::removeFocusListener( const Reference< awt::XFocusListener >& /*xListener*/ )
 849     throw (RuntimeException)
 850 {
 851     OSL_FAIL( "SvxRectCtlChildAccessibleContext::removeFocusListener: not implemented" );
 852 }
 853
 854 void SAL_CALL SvxRectCtlChildAccessibleContext::grabFocus() throw( RuntimeException )
 855 {
 856 }
 857
 858 Any SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleKeyBinding() throw( RuntimeException )
 859 {
 860     // here is no implementation, because here are no KeyBindings for every object
 861     return Any();
 862 }
 863 sal_Int32 SvxRectCtlChildAccessibleContext::getForeground(  )
 864         throw (::com::sun::star::uno::RuntimeException)
 865 {
 866     ::SolarMutexGuard aSolarGuard;
 867     ::osl::MutexGuard   aGuard( maMutex );
 868     ThrowExceptionIfNotAlive();
 869     return mrParentWindow.GetControlForeground().GetColor();
 870 }
 871 sal_Int32 SvxRectCtlChildAccessibleContext::getBackground(  )
 872         throw (::com::sun::star::uno::RuntimeException)
 873 {
 874     ::SolarMutexGuard aSolarGuard;
 875     ::osl::MutexGuard   aGuard( maMutex );
 876
 877     ThrowExceptionIfNotAlive();
 878     return mrParentWindow.GetControlBackground().GetColor();
 879 }
 880
 881 //=====  XAccessibleContext  ==================================================
 882
 883 sal_Int32 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleChildCount( void ) throw( RuntimeException )
 884 {
 885     return 0;
 886 }
 887
 888 Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleChild( sal_Int32 /*nIndex*/ ) throw ( RuntimeException, lang::IndexOutOfBoundsException )
 889 {
 890     throw lang::IndexOutOfBoundsException();
 891 }
 892
 893 Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleParent( void ) throw( RuntimeException )
 894 {
 895     return mxParent;
 896 }
 897
 898 sal_Int32 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleIndexInParent( void ) throw( RuntimeException )
 899 {
 900    return mnIndexInParent;
 901 }
 902
 903 sal_Int16 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRole( void ) throw( RuntimeException )
 904 {
 905     return AccessibleRole::RADIO_BUTTON;
 906 }
 907
 908 OUString SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleDescription( void ) throw( RuntimeException )
 909 {
 910     ::osl::MutexGuard   aGuard( maMutex );
 911     return msDescription;
 912 }
 913
 914 OUString SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleName( void ) throw( RuntimeException )
 915 {
 916     ::osl::MutexGuard   aGuard( maMutex );
 917     return msName;
 918 }
 919
 920 /** Return empty reference to indicate that the relation set is not
 921     supported.
 922 */
 923 Reference<XAccessibleRelationSet> SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRelationSet( void ) throw( RuntimeException )
 924 {
 925     return Reference< XAccessibleRelationSet >();
 926 }
 927
 928 Reference< XAccessibleStateSet > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleStateSet( void ) throw( RuntimeException )
 929 {
 930     ::osl::MutexGuard                       aGuard( maMutex );
 931     utl::AccessibleStateSetHelper*          pStateSetHelper = new utl::AccessibleStateSetHelper;
 932
 933     if( IsAlive() )
 934     {
 935         if( mbIsChecked )
 936         {
 937             pStateSetHelper->AddState( AccessibleStateType::CHECKED );
 938 //          pStateSetHelper->AddState( AccessibleStateType::SELECTED );
 939         }
 940
 941         pStateSetHelper->AddState( AccessibleStateType::ENABLED );
 942         pStateSetHelper->AddState( AccessibleStateType::SENSITIVE );
 943         pStateSetHelper->AddState( AccessibleStateType::OPAQUE );
 944         pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
 945         pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 946         pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
 947     }
 948     else
 949         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 950
 951     return pStateSetHelper;
 952 }
 953
 954 lang::Locale SAL_CALL SvxRectCtlChildAccessibleContext::getLocale( void ) throw( IllegalAccessibleComponentStateException, RuntimeException )
 955 {
 956     ::osl::MutexGuard                       aGuard( maMutex );
 957     if( mxParent.is() )
 958     {
 959         Reference< XAccessibleContext >     xParentContext( mxParent->getAccessibleContext() );
 960         if( xParentContext.is() )
 961             return xParentContext->getLocale();
 962     }
 963
 964     //  No locale and no parent.  Therefore throw exception to indicate this
 965     //  cluelessness.
 966     throw IllegalAccessibleComponentStateException();
 967 }
 968
 969 void SAL_CALL SvxRectCtlChildAccessibleContext::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 970     throw( RuntimeException )
 971 {
 972     if (xListener.is())
 973     {
 974         ::osl::MutexGuard   aGuard( maMutex );
 975         if (!mnClientId)
 976             mnClientId = comphelper::AccessibleEventNotifier::registerClient( );
 977         comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
 978     }
 979 }
 980
 981
 982
 983
 984 void SAL_CALL SvxRectCtlChildAccessibleContext::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 985     throw( RuntimeException )
 986 {
 987     if (xListener.is())
 988     {
 989         ::osl::MutexGuard   aGuard( maMutex );
 990
 991         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener );
 992         if ( !nListenerCount )
 993         {
 994             // no listeners anymore
 995             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 996             // and at least to us not firing any events anymore, in case somebody calls
 997             // NotifyAccessibleEvent, again
 998             comphelper::AccessibleEventNotifier::revokeClient( mnClientId );
 999             mnClientId = 0;
1000         }
1001     }
1002 }
1003
1004 //=====  XAccessibleValue  ================================================
1005
1006 Any SAL_CALL SvxRectCtlChildAccessibleContext::getCurrentValue() throw( RuntimeException )
1007 {
1008     ThrowExceptionIfNotAlive();
1009
1010     Any aRet;
1011     aRet <<= ( mbIsChecked? 1.0 : 0.0 );
1012     return aRet;
1013 }
1014
1015 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::setCurrentValue( const Any& /*aNumber*/ ) throw( RuntimeException )
1016 {
1017     return sal_False;
1018 }
1019
1020 Any SAL_CALL SvxRectCtlChildAccessibleContext::getMaximumValue() throw( RuntimeException )
1021 {
1022     Any aRet;
1023     aRet <<= 1.0;
1024     return aRet;
1025 }
1026
1027 Any SAL_CALL SvxRectCtlChildAccessibleContext::getMinimumValue() throw( RuntimeException )
1028 {
1029     Any aRet;
1030     aRet <<= 0.0;
1031     return aRet;
1032 }
1033
1034 //=====  XServiceInfo  ========================================================
1035
1036 OUString SAL_CALL SvxRectCtlChildAccessibleContext::getImplementationName( void ) throw( RuntimeException )
1037 {
1038     return OUString( "com.sun.star.comp.ui.SvxRectCtlChildAccessibleContext" );
1039 }
1040
1041 sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::supportsService( const OUString& sServiceName ) throw( RuntimeException )
1042 {
1043     //  Iterate over all supported service names and return true if on of them
1044     //  matches the given name.
1045     ::osl::MutexGuard   aGuard( maMutex );
1046     Sequence< OUString > aSupportedServices ( getSupportedServiceNames() );
1047     int                     nLength = aSupportedServices.getLength();
1048     for( int i = 0 ; i < nLength; ++i )
1049     {
1050         if( sServiceName == aSupportedServices[ i ] )
1051             return sal_True;
1052     }
1053
1054     return sal_False;
1055 }
1056
1057 Sequence< OUString > SAL_CALL SvxRectCtlChildAccessibleContext::getSupportedServiceNames( void ) throw( RuntimeException )
1058 {
1059     const OUString sServiceName ("com.sun.star.accessibility.AccessibleContext");
1060     return Sequence< OUString >( &sServiceName, 1 );
1061 }
1062
1063 //=====  XTypeProvider  =======================================================
1064
1065 Sequence< sal_Int8 > SAL_CALL SvxRectCtlChildAccessibleContext::getImplementationId( void ) throw( RuntimeException )
1066 {
1067     static OImplementationId*   pId = 0;
1068     if( !pId )
1069     {
1070         MutexGuard                      aGuard( Mutex::getGlobalMutex() );
1071         if( !pId)
1072         {
1073             static OImplementationId    aId;
1074             pId = &aId;
1075         }
1076     }
1077     return pId->getImplementationId();
1078 }
1079
1080 //=====  internal  ============================================================
1081
1082 void SvxRectCtlChildAccessibleContext::CommitChange( const AccessibleEventObject& rEvent )
1083 {
1084     if (mnClientId)
1085         comphelper::AccessibleEventNotifier::addEvent( mnClientId, rEvent );
1086 }
1087
1088 void SAL_CALL SvxRectCtlChildAccessibleContext::disposing()
1089 {
1090     if( !rBHelper.bDisposed )
1091     {
1092         ::osl::MutexGuard   aGuard( maMutex );
1093
1094         // Send a disposing to all listeners.
1095         if ( mnClientId )
1096         {
1097             comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this );
1098             mnClientId =  0;
1099         }
1100
1101         mxParent = Reference< XAccessible >();
1102
1103         delete mpBoundingBox;
1104     }
1105 }
1106
1107 void SvxRectCtlChildAccessibleContext::ThrowExceptionIfNotAlive( void ) throw( lang::DisposedException )
1108 {
1109     if( IsNotAlive() )
1110         throw lang::DisposedException();
1111 }
1112
1113 Rectangle SvxRectCtlChildAccessibleContext::GetBoundingBoxOnScreen( void ) throw( RuntimeException )
1114 {
1115     ::osl::MutexGuard   aGuard( maMutex );
1116
1117     // no ThrowExceptionIfNotAlive() because its done in GetBoundingBox()
1118     Rectangle           aRect( GetBoundingBox() );
1119
1120     return Rectangle( mrParentWindow.OutputToScreenPixel( aRect.TopLeft() ), aRect.GetSize() );
1121 }
1122
1123 Rectangle SvxRectCtlChildAccessibleContext::GetBoundingBox( void ) throw( RuntimeException )
1124 {
1125     // no guard necessary, because no one changes mpBoundingBox after creating it
1126     ThrowExceptionIfNotAlive();
1127
1128     return *mpBoundingBox;
1129 }
1130
1131 void SvxRectCtlChildAccessibleContext::setStateChecked( bool bChecked )
1132 {
1133     if( mbIsChecked != bChecked )
1134     {
1135         mbIsChecked = bChecked;
1136
1137         const Reference< XInterface >   xSource( *this );
1138
1139         Any                             aOld;
1140         Any                             aNew;
1141         Any&                            rMod = bChecked? aNew : aOld;
1142
1143         rMod <<= AccessibleStateType::CHECKED;
1144
1145         CommitChange( AccessibleEventObject( xSource, AccessibleEventId::STATE_CHANGED, aNew, aOld ) );
1146     }
1147 }
1148
1149 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */