svx/source/accessibility/GraphCtlAccessibleContext.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: GraphCtlAccessibleContext.cxx,v $
  10  * $Revision: 1.26 $
  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 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  34 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  35 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  36 #include <com/sun/star/lang/DisposedException.hpp>
  37 #include <com/sun/star/beans/PropertyChangeEvent.hpp>
  38 #include <com/sun/star/awt/XWindow.hpp>
  39 #include <unotools/accessiblestatesethelper.hxx>
  40 #include <cppuhelper/typeprovider.hxx>
  41 #include <toolkit/helper/vclunohelper.hxx>
  42 #include <vcl/svapp.hxx>
  43 #include <osl/mutex.hxx>
  44 #include <rtl/uuid.h>
  45 #include <tools/debug.hxx>
  46 #include <tools/gen.hxx>
  47 #include <svtools/smplhint.hxx>
  48 #include <toolkit/helper/convert.hxx>
  49 #include <svtools/colorcfg.hxx>
  50 #include <comphelper/accessibleeventnotifier.hxx>
  51 #include <sdrpaintwindow.hxx>
  52
  53 //===== local includes ========================================================
  54 #include <svx/ShapeTypeHandler.hxx>
  55 #include <svx/AccessibleShapeInfo.hxx>
  56 #include "GraphCtlAccessibleContext.hxx"
  57 #include <svx/graphctl.hxx>
  58 #ifndef _SVX_DIALOGS_HRC
  59 #include <svx/dialogs.hrc>
  60 #endif
  61 #ifndef _SVX_ACCESSIBILITY_HRC
  62 #include "accessibility.hrc"
  63 #endif
  64 #include <svx/svdpage.hxx>
  65 #include <svx/unomod.hxx>
  66 #include <svx/dialmgr.hxx>
  67 #include <svx/svdetc.hxx>
  68 #include <svx/sdrhittesthelper.hxx>
  69
  70 //=====  namespaces ===========================================================
  71
  72 using namespace ::vos;
  73 using namespace ::cppu;
  74 using namespace ::osl;
  75 using ::rtl::OUString;
  76 using namespace ::accessibility;
  77 using namespace ::com::sun::star;
  78 using namespace ::com::sun::star::uno;
  79 using namespace ::com::sun::star::drawing;
  80 using namespace ::com::sun::star::lang;
  81 using namespace ::com::sun::star::accessibility;
  82
  83 //=====  internal  ============================================================
  84
  85 /** initialize this component and set default values */
  86 SvxGraphCtrlAccessibleContext::SvxGraphCtrlAccessibleContext(
  87     const Reference< XAccessible >&     rxParent,
  88     GraphCtrl&                                                          rRepr,
  89     const OUString*                                                     pName,
  90     const OUString*                                                     pDesc ) :
  91
  92     SvxGraphCtrlAccessibleContext_Base( m_aMutex ),
  93     mxParent( rxParent ),
  94     mpControl( &rRepr ),
  95     mpModel (NULL),
  96     mpPage (NULL),
  97     mpView (NULL),
  98     mnClientId( 0 ),
  99     mbDisposed( sal_False )
 100 {
 101     if (mpControl != NULL)
 102     {
 103         mpModel = mpControl->GetSdrModel();
 104         if (mpModel != NULL)
 105             mpPage = (SdrPage*)mpModel->GetPage( 0 );
 106         mpView = mpControl->GetSdrView();
 107
 108         if( mpModel == NULL || mpPage == NULL || mpView == NULL )
 109         {
 110             mbDisposed = true;
 111             // Set all the pointers to NULL just in case they are used as
 112             // a disposed flag.
 113             mpModel = NULL;
 114             mpPage = NULL;
 115             mpView = NULL;
 116         }
 117     }
 118
 119     if( pName )
 120     {
 121         msName = *pName;
 122     }
 123     else
 124     {
 125         ::vos::OGuard   aSolarGuard( Application::GetSolarMutex() );
 126         msName = SVX_RESSTR( RID_SVXSTR_GRAPHCTRL_ACC_NAME );
 127     }
 128
 129     if( pDesc )
 130     {
 131         msDescription = *pDesc;
 132     }
 133     else
 134     {
 135         ::vos::OGuard   aSolarGuard( Application::GetSolarMutex() );
 136         msDescription = SVX_RESSTR( RID_SVXSTR_GRAPHCTRL_ACC_DESCRIPTION );
 137     }
 138
 139     maTreeInfo.SetSdrView( mpView );
 140     maTreeInfo.SetWindow( mpControl );
 141     maTreeInfo.SetViewForwarder( const_cast<SvxGraphCtrlAccessibleContext*>(this) );
 142 }
 143
 144 //-----------------------------------------------------------------------------
 145
 146 /** on destruction, this component is disposed and all dispose listeners
 147     are called, except if this component was already disposed */
 148 SvxGraphCtrlAccessibleContext::~SvxGraphCtrlAccessibleContext()
 149 {
 150     disposing();
 151 }
 152
 153 //-----------------------------------------------------------------------------
 154
 155 /** returns the XAccessible interface for a given SdrObject.
 156     Multiple calls for the same SdrObject return the same XAccessible.
 157 */
 158 Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessible( const SdrObject* pObj )
 159 {
 160     Reference<XAccessible> xAccessibleShape;
 161
 162     if( pObj )
 163     {
 164         // see if we already created an XAccessible for the given SdrObject
 165         ShapesMapType::iterator iter = mxShapes.find( pObj );
 166
 167         if( iter != mxShapes.end() )
 168         {
 169             // if we already have one, return it
 170             xAccessibleShape = (*iter).second;
 171         }
 172         else
 173         {
 174             // create a new one and remember in our internal map
 175             Reference< XShape > xShape( Reference< XShape >::query( (const_cast<SdrObject*>(pObj))->getUnoShape() ) );
 176
 177             AccessibleShapeInfo aShapeInfo (xShape,mxParent);
 178             // Create accessible object that corresponds to the descriptor's shape.
 179             AccessibleShape* pAcc = ShapeTypeHandler::Instance().CreateAccessibleObject(
 180                 aShapeInfo, maTreeInfo);
 181             xAccessibleShape = pAcc;
 182             if (pAcc != NULL)
 183             {
 184                 pAcc->acquire();
 185                 // Now that we acquired the new accessible shape we can
 186                 // safely call its Init() method.
 187                 pAcc->Init ();
 188             }
 189             mxShapes[pObj] = pAcc;
 190
 191             // Create event and inform listeners of the object creation.
 192             CommitChange( AccessibleEventId::CHILD, makeAny( xAccessibleShape ), makeAny( Reference<XAccessible>() ) );
 193         }
 194     }
 195
 196     return xAccessibleShape;
 197 }
 198
 199 //=====  XAccessible  =========================================================
 200
 201 Reference< XAccessibleContext > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleContext( void ) throw( RuntimeException )
 202 {
 203     return this;
 204 }
 205
 206 //=====  XAccessibleComponent  ================================================
 207
 208 sal_Bool SAL_CALL SvxGraphCtrlAccessibleContext::containsPoint( const awt::Point& rPoint ) throw( RuntimeException )
 209 {
 210     // no guard -> done in getSize()
 211     awt::Size aSize (getSize());
 212     return (rPoint.X >= 0)
 213         && (rPoint.X < aSize.Width)
 214         && (rPoint.Y >= 0)
 215         && (rPoint.Y < aSize.Height);
 216 }
 217
 218 //-----------------------------------------------------------------------------
 219
 220 Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleAtPoint( const awt::Point& rPoint ) throw( RuntimeException )
 221 {
 222     ::osl::MutexGuard   aGuard( m_aMutex );
 223
 224     Reference< XAccessible > xAccessible;
 225
 226     if( mpControl )
 227     {
 228         Point aPnt( rPoint.X, rPoint.Y );
 229         mpControl->PixelToLogic( aPnt );
 230
 231         SdrObject* pObj = 0;
 232
 233         if(mpView && mpView->GetSdrPageView())
 234         {
 235             pObj = SdrObjListPrimitiveHit(*mpPage, aPnt, 1, *mpView->GetSdrPageView(), 0, false);
 236         }
 237
 238         if( pObj )
 239             xAccessible = getAccessible( pObj );
 240     }
 241     else
 242     {
 243         throw DisposedException();
 244     }
 245
 246     return xAccessible;
 247 }
 248
 249 //-----------------------------------------------------------------------------
 250
 251 awt::Rectangle SAL_CALL SvxGraphCtrlAccessibleContext::getBounds() throw( RuntimeException )
 252 {
 253     // no guard -> done in GetBoundingBox()
 254     Rectangle                   aCoreBounds( GetBoundingBox() );
 255     awt::Rectangle              aBounds;
 256     aBounds.X = aCoreBounds.getX();
 257     aBounds.Y = aCoreBounds.getY();
 258     aBounds.Width = aCoreBounds.getWidth();
 259     aBounds.Height = aCoreBounds.getHeight();
 260     return aBounds;
 261 }
 262
 263 //-----------------------------------------------------------------------------
 264
 265 awt::Point SAL_CALL SvxGraphCtrlAccessibleContext::getLocation() throw( RuntimeException )
 266 {
 267     // no guard -> done in GetBoundingBox()
 268     Rectangle   aRect( GetBoundingBox() );
 269     return awt::Point( aRect.getX(), aRect.getY() );
 270 }
 271
 272 //-----------------------------------------------------------------------------
 273
 274 awt::Point SAL_CALL SvxGraphCtrlAccessibleContext::getLocationOnScreen() throw( RuntimeException )
 275 {
 276     // no guard -> done in GetBoundingBoxOnScreen()
 277     Rectangle   aRect( GetBoundingBoxOnScreen() );
 278     return awt::Point( aRect.getX(), aRect.getY() );
 279 }
 280
 281 //-----------------------------------------------------------------------------
 282
 283 awt::Size SAL_CALL SvxGraphCtrlAccessibleContext::getSize() throw( RuntimeException )
 284 {
 285     // no guard -> done in GetBoundingBox()
 286     Rectangle   aRect( GetBoundingBox() );
 287     return awt::Size( aRect.getWidth(), aRect.getHeight() );
 288 }
 289
 290
 291 //=====  XAccessibleContext  ==================================================
 292
 293 sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleChildCount( void ) throw( RuntimeException )
 294 {
 295     OGuard aGuard( Application::GetSolarMutex() );
 296
 297     if( NULL == mpPage )
 298         throw DisposedException();
 299
 300     return mpPage->GetObjCount();
 301 }
 302
 303 //-----------------------------------------------------------------------------
 304
 305 /** returns the SdrObject at index nIndex from the model of this graph */
 306 SdrObject* SvxGraphCtrlAccessibleContext::getSdrObject( sal_Int32 nIndex )
 307     throw( RuntimeException, lang::IndexOutOfBoundsException )
 308 {
 309     OGuard aGuard( Application::GetSolarMutex() );
 310
 311     if( NULL == mpPage )
 312         throw DisposedException();
 313
 314     if( (nIndex < 0) || ( static_cast<sal_uInt32>(nIndex) >= mpPage->GetObjCount() ) )
 315         throw lang::IndexOutOfBoundsException();
 316
 317     return mpPage->GetObj( nIndex );
 318 }
 319
 320 //-----------------------------------------------------------------------------
 321
 322 /** sends an AccessibleEventObject to all added XAccessibleEventListeners */
 323 void SvxGraphCtrlAccessibleContext::CommitChange (
 324     sal_Int16 nEventId,
 325     const uno::Any& rNewValue,
 326     const uno::Any& rOldValue)
 327 {
 328     AccessibleEventObject aEvent (
 329         static_cast<uno::XWeak*>(this),
 330         nEventId,
 331         rNewValue,
 332         rOldValue);
 333
 334     FireEvent (aEvent);
 335 }
 336
 337 /** sends an AccessibleEventObject to all added XAccessibleEventListeners */
 338 void SvxGraphCtrlAccessibleContext::FireEvent (const AccessibleEventObject& aEvent)
 339 {
 340     if (mnClientId)
 341         comphelper::AccessibleEventNotifier::addEvent( mnClientId, aEvent );
 342 }
 343
 344 //-----------------------------------------------------------------------------
 345
 346 Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleChild( sal_Int32 nIndex )
 347     throw( RuntimeException, lang::IndexOutOfBoundsException )
 348 {
 349     OGuard aGuard( Application::GetSolarMutex() );
 350
 351     return getAccessible( getSdrObject( nIndex ) );
 352 }
 353
 354 //-----------------------------------------------------------------------------
 355
 356 Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleParent( void ) throw( RuntimeException )
 357 {
 358     return mxParent;
 359 }
 360
 361 //-----------------------------------------------------------------------------
 362
 363 sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleIndexInParent( void ) throw( RuntimeException )
 364 {
 365     OGuard aGuard( Application::GetSolarMutex() );
 366     //  Use a simple but slow solution for now.  Optimize later.
 367
 368     //  Iterate over all the parent's children and search for this object.
 369     if( mxParent.is() )
 370     {
 371         Reference< XAccessibleContext > xParentContext( mxParent->getAccessibleContext() );
 372         if( xParentContext.is() )
 373         {
 374             sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
 375             for( sal_Int32 i = 0 ; i < nChildCount ; ++i )
 376             {
 377                 Reference< XAccessible > xChild( xParentContext->getAccessibleChild( i ) );
 378                 if( xChild.is() )
 379                 {
 380                     Reference< XAccessibleContext >     xChildContext = xChild->getAccessibleContext();
 381                     if( xChildContext == ( XAccessibleContext* ) this )
 382                         return i;
 383                 }
 384             }
 385         }
 386    }
 387
 388    //   Return -1 to indicate that this object's parent does not know about the
 389    //   object.
 390    return -1;
 391 }
 392
 393 //-----------------------------------------------------------------------------
 394
 395 sal_Int16 SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleRole( void ) throw( RuntimeException )
 396 {
 397     return AccessibleRole::PANEL;
 398 }
 399
 400 //-----------------------------------------------------------------------------
 401
 402 OUString SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleDescription( void ) throw( RuntimeException )
 403 {
 404     OGuard aGuard( Application::GetSolarMutex() );
 405     return msDescription;
 406 }
 407
 408 //-----------------------------------------------------------------------------
 409
 410 OUString SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleName( void ) throw( RuntimeException )
 411 {
 412     OGuard aGuard( Application::GetSolarMutex() );
 413     return msName;
 414 }
 415
 416 //-----------------------------------------------------------------------------
 417
 418 /**     Return empty reference to indicate that the relation set is not
 419     supported.
 420 */
 421 Reference< XAccessibleRelationSet > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleRelationSet( void ) throw( RuntimeException )
 422 {
 423     return Reference< XAccessibleRelationSet >();
 424 }
 425
 426 //-----------------------------------------------------------------------------
 427
 428 Reference< XAccessibleStateSet > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleStateSet( void ) throw( RuntimeException )
 429 {
 430     OGuard aGuard( Application::GetSolarMutex() );
 431
 432     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 433
 434     if ( rBHelper.bDisposed || mbDisposed )
 435     {
 436         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 437     }
 438     else
 439     {
 440         // pStateSetHelper->AddState( AccessibleStateType::ENABLED );
 441         // pStateSetHelper->AddState( AccessibleStateType::SENSITIVE );
 442         pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE );
 443         if( mpControl->HasFocus() )
 444             pStateSetHelper->AddState( AccessibleStateType::FOCUSED );
 445         pStateSetHelper->AddState( AccessibleStateType::OPAQUE );
 446         pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 447         pStateSetHelper->AddState( AccessibleStateType::VISIBLE );
 448     }
 449
 450     return pStateSetHelper;
 451 }
 452
 453 //-----------------------------------------------------------------------------
 454
 455 lang::Locale SAL_CALL SvxGraphCtrlAccessibleContext::getLocale( void ) throw( IllegalAccessibleComponentStateException, RuntimeException )
 456 {
 457     OGuard aGuard( Application::GetSolarMutex() );
 458
 459     if( mxParent.is() )
 460     {
 461         Reference< XAccessibleContext > xParentContext( mxParent->getAccessibleContext() );
 462         if( xParentContext.is() )
 463             return xParentContext->getLocale();
 464     }
 465
 466     //  No parent.  Therefore throw exception to indicate this cluelessness.
 467     throw IllegalAccessibleComponentStateException();
 468 }
 469
 470 //=====  XAccessibleEventListener  ============================================
 471
 472 void SAL_CALL SvxGraphCtrlAccessibleContext::addEventListener( const Reference< XAccessibleEventListener >& xListener )
 473     throw( RuntimeException )
 474 {
 475     if (xListener.is())
 476     {
 477         OGuard aGuard( Application::GetSolarMutex() );
 478         if (!mnClientId)
 479             mnClientId = comphelper::AccessibleEventNotifier::registerClient( );
 480         comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
 481     }
 482 }
 483
 484 //-----------------------------------------------------------------------------
 485
 486 void SAL_CALL SvxGraphCtrlAccessibleContext::removeEventListener( const Reference< XAccessibleEventListener >& xListener )
 487     throw( RuntimeException )
 488 {
 489     if (xListener.is())
 490     {
 491         OGuard aGuard( Application::GetSolarMutex() );
 492
 493         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener );
 494         if ( !nListenerCount )
 495         {
 496             // no listeners anymore
 497             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 498             // and at least to us not firing any events anymore, in case somebody calls
 499             // NotifyAccessibleEvent, again
 500             comphelper::AccessibleEventNotifier::revokeClient( mnClientId );
 501             mnClientId = 0;
 502         }
 503     }
 504 }
 505
 506 //-----------------------------------------------------------------------------
 507
 508 void SAL_CALL SvxGraphCtrlAccessibleContext::addFocusListener( const Reference< awt::XFocusListener >& xListener )
 509     throw( RuntimeException )
 510 {
 511     OGuard aGuard( Application::GetSolarMutex() );
 512
 513     if( xListener.is() )
 514     {
 515         Reference< ::com::sun::star::awt::XWindow >     xWindow( VCLUnoHelper::GetInterface( mpControl ) );
 516         if( xWindow.is() )
 517             xWindow->addFocusListener( xListener );
 518     }
 519 }
 520
 521 //-----------------------------------------------------------------------------
 522
 523 void SAL_CALL SvxGraphCtrlAccessibleContext::removeFocusListener( const Reference< awt::XFocusListener >& xListener )
 524     throw (RuntimeException)
 525 {
 526     OGuard aGuard( Application::GetSolarMutex() );
 527
 528     if( xListener.is() )
 529     {
 530         Reference< ::com::sun::star::awt::XWindow >     xWindow = VCLUnoHelper::GetInterface( mpControl );
 531         if( xWindow.is() )
 532             xWindow->removeFocusListener( xListener );
 533     }
 534 }
 535
 536 //-----------------------------------------------------------------------------
 537
 538 void SAL_CALL SvxGraphCtrlAccessibleContext::grabFocus() throw( RuntimeException )
 539 {
 540     OGuard aGuard( Application::GetSolarMutex() );
 541
 542     if( NULL == mpControl )
 543         throw DisposedException();
 544
 545     mpControl->GrabFocus();
 546 }
 547
 548 //-----------------------------------------------------------------------------
 549
 550 Any SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleKeyBinding() throw( RuntimeException )
 551 {
 552     // here is no implementation, because here are no KeyBindings for every object
 553     return Any();
 554 }
 555
 556
 557
 558
 559
 560 sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getForeground (void)
 561     throw (::com::sun::star::uno::RuntimeException)
 562 {
 563     svtools::ColorConfig aColorConfig;
 564     UINT32 nColor = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor;
 565     return static_cast<sal_Int32>(nColor);
 566 }
 567
 568
 569
 570
 571 sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getBackground (void)
 572     throw (::com::sun::star::uno::RuntimeException)
 573 {
 574     UINT32 nColor = Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor();
 575     return static_cast<sal_Int32>(nColor);
 576 }
 577
 578
 579 //=====  XServiceInfo  ========================================================
 580
 581 OUString SAL_CALL SvxGraphCtrlAccessibleContext::getImplementationName( void ) throw( RuntimeException )
 582 {
 583     return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.ui.SvxGraphCtrlAccessibleContext" ) );
 584 }
 585
 586 //-----------------------------------------------------------------------------
 587
 588 sal_Bool SAL_CALL SvxGraphCtrlAccessibleContext::supportsService( const OUString& sServiceName ) throw( RuntimeException )
 589 {
 590     OGuard aGuard( Application::GetSolarMutex() );
 591     //  Iterate over all supported service names and return true if on of them
 592     //  matches the given name.
 593     Sequence< OUString >        aSupportedServices( getSupportedServiceNames() );
 594     int                                         nLenght = aSupportedServices.getLength();
 595
 596     for( int i = 0 ; i < nLenght ; ++i )
 597     {
 598         if( sServiceName == aSupportedServices[ i ] )
 599             return sal_True;
 600     }
 601
 602     return sal_False;
 603 }
 604
 605 //-----------------------------------------------------------------------------
 606
 607 Sequence< OUString > SAL_CALL SvxGraphCtrlAccessibleContext::getSupportedServiceNames( void ) throw( RuntimeException )
 608 {
 609     Sequence< OUString > aSNs( 3 );
 610
 611     aSNs[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.accessibility.Accessible" ) );
 612     aSNs[1] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.accessibility.AccessibleContext" ) );
 613     aSNs[2] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.AccessibleGraphControl" ) );
 614
 615     return aSNs;
 616 }
 617
 618 //=====  XTypeProvider  =======================================================
 619
 620 Sequence<sal_Int8> SAL_CALL SvxGraphCtrlAccessibleContext::getImplementationId( void ) throw( RuntimeException )
 621 {
 622     OGuard aGuard( Application::GetSolarMutex() );
 623     return getUniqueId();
 624 }
 625
 626 //=====  XServiceName  ========================================================
 627
 628 OUString SvxGraphCtrlAccessibleContext::getServiceName( void ) throw( RuntimeException )
 629 {
 630     return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.accessibility.AccessibleContext" ) );
 631 }
 632
 633 //=====  XAccessibleSelection =============================================
 634
 635 void SAL_CALL SvxGraphCtrlAccessibleContext::selectAccessibleChild( sal_Int32 nIndex ) throw( lang::IndexOutOfBoundsException, RuntimeException )
 636 {
 637     OGuard aGuard( Application::GetSolarMutex() );
 638
 639     if( NULL == mpView )
 640         throw DisposedException();
 641
 642     SdrObject* pObj = getSdrObject( nIndex );
 643
 644     if( pObj )
 645         mpView->MarkObj( pObj, mpView->GetSdrPageView());
 646 }
 647
 648 //-----------------------------------------------------------------------------
 649
 650 sal_Bool SAL_CALL SvxGraphCtrlAccessibleContext::isAccessibleChildSelected( sal_Int32 nIndex ) throw( lang::IndexOutOfBoundsException, RuntimeException )
 651 {
 652     OGuard aGuard( Application::GetSolarMutex() );
 653
 654     if( NULL == mpView )
 655         throw DisposedException();
 656
 657     return mpView->IsObjMarked( getSdrObject( nIndex ) );
 658 }
 659
 660 //-----------------------------------------------------------------------------
 661
 662 void SAL_CALL SvxGraphCtrlAccessibleContext::clearAccessibleSelection() throw( RuntimeException )
 663 {
 664     OGuard aGuard( Application::GetSolarMutex() );
 665
 666     if( NULL == mpView )
 667         throw DisposedException();
 668
 669     mpView->UnmarkAllObj();
 670 }
 671
 672 //-----------------------------------------------------------------------------
 673
 674 void SAL_CALL SvxGraphCtrlAccessibleContext::selectAllAccessibleChildren() throw( RuntimeException )
 675 {
 676     OGuard aGuard( Application::GetSolarMutex() );
 677
 678     if( NULL == mpView )
 679         throw DisposedException();
 680
 681     mpView->MarkAllObj();
 682 }
 683
 684 //-----------------------------------------------------------------------------
 685
 686 sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getSelectedAccessibleChildCount() throw( RuntimeException )
 687 {
 688     OGuard aGuard( Application::GetSolarMutex() );
 689
 690     if( NULL == mpView )
 691         throw DisposedException();
 692
 693     const SdrMarkList& rList = mpView->GetMarkedObjectList();
 694     return rList.GetMarkCount();
 695 }
 696
 697 //-----------------------------------------------------------------------------
 698
 699 Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getSelectedAccessibleChild( sal_Int32 nIndex )
 700     throw( lang::IndexOutOfBoundsException, RuntimeException )
 701 {
 702     OGuard aGuard( Application::GetSolarMutex() );
 703
 704     checkChildIndexOnSelection( nIndex );
 705
 706     Reference< XAccessible > xAccessible;
 707
 708     const SdrMarkList& rList = mpView->GetMarkedObjectList();
 709     SdrObject* pObj = rList.GetMark(nIndex)->GetMarkedSdrObj();
 710     if( pObj )
 711         xAccessible = getAccessible( pObj );
 712
 713     return xAccessible;
 714 }
 715
 716 //-----------------------------------------------------------------------------
 717
 718 void SAL_CALL SvxGraphCtrlAccessibleContext::deselectAccessibleChild( sal_Int32 nIndex ) throw( lang::IndexOutOfBoundsException, RuntimeException )
 719 {
 720     OGuard aGuard( Application::GetSolarMutex() );
 721
 722     checkChildIndexOnSelection( nIndex );
 723
 724     if( mpView )
 725     {
 726         const SdrMarkList& rList = mpView->GetMarkedObjectList();
 727
 728         SdrObject* pObj = getSdrObject( nIndex );
 729         if( pObj )
 730         {
 731             SdrMarkList aRefList( rList );
 732
 733             SdrPageView* pPV = mpView->GetSdrPageView();
 734             mpView->UnmarkAllObj( pPV );
 735
 736             sal_uInt32 nCount = aRefList.GetMarkCount();
 737             sal_uInt32 nMark;
 738             for( nMark = 0; nMark < nCount; nMark++ )
 739             {
 740                 if( aRefList.GetMark(nMark)->GetMarkedSdrObj() != pObj )
 741                     mpView->MarkObj( aRefList.GetMark(nMark)->GetMarkedSdrObj(), pPV );
 742             }
 743         }
 744     }
 745 }
 746
 747 //=====  internals ========================================================
 748
 749 void SvxGraphCtrlAccessibleContext::checkChildIndex( long nIndex ) throw( lang::IndexOutOfBoundsException )
 750 {
 751     if( nIndex < 0 || nIndex >= getAccessibleChildCount() )
 752         throw lang::IndexOutOfBoundsException();
 753 }
 754
 755 //-----------------------------------------------------------------------------
 756
 757 void SvxGraphCtrlAccessibleContext::checkChildIndexOnSelection( long nIndex ) throw( lang::IndexOutOfBoundsException )
 758 {
 759     if( nIndex < 0 || nIndex >= getSelectedAccessibleChildCount() )
 760         throw lang::IndexOutOfBoundsException();
 761 }
 762
 763 //-----------------------------------------------------------------------------
 764
 765 void SvxGraphCtrlAccessibleContext::setName( const OUString& rName )
 766 {
 767     OGuard aGuard( Application::GetSolarMutex() );
 768
 769     msName = rName;
 770 }
 771
 772 //-----------------------------------------------------------------------------
 773
 774 void SvxGraphCtrlAccessibleContext::setDescription( const OUString& rDescr )
 775 {
 776     OGuard aGuard( Application::GetSolarMutex() );
 777
 778     msDescription = rDescr;
 779 }
 780
 781
 782
 783
 784 /** Replace the model, page, and view pointers by the ones provided
 785     (explicitly and implicitly).
 786 */
 787 void SvxGraphCtrlAccessibleContext::setModelAndView (
 788     SdrModel* pModel,
 789     SdrView* pView)
 790 {
 791     OGuard aGuard (Application::GetSolarMutex());
 792
 793     mpModel = pModel;
 794     if (mpModel != NULL)
 795         mpPage = (SdrPage*)mpModel->GetPage( 0 );
 796     mpView = pView;
 797
 798     if (mpModel == NULL || mpPage == NULL || mpView == NULL)
 799     {
 800         mbDisposed = true;
 801
 802         // Set all the pointers to NULL just in case they are used as
 803         // a disposed flag.
 804         mpModel = NULL;
 805         mpPage = NULL;
 806         mpView = NULL;
 807     }
 808
 809     maTreeInfo.SetSdrView (mpView);
 810 }
 811
 812
 813
 814 //-----------------------------------------------------------------------------
 815
 816 void SAL_CALL SvxGraphCtrlAccessibleContext::disposing()
 817 {
 818     OGuard aGuard( Application::GetSolarMutex() );
 819
 820     if( mbDisposed )
 821         return;
 822
 823     mbDisposed = sal_True;
 824
 825     mpControl = NULL;           // object dies with representation
 826     mpView = NULL;
 827     mpPage = NULL;
 828
 829     {
 830         ShapesMapType::iterator I;
 831
 832         for (I=mxShapes.begin(); I!=mxShapes.end(); I++)
 833         {
 834             XAccessible* pAcc = (*I).second;
 835             Reference< XComponent > xComp( pAcc, UNO_QUERY );
 836             if( xComp.is() )
 837                 xComp->dispose();
 838
 839             (*I).second->release();
 840         }
 841
 842         mxShapes.clear();
 843     }
 844
 845     // Send a disposing to all listeners.
 846     if ( mnClientId )
 847     {
 848         comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this );
 849         mnClientId =  0;
 850     }
 851 }
 852
 853 //-----------------------------------------------------------------------------
 854
 855 Rectangle SvxGraphCtrlAccessibleContext::GetBoundingBoxOnScreen( void ) throw( RuntimeException )
 856 {
 857     OGuard aGuard( Application::GetSolarMutex() );
 858
 859     if( NULL == mpControl )
 860         throw DisposedException();
 861
 862     return Rectangle(
 863         mpControl->GetAccessibleParentWindow()->OutputToAbsoluteScreenPixel(
 864             mpControl->GetPosPixel() ),
 865         mpControl->GetSizePixel() );
 866 }
 867
 868 //-----------------------------------------------------------------------------
 869
 870 /** Calculate the relative coordinates of the bounding box as difference
 871     between the absolute coordinates of the bounding boxes of this control
 872     and its parent in the accessibility tree.
 873 */
 874 Rectangle SvxGraphCtrlAccessibleContext::GetBoundingBox( void ) throw( RuntimeException )
 875 {
 876     OGuard aGuard( Application::GetSolarMutex() );
 877
 878     Rectangle aBounds ( 0, 0, 0, 0 );
 879
 880     Window* pWindow = mpControl;
 881     if (pWindow != NULL)
 882     {
 883         aBounds = pWindow->GetWindowExtentsRelative (NULL);
 884         Window* pParent = pWindow->GetAccessibleParentWindow();
 885         if (pParent != NULL)
 886         {
 887             Rectangle aParentRect = pParent->GetWindowExtentsRelative (NULL);
 888             aBounds -= aParentRect.TopLeft();
 889         }
 890     }
 891     else
 892         throw DisposedException();
 893
 894     return aBounds;
 895 }
 896
 897 //-----------------------------------------------------------------------------
 898
 899 Sequence< sal_Int8 > SvxGraphCtrlAccessibleContext::getUniqueId( void )
 900 {
 901     // no guard because it's private -> has to guarded when using it!
 902     static OImplementationId*   pId = 0;
 903     if( !pId )
 904     {
 905         OGuard aGuard( Application::GetSolarMutex() );
 906         if( !pId)
 907         {
 908             static OImplementationId    aId;
 909             pId = &aId;
 910         }
 911     }
 912     return pId->getImplementationId();
 913 }
 914
 915 //-----------------------------------------------------------------------------
 916
 917 void SvxGraphCtrlAccessibleContext::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
 918 {
 919     const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
 920
 921     if( pSdrHint )
 922     {
 923         switch( pSdrHint->GetKind() )
 924         {
 925             case HINT_OBJCHG:
 926                 {
 927                     ShapesMapType::iterator iter = mxShapes.find( pSdrHint->GetObject() );
 928
 929                     if( iter != mxShapes.end() )
 930                     {
 931                         // if we already have one, return it
 932                         AccessibleShape* pShape = (*iter).second;
 933
 934                         if( NULL != pShape )
 935                             pShape->CommitChange( AccessibleEventId::VISIBLE_DATA_CHANGED, uno::Any(), uno::Any() );
 936                     }
 937                 }
 938                 break;
 939
 940             case HINT_OBJINSERTED:
 941                 CommitChange( AccessibleEventId::CHILD, makeAny( getAccessible( pSdrHint->GetObject() ) ) , uno::Any());
 942                 break;
 943             case HINT_OBJREMOVED:
 944                 CommitChange( AccessibleEventId::CHILD, uno::Any(), makeAny( getAccessible( pSdrHint->GetObject() ) )  );
 945                 break;
 946             case HINT_MODELCLEARED:
 947                 dispose();
 948                 break;
 949             default:
 950                 break;
 951         }
 952     }
 953     else
 954     {
 955         const SfxSimpleHint* pSfxHint = PTR_CAST(SfxSimpleHint, &rHint );
 956
 957         // ist unser SdDrawDocument gerade gestorben?
 958         if(pSfxHint && pSfxHint->GetId() == SFX_HINT_DYING)
 959         {
 960             dispose();
 961         }
 962     }
 963 }
 964
 965 //=====  IAccessibleViewforwarder  ========================================
 966
 967 sal_Bool SvxGraphCtrlAccessibleContext::IsValid (void) const
 968 {
 969     return sal_True;
 970 }
 971
 972 //-----------------------------------------------------------------------------
 973
 974 Rectangle SvxGraphCtrlAccessibleContext::GetVisibleArea (void) const
 975 {
 976     Rectangle aVisArea;
 977
 978     if( mpView && mpView->PaintWindowCount())
 979     {
 980         SdrPaintWindow* pPaintWindow = mpView->GetPaintWindow(0L);
 981         aVisArea = pPaintWindow->GetVisibleArea();
 982     }
 983
 984     return aVisArea;
 985 }
 986
 987 //-----------------------------------------------------------------------------
 988
 989 Point SvxGraphCtrlAccessibleContext::LogicToPixel (const Point& rPoint) const
 990 {
 991     if( mpControl )
 992     {
 993         Rectangle aBBox(mpControl->GetWindowExtentsRelative(NULL));
 994         return mpControl->LogicToPixel (rPoint) + aBBox.TopLeft();
 995     }
 996     else
 997     {
 998         return rPoint;
 999     }
1000 }
1001
1002 //-----------------------------------------------------------------------------
1003
1004 Size SvxGraphCtrlAccessibleContext::LogicToPixel (const Size& rSize) const
1005 {
1006     if( mpControl )
1007         return mpControl->LogicToPixel (rSize);
1008     else
1009         return rSize;
1010 }
1011
1012 //-----------------------------------------------------------------------------
1013
1014 Point SvxGraphCtrlAccessibleContext::PixelToLogic (const Point& rPoint) const
1015 {
1016     if( mpControl )
1017         return mpControl->PixelToLogic (rPoint);
1018     else
1019         return rPoint;
1020 }
1021
1022 //-----------------------------------------------------------------------------
1023
1024 Size SvxGraphCtrlAccessibleContext::PixelToLogic (const Size& rSize) const
1025 {
1026     if( mpControl )
1027         return mpControl->PixelToLogic (rSize);
1028     else
1029         return rSize;
1030 }