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