svx/source/accessibility/svxrectctaccessiblecontext.cxx

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