basctl/source/accessibility/accessibledialogwindow.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: accessibledialogwindow.cxx,v $
  10  * $Revision: 1.10 $
  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_basctl.hxx"
  33 #include <accessibledialogwindow.hxx>
  34 #include <accessibledialogcontrolshape.hxx>
  35 #include <baside3.hxx>
  36 #include <dlged.hxx>
  37 #include <dlgedmod.hxx>
  38 #include <dlgedpage.hxx>
  39 #include <dlgedview.hxx>
  40 #include <dlgedobj.hxx>
  41 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  42 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  43 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  44 #include <unotools/accessiblestatesethelper.hxx>
  45 #include <unotools/accessiblerelationsethelper.hxx>
  46 #include <toolkit/awt/vclxfont.hxx>
  47 #include <toolkit/helper/externallock.hxx>
  48 #include <toolkit/helper/convert.hxx>
  49 #include <vcl/svapp.hxx>
  50
  51 #include <vector>
  52 #include <algorithm>
  53
  54
  55 using namespace ::com::sun::star;
  56 using namespace ::com::sun::star::uno;
  57 using namespace ::com::sun::star::lang;
  58 using namespace ::com::sun::star::accessibility;
  59 using namespace ::comphelper;
  60
  61 DBG_NAME( AccessibleDialogWindow )
  62
  63
  64 // -----------------------------------------------------------------------------
  65 //      class ChildDescriptor
  66 // -----------------------------------------------------------------------------
  67
  68 AccessibleDialogWindow::ChildDescriptor::ChildDescriptor( DlgEdObj* _pDlgEdObj )
  69     :pDlgEdObj( _pDlgEdObj )
  70     ,rxAccessible( 0 )
  71 {
  72 }
  73
  74 // -----------------------------------------------------------------------------
  75
  76 AccessibleDialogWindow::ChildDescriptor::~ChildDescriptor()
  77 {
  78 }
  79
  80 // -----------------------------------------------------------------------------
  81
  82 AccessibleDialogWindow::ChildDescriptor::ChildDescriptor( const ChildDescriptor& rDesc )
  83     :pDlgEdObj( rDesc.pDlgEdObj )
  84     ,rxAccessible( rDesc.rxAccessible )
  85 {
  86 }
  87
  88 // -----------------------------------------------------------------------------
  89
  90 AccessibleDialogWindow::ChildDescriptor& AccessibleDialogWindow::ChildDescriptor::operator=( const ChildDescriptor& rDesc )
  91 {
  92     pDlgEdObj = rDesc.pDlgEdObj;
  93     rxAccessible = rDesc.rxAccessible;
  94
  95     return *this;
  96 }
  97
  98 // -----------------------------------------------------------------------------
  99
 100 bool AccessibleDialogWindow::ChildDescriptor::operator==( const ChildDescriptor& rDesc )
 101 {
 102     bool bRet = false;
 103     if ( pDlgEdObj == rDesc.pDlgEdObj )
 104         bRet = true;
 105
 106     return bRet;
 107 }
 108
 109 // -----------------------------------------------------------------------------
 110
 111 bool AccessibleDialogWindow::ChildDescriptor::operator<( const ChildDescriptor& rDesc ) const
 112 {
 113     bool bRet = false;
 114     if ( pDlgEdObj && rDesc.pDlgEdObj && pDlgEdObj->GetOrdNum() < rDesc.pDlgEdObj->GetOrdNum() )
 115         bRet = true;
 116
 117     return bRet;
 118 }
 119
 120 // -----------------------------------------------------------------------------
 121 //      class AccessibleDialogWindow
 122 // -----------------------------------------------------------------------------
 123
 124 AccessibleDialogWindow::AccessibleDialogWindow( DialogWindow* pDialogWindow )
 125     :AccessibleExtendedComponentHelper_BASE( new VCLExternalSolarLock() )
 126     ,m_pDialogWindow( pDialogWindow )
 127 {
 128     DBG_CTOR( AccessibleDialogWindow, NULL );
 129     m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock() );
 130
 131     if ( m_pDialogWindow )
 132     {
 133         SdrPage* pSdrPage = m_pDialogWindow->GetPage();
 134         if ( pSdrPage )
 135         {
 136             ULONG nCount = pSdrPage->GetObjCount();
 137
 138             for ( ULONG i = 0; i < nCount; ++i )
 139             {
 140                 SdrObject* pObj = pSdrPage->GetObj( i );
 141                 DlgEdObj* pDlgEdObj = PTR_CAST( DlgEdObj, pObj );
 142                 if ( pDlgEdObj )
 143                 {
 144                     ChildDescriptor aDesc( pDlgEdObj );
 145                     if ( IsChildVisible( aDesc ) )
 146                         m_aAccessibleChildren.push_back( aDesc );
 147                 }
 148             }
 149         }
 150
 151         m_pDialogWindow->AddEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
 152
 153         m_pDlgEditor = m_pDialogWindow->GetEditor();
 154         if ( m_pDlgEditor )
 155             StartListening( *m_pDlgEditor );
 156
 157         m_pDlgEdModel = m_pDialogWindow->GetModel();
 158         if ( m_pDlgEdModel )
 159             StartListening( *m_pDlgEdModel );
 160     }
 161 }
 162
 163 // -----------------------------------------------------------------------------
 164
 165 AccessibleDialogWindow::~AccessibleDialogWindow()
 166 {
 167     DBG_DTOR( AccessibleDialogWindow, NULL );
 168     if ( m_pDialogWindow )
 169         m_pDialogWindow->RemoveEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
 170
 171     if ( m_pDlgEditor )
 172         EndListening( *m_pDlgEditor );
 173
 174     if ( m_pDlgEdModel )
 175         EndListening( *m_pDlgEdModel );
 176
 177     delete m_pExternalLock;
 178     m_pExternalLock = NULL;
 179 }
 180
 181 // -----------------------------------------------------------------------------
 182
 183 void AccessibleDialogWindow::UpdateFocused()
 184 {
 185     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 186     {
 187         Reference< XAccessible > xChild( m_aAccessibleChildren[i].rxAccessible );
 188         if ( xChild.is() )
 189         {
 190             AccessibleDialogControlShape* pShape = static_cast< AccessibleDialogControlShape* >( xChild.get() );
 191             if ( pShape )
 192                 pShape->SetFocused( pShape->IsFocused() );
 193         }
 194     }
 195 }
 196
 197 // -----------------------------------------------------------------------------
 198
 199 void AccessibleDialogWindow::UpdateSelected()
 200 {
 201     NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 202
 203     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 204     {
 205         Reference< XAccessible > xChild( m_aAccessibleChildren[i].rxAccessible );
 206         if ( xChild.is() )
 207         {
 208             AccessibleDialogControlShape* pShape = static_cast< AccessibleDialogControlShape* >( xChild.get() );
 209             if ( pShape )
 210                 pShape->SetSelected( pShape->IsSelected() );
 211         }
 212     }
 213 }
 214
 215 // -----------------------------------------------------------------------------
 216
 217 void AccessibleDialogWindow::UpdateBounds()
 218 {
 219     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 220     {
 221         Reference< XAccessible > xChild( m_aAccessibleChildren[i].rxAccessible );
 222         if ( xChild.is() )
 223         {
 224             AccessibleDialogControlShape* pShape = static_cast< AccessibleDialogControlShape* >( xChild.get() );
 225             if ( pShape )
 226                 pShape->SetBounds( pShape->GetBounds() );
 227         }
 228     }
 229 }
 230
 231 // -----------------------------------------------------------------------------
 232
 233 sal_Bool AccessibleDialogWindow::IsChildVisible( const ChildDescriptor& rDesc )
 234 {
 235     sal_Bool bVisible = sal_False;
 236
 237     if ( m_pDialogWindow )
 238     {
 239         // first check, if the shape is in a visible layer
 240         SdrModel* pSdrModel = m_pDialogWindow->GetModel();
 241         if ( pSdrModel )
 242         {
 243             SdrLayerAdmin& rLayerAdmin = pSdrModel->GetLayerAdmin();
 244             DlgEdObj* pDlgEdObj = rDesc.pDlgEdObj;
 245             if ( pDlgEdObj )
 246             {
 247                 SdrLayerID nLayerId = pDlgEdObj->GetLayer();
 248                 const SdrLayer* pSdrLayer = rLayerAdmin.GetLayerPerID( nLayerId );
 249                 if ( pSdrLayer )
 250                 {
 251                     String aLayerName = pSdrLayer->GetName();
 252                     SdrView* pSdrView = m_pDialogWindow->GetView();
 253                     if ( pSdrView && pSdrView->IsLayerVisible( aLayerName ) )
 254                     {
 255                         // get the bounding box of the shape in logic units
 256                         Rectangle aRect = pDlgEdObj->GetSnapRect();
 257
 258                         // transform coordinates relative to the parent
 259                         MapMode aMap = m_pDialogWindow->GetMapMode();
 260                         Point aOrg = aMap.GetOrigin();
 261                         aRect.Move( aOrg.X(), aOrg.Y() );
 262
 263                         // convert logic units to pixel
 264                         aRect = m_pDialogWindow->LogicToPixel( aRect, MapMode(MAP_100TH_MM) );
 265
 266                         // check, if the shape's bounding box intersects with the bounding box of its parent
 267                         Rectangle aParentRect( Point( 0, 0 ), m_pDialogWindow->GetSizePixel() );
 268                         if ( aParentRect.IsOver( aRect ) )
 269                             bVisible = sal_True;
 270                     }
 271                 }
 272             }
 273         }
 274     }
 275
 276     return bVisible;
 277 }
 278
 279 // -----------------------------------------------------------------------------
 280
 281 void AccessibleDialogWindow::InsertChild( const ChildDescriptor& rDesc )
 282 {
 283     // check, if object is already in child list
 284     AccessibleChildren::iterator aIter = ::std::find( m_aAccessibleChildren.begin(), m_aAccessibleChildren.end(), rDesc );
 285
 286     // if not found, insert in child list
 287     if ( aIter == m_aAccessibleChildren.end() )
 288     {
 289         // insert entry in child list
 290         m_aAccessibleChildren.push_back( rDesc );
 291
 292         // get the accessible of the inserted child
 293         Reference< XAccessible > xChild( getAccessibleChild( m_aAccessibleChildren.size() - 1 ) );
 294
 295         // sort child list
 296         SortChildren();
 297
 298         // send accessible child event
 299         if ( xChild.is() )
 300         {
 301             Any aOldValue, aNewValue;
 302             aNewValue <<= xChild;
 303             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 304         }
 305     }
 306 }
 307
 308 // -----------------------------------------------------------------------------
 309
 310 void AccessibleDialogWindow::RemoveChild( const ChildDescriptor& rDesc )
 311 {
 312     // find object in child list
 313     AccessibleChildren::iterator aIter = ::std::find( m_aAccessibleChildren.begin(), m_aAccessibleChildren.end(), rDesc );
 314
 315     // if found, remove from child list
 316     if ( aIter != m_aAccessibleChildren.end() )
 317     {
 318         // get the accessible of the removed child
 319         Reference< XAccessible > xChild( aIter->rxAccessible );
 320
 321         // remove entry from child list
 322         m_aAccessibleChildren.erase( aIter );
 323
 324         // send accessible child event
 325         if ( xChild.is() )
 326         {
 327             Any aOldValue, aNewValue;
 328             aOldValue <<= xChild;
 329             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 330
 331             Reference< XComponent > xComponent( xChild, UNO_QUERY );
 332             if ( xComponent.is() )
 333                 xComponent->dispose();
 334         }
 335     }
 336 }
 337
 338 // -----------------------------------------------------------------------------
 339
 340 void AccessibleDialogWindow::UpdateChild( const ChildDescriptor& rDesc )
 341 {
 342     if ( IsChildVisible( rDesc ) )
 343     {
 344         // if the object is not in the child list, insert child
 345         InsertChild( rDesc );
 346     }
 347     else
 348     {
 349         // if the object is in the child list, remove child
 350         RemoveChild( rDesc );
 351     }
 352 }
 353
 354 // -----------------------------------------------------------------------------
 355
 356 void AccessibleDialogWindow::UpdateChildren()
 357 {
 358     if ( m_pDialogWindow )
 359     {
 360         SdrPage* pSdrPage = m_pDialogWindow->GetPage();
 361         if ( pSdrPage )
 362         {
 363             for ( ULONG i = 0, nCount = pSdrPage->GetObjCount(); i < nCount; ++i )
 364             {
 365                 SdrObject* pObj = pSdrPage->GetObj( i );
 366                 DlgEdObj* pDlgEdObj = PTR_CAST( DlgEdObj, pObj );
 367                 if ( pDlgEdObj )
 368                     UpdateChild( ChildDescriptor( pDlgEdObj ) );
 369             }
 370         }
 371     }
 372 }
 373
 374 // -----------------------------------------------------------------------------
 375
 376 void AccessibleDialogWindow::SortChildren()
 377 {
 378     // sort child list
 379     ::std::sort( m_aAccessibleChildren.begin(), m_aAccessibleChildren.end() );
 380 }
 381
 382 // -----------------------------------------------------------------------------
 383
 384 IMPL_LINK( AccessibleDialogWindow, WindowEventListener, VclSimpleEvent*, pEvent )
 385 {
 386     DBG_CHKTHIS( AccessibleDialogWindow, 0 );
 387     DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "AccessibleDialogWindow::WindowEventListener: unknown window event!" );
 388
 389     if ( pEvent && pEvent->ISA( VclWindowEvent ) )
 390     {
 391         DBG_ASSERT( ((VclWindowEvent*)pEvent)->GetWindow(), "AccessibleDialogWindow::WindowEventListener: no window!" );
 392         if ( !((VclWindowEvent*)pEvent)->GetWindow()->IsAccessibilityEventsSuppressed() || ( pEvent->GetId() == VCLEVENT_OBJECT_DYING ) )
 393         {
 394             ProcessWindowEvent( *(VclWindowEvent*)pEvent );
 395         }
 396     }
 397
 398     return 0;
 399 }
 400
 401 // -----------------------------------------------------------------------------
 402
 403 void AccessibleDialogWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 404 {
 405     Any aOldValue, aNewValue;
 406
 407     switch ( rVclWindowEvent.GetId() )
 408     {
 409         case VCLEVENT_WINDOW_ENABLED:
 410         {
 411             aNewValue <<= AccessibleStateType::ENABLED;
 412             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 413         }
 414         break;
 415         case VCLEVENT_WINDOW_DISABLED:
 416         {
 417             aOldValue <<= AccessibleStateType::ENABLED;
 418             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 419         }
 420         break;
 421         case VCLEVENT_WINDOW_ACTIVATE:
 422         {
 423             aNewValue <<= AccessibleStateType::ACTIVE;
 424             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 425         }
 426         break;
 427         case VCLEVENT_WINDOW_DEACTIVATE:
 428         {
 429             aOldValue <<= AccessibleStateType::ACTIVE;
 430             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 431         }
 432         break;
 433         case VCLEVENT_WINDOW_GETFOCUS:
 434         {
 435             aNewValue <<= AccessibleStateType::FOCUSED;
 436             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 437         }
 438         break;
 439         case VCLEVENT_WINDOW_LOSEFOCUS:
 440         {
 441             aOldValue <<= AccessibleStateType::FOCUSED;
 442             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 443         }
 444         break;
 445         case VCLEVENT_WINDOW_SHOW:
 446         {
 447             aNewValue <<= AccessibleStateType::SHOWING;
 448             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 449         }
 450         break;
 451         case VCLEVENT_WINDOW_HIDE:
 452         {
 453             aOldValue <<= AccessibleStateType::SHOWING;
 454             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 455         }
 456         break;
 457         case VCLEVENT_WINDOW_RESIZE:
 458         {
 459             NotifyAccessibleEvent( AccessibleEventId::BOUNDRECT_CHANGED, aOldValue, aNewValue );
 460             UpdateChildren();
 461             UpdateBounds();
 462         }
 463         break;
 464         case VCLEVENT_OBJECT_DYING:
 465         {
 466             if ( m_pDialogWindow )
 467             {
 468                 m_pDialogWindow->RemoveEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
 469                 m_pDialogWindow = NULL;
 470
 471                 if ( m_pDlgEditor )
 472                     EndListening( *m_pDlgEditor );
 473                 m_pDlgEditor = NULL;
 474
 475                 if ( m_pDlgEdModel )
 476                     EndListening( *m_pDlgEdModel );
 477                 m_pDlgEdModel = NULL;
 478
 479                 // dispose all children
 480                 for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 481                 {
 482                     Reference< XComponent > xComponent( m_aAccessibleChildren[i].rxAccessible, UNO_QUERY );
 483                     if ( xComponent.is() )
 484                         xComponent->dispose();
 485                 }
 486                 m_aAccessibleChildren.clear();
 487             }
 488         }
 489         break;
 490         default:
 491         {
 492         }
 493         break;
 494     }
 495 }
 496
 497 // -----------------------------------------------------------------------------
 498
 499 void AccessibleDialogWindow::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 500 {
 501     if ( m_pDialogWindow )
 502     {
 503         if ( m_pDialogWindow->IsEnabled() )
 504             rStateSet.AddState( AccessibleStateType::ENABLED );
 505
 506         rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 507
 508         if ( m_pDialogWindow->HasFocus() )
 509             rStateSet.AddState( AccessibleStateType::FOCUSED );
 510
 511         rStateSet.AddState( AccessibleStateType::VISIBLE );
 512
 513         if ( m_pDialogWindow->IsVisible() )
 514             rStateSet.AddState( AccessibleStateType::SHOWING );
 515
 516         rStateSet.AddState( AccessibleStateType::OPAQUE );
 517
 518         rStateSet.AddState( AccessibleStateType::RESIZABLE );
 519     }
 520 }
 521
 522 // -----------------------------------------------------------------------------
 523 // OCommonAccessibleComponent
 524 // -----------------------------------------------------------------------------
 525
 526 awt::Rectangle AccessibleDialogWindow::implGetBounds() throw (RuntimeException)
 527 {
 528     awt::Rectangle aBounds;
 529     if ( m_pDialogWindow )
 530         aBounds = AWTRectangle( Rectangle( m_pDialogWindow->GetPosPixel(), m_pDialogWindow->GetSizePixel() ) );
 531
 532     return aBounds;
 533 }
 534
 535 // -----------------------------------------------------------------------------
 536 // SfxListener
 537 // -----------------------------------------------------------------------------
 538
 539 void AccessibleDialogWindow::Notify( SfxBroadcaster&, const SfxHint& rHint )
 540 {
 541     if ( rHint.ISA( SdrHint ) )
 542     {
 543         SdrHint* pSdrHint = (SdrHint*)&rHint;
 544         switch ( pSdrHint->GetKind() )
 545         {
 546             case HINT_OBJINSERTED:
 547             {
 548                 SdrObject* pObj = (SdrObject*)pSdrHint->GetObject();
 549                 DlgEdObj* pDlgEdObj = PTR_CAST( DlgEdObj, pObj );
 550                 if ( pDlgEdObj )
 551                 {
 552                     ChildDescriptor aDesc( pDlgEdObj );
 553                     if ( IsChildVisible( aDesc ) )
 554                         InsertChild( aDesc );
 555                 }
 556             }
 557             break;
 558             case HINT_OBJREMOVED:
 559             {
 560                 SdrObject* pObj = (SdrObject*)pSdrHint->GetObject();
 561                 DlgEdObj* pDlgEdObj = PTR_CAST( DlgEdObj, pObj );
 562                 if ( pDlgEdObj )
 563                     RemoveChild( ChildDescriptor( pDlgEdObj ) );
 564             }
 565             break;
 566             default: ;
 567         }
 568     }
 569     else if ( rHint.ISA( DlgEdHint ) )
 570     {
 571         DlgEdHint* pDlgEdHint = (DlgEdHint*)&rHint;
 572         switch ( pDlgEdHint->GetKind() )
 573         {
 574             case DLGED_HINT_WINDOWSCROLLED:
 575             {
 576                 UpdateChildren();
 577                 UpdateBounds();
 578             }
 579             break;
 580             case DLGED_HINT_LAYERCHANGED:
 581             {
 582                 DlgEdObj* pDlgEdObj = pDlgEdHint->GetObject();
 583                 if ( pDlgEdObj )
 584                     UpdateChild( ChildDescriptor( pDlgEdObj ) );
 585             }
 586             break;
 587             case DLGED_HINT_OBJORDERCHANGED:
 588             {
 589                 SortChildren();
 590             }
 591             break;
 592             case DLGED_HINT_SELECTIONCHANGED:
 593             {
 594                 UpdateFocused();
 595                 UpdateSelected();
 596             }
 597             break;
 598             default: ;
 599         }
 600     }
 601 }
 602
 603 // -----------------------------------------------------------------------------
 604 // XInterface
 605 // -----------------------------------------------------------------------------
 606
 607 IMPLEMENT_FORWARD_XINTERFACE2( AccessibleDialogWindow, AccessibleExtendedComponentHelper_BASE, AccessibleDialogWindow_BASE )
 608
 609 // -----------------------------------------------------------------------------
 610 // XTypeProvider
 611 // -----------------------------------------------------------------------------
 612
 613 IMPLEMENT_FORWARD_XTYPEPROVIDER2( AccessibleDialogWindow, AccessibleExtendedComponentHelper_BASE, AccessibleDialogWindow_BASE )
 614
 615 // -----------------------------------------------------------------------------
 616 // XComponent
 617 // -----------------------------------------------------------------------------
 618
 619 void AccessibleDialogWindow::disposing()
 620 {
 621     AccessibleExtendedComponentHelper_BASE::disposing();
 622
 623     if ( m_pDialogWindow )
 624     {
 625         m_pDialogWindow->RemoveEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
 626         m_pDialogWindow = NULL;
 627
 628         if ( m_pDlgEditor )
 629             EndListening( *m_pDlgEditor );
 630         m_pDlgEditor = NULL;
 631
 632         if ( m_pDlgEdModel )
 633             EndListening( *m_pDlgEdModel );
 634         m_pDlgEdModel = NULL;
 635
 636         // dispose all children
 637         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 638         {
 639             Reference< XComponent > xComponent( m_aAccessibleChildren[i].rxAccessible, UNO_QUERY );
 640             if ( xComponent.is() )
 641                 xComponent->dispose();
 642         }
 643         m_aAccessibleChildren.clear();
 644     }
 645 }
 646
 647 // -----------------------------------------------------------------------------
 648 // XServiceInfo
 649 // -----------------------------------------------------------------------------
 650
 651 ::rtl::OUString AccessibleDialogWindow::getImplementationName() throw (RuntimeException)
 652 {
 653     return ::rtl::OUString::createFromAscii( "com.sun.star.comp.basctl.AccessibleWindow" );
 654 }
 655
 656 // -----------------------------------------------------------------------------
 657
 658 sal_Bool AccessibleDialogWindow::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException)
 659 {
 660     Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() );
 661     const ::rtl::OUString* pNames = aNames.getConstArray();
 662     const ::rtl::OUString* pEnd = pNames + aNames.getLength();
 663     for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
 664         ;
 665
 666     return pNames != pEnd;
 667 }
 668
 669 // -----------------------------------------------------------------------------
 670
 671 Sequence< ::rtl::OUString > AccessibleDialogWindow::getSupportedServiceNames() throw (RuntimeException)
 672 {
 673     Sequence< ::rtl::OUString > aNames(1);
 674     aNames[0] = ::rtl::OUString::createFromAscii( "com.sun.star.awt.AccessibleWindow" );
 675     return aNames;
 676 }
 677
 678 // -----------------------------------------------------------------------------
 679 // XAccessible
 680 // -----------------------------------------------------------------------------
 681
 682 Reference< XAccessibleContext > AccessibleDialogWindow::getAccessibleContext(  ) throw (RuntimeException)
 683 {
 684     OExternalLockGuard aGuard( this );
 685
 686     return this;
 687 }
 688
 689 // -----------------------------------------------------------------------------
 690 // XAccessibleContext
 691 // -----------------------------------------------------------------------------
 692
 693 sal_Int32 AccessibleDialogWindow::getAccessibleChildCount() throw (RuntimeException)
 694 {
 695     OExternalLockGuard aGuard( this );
 696
 697     return m_aAccessibleChildren.size();
 698 }
 699
 700 // -----------------------------------------------------------------------------
 701
 702 Reference< XAccessible > AccessibleDialogWindow::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 703 {
 704     OExternalLockGuard aGuard( this );
 705
 706     if ( i < 0 || i >= getAccessibleChildCount() )
 707         throw IndexOutOfBoundsException();
 708
 709     Reference< XAccessible > xChild = m_aAccessibleChildren[i].rxAccessible;
 710     if ( !xChild.is() )
 711     {
 712         if ( m_pDialogWindow )
 713         {
 714             DlgEdObj* pDlgEdObj = m_aAccessibleChildren[i].pDlgEdObj;
 715             if ( pDlgEdObj )
 716             {
 717                 xChild = new AccessibleDialogControlShape( m_pDialogWindow, pDlgEdObj );
 718
 719                 // insert into child list
 720                 m_aAccessibleChildren[i].rxAccessible = xChild;
 721             }
 722         }
 723     }
 724
 725     return xChild;
 726 }
 727
 728 // -----------------------------------------------------------------------------
 729
 730 Reference< XAccessible > AccessibleDialogWindow::getAccessibleParent(  ) throw (RuntimeException)
 731 {
 732     OExternalLockGuard aGuard( this );
 733
 734     Reference< XAccessible > xParent;
 735     if ( m_pDialogWindow )
 736     {
 737         Window* pParent = m_pDialogWindow->GetAccessibleParentWindow();
 738         if ( pParent )
 739             xParent = pParent->GetAccessible();
 740     }
 741
 742     return xParent;
 743 }
 744
 745 // -----------------------------------------------------------------------------
 746
 747 sal_Int32 AccessibleDialogWindow::getAccessibleIndexInParent(  ) throw (RuntimeException)
 748 {
 749     OExternalLockGuard aGuard( this );
 750
 751     sal_Int32 nIndexInParent = -1;
 752     if ( m_pDialogWindow )
 753     {
 754         Window* pParent = m_pDialogWindow->GetAccessibleParentWindow();
 755         if ( pParent )
 756         {
 757             for ( USHORT i = 0, nCount = pParent->GetAccessibleChildWindowCount(); i < nCount; ++i )
 758             {
 759                 Window* pChild = pParent->GetAccessibleChildWindow( i );
 760                 if ( pChild == static_cast< Window* >( m_pDialogWindow ) )
 761                 {
 762                     nIndexInParent = i;
 763                     break;
 764                 }
 765             }
 766         }
 767     }
 768
 769     return nIndexInParent;
 770 }
 771
 772 // -----------------------------------------------------------------------------
 773
 774 sal_Int16 AccessibleDialogWindow::getAccessibleRole(  ) throw (RuntimeException)
 775 {
 776     OExternalLockGuard aGuard( this );
 777
 778     return AccessibleRole::PANEL;
 779 }
 780
 781 // -----------------------------------------------------------------------------
 782
 783 ::rtl::OUString AccessibleDialogWindow::getAccessibleDescription(       ) throw (RuntimeException)
 784 {
 785     OExternalLockGuard aGuard( this );
 786
 787     ::rtl::OUString sDescription;
 788     if ( m_pDialogWindow )
 789         sDescription = m_pDialogWindow->GetAccessibleDescription();
 790
 791     return sDescription;
 792 }
 793
 794 // -----------------------------------------------------------------------------
 795
 796 ::rtl::OUString AccessibleDialogWindow::getAccessibleName(  ) throw (RuntimeException)
 797 {
 798     OExternalLockGuard aGuard( this );
 799
 800     ::rtl::OUString sName;
 801     if ( m_pDialogWindow )
 802         sName = m_pDialogWindow->GetAccessibleName();
 803
 804     return sName;
 805 }
 806
 807 // -----------------------------------------------------------------------------
 808
 809 Reference< XAccessibleRelationSet > AccessibleDialogWindow::getAccessibleRelationSet(  ) throw (RuntimeException)
 810 {
 811     OExternalLockGuard aGuard( this );
 812
 813     utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 814     Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
 815     return xSet;
 816 }
 817
 818 // -----------------------------------------------------------------------------
 819
 820 Reference< XAccessibleStateSet > AccessibleDialogWindow::getAccessibleStateSet(  ) throw (RuntimeException)
 821 {
 822     OExternalLockGuard aGuard( this );
 823
 824     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 825     Reference< XAccessibleStateSet > xSet = pStateSetHelper;
 826
 827     if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 828     {
 829         FillAccessibleStateSet( *pStateSetHelper );
 830     }
 831     else
 832     {
 833         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 834     }
 835
 836     return xSet;
 837 }
 838
 839 // -----------------------------------------------------------------------------
 840
 841 Locale AccessibleDialogWindow::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 842 {
 843     OExternalLockGuard aGuard( this );
 844
 845     return Application::GetSettings().GetLocale();
 846 }
 847
 848 // -----------------------------------------------------------------------------
 849 // XAccessibleComponent
 850 // -----------------------------------------------------------------------------
 851
 852 Reference< XAccessible > AccessibleDialogWindow::getAccessibleAtPoint( const awt::Point& rPoint ) throw (RuntimeException)
 853 {
 854     OExternalLockGuard aGuard( this );
 855
 856     Reference< XAccessible > xChild;
 857     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 858     {
 859         Reference< XAccessible > xAcc = getAccessibleChild( i );
 860         if ( xAcc.is() )
 861         {
 862             Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 863             if ( xComp.is() )
 864             {
 865                 Rectangle aRect = VCLRectangle( xComp->getBounds() );
 866                 Point aPos = VCLPoint( rPoint );
 867                 if ( aRect.IsInside( aPos ) )
 868                 {
 869                     xChild = xAcc;
 870                     break;
 871                 }
 872             }
 873         }
 874     }
 875
 876     return xChild;
 877 }
 878
 879 // -----------------------------------------------------------------------------
 880
 881 void AccessibleDialogWindow::grabFocus(  ) throw (RuntimeException)
 882 {
 883     OExternalLockGuard aGuard( this );
 884
 885     if ( m_pDialogWindow )
 886         m_pDialogWindow->GrabFocus();
 887 }
 888
 889 // -----------------------------------------------------------------------------
 890
 891 sal_Int32 AccessibleDialogWindow::getForeground(  ) throw (RuntimeException)
 892 {
 893     OExternalLockGuard aGuard( this );
 894
 895     sal_Int32 nColor = 0;
 896     if ( m_pDialogWindow )
 897     {
 898         if ( m_pDialogWindow->IsControlForeground() )
 899             nColor = m_pDialogWindow->GetControlForeground().GetColor();
 900         else
 901         {
 902             Font aFont;
 903             if ( m_pDialogWindow->IsControlFont() )
 904                 aFont = m_pDialogWindow->GetControlFont();
 905             else
 906                 aFont = m_pDialogWindow->GetFont();
 907             nColor = aFont.GetColor().GetColor();
 908         }
 909     }
 910
 911     return nColor;
 912 }
 913
 914 // -----------------------------------------------------------------------------
 915
 916 sal_Int32 AccessibleDialogWindow::getBackground(  ) throw (RuntimeException)
 917 {
 918     OExternalLockGuard aGuard( this );
 919
 920     sal_Int32 nColor = 0;
 921     if ( m_pDialogWindow )
 922     {
 923         if ( m_pDialogWindow->IsControlBackground() )
 924             nColor = m_pDialogWindow->GetControlBackground().GetColor();
 925         else
 926             nColor = m_pDialogWindow->GetBackground().GetColor().GetColor();
 927     }
 928
 929     return nColor;
 930 }
 931
 932 // -----------------------------------------------------------------------------
 933 // XAccessibleExtendedComponent
 934 // -----------------------------------------------------------------------------
 935
 936 Reference< awt::XFont > AccessibleDialogWindow::getFont(  ) throw (RuntimeException)
 937 {
 938     OExternalLockGuard aGuard( this );
 939
 940     Reference< awt::XFont > xFont;
 941     if ( m_pDialogWindow )
 942     {
 943         Reference< awt::XDevice > xDev( m_pDialogWindow->GetComponentInterface(), UNO_QUERY );
 944         if ( xDev.is() )
 945         {
 946             Font aFont;
 947             if ( m_pDialogWindow->IsControlFont() )
 948                 aFont = m_pDialogWindow->GetControlFont();
 949             else
 950                 aFont = m_pDialogWindow->GetFont();
 951             VCLXFont* pVCLXFont = new VCLXFont;
 952             pVCLXFont->Init( *xDev.get(), aFont );
 953             xFont = pVCLXFont;
 954         }
 955     }
 956
 957     return xFont;
 958 }
 959
 960 // -----------------------------------------------------------------------------
 961
 962 ::rtl::OUString AccessibleDialogWindow::getTitledBorderText(  ) throw (RuntimeException)
 963 {
 964     OExternalLockGuard aGuard( this );
 965
 966     return ::rtl::OUString();
 967 }
 968
 969 // -----------------------------------------------------------------------------
 970
 971 ::rtl::OUString AccessibleDialogWindow::getToolTipText(  ) throw (RuntimeException)
 972 {
 973     OExternalLockGuard aGuard( this );
 974
 975     ::rtl::OUString sText;
 976     if ( m_pDialogWindow )
 977         sText = m_pDialogWindow->GetQuickHelpText();
 978
 979     return sText;
 980 }
 981
 982 // -----------------------------------------------------------------------------
 983 // XAccessibleSelection
 984 // -----------------------------------------------------------------------------
 985
 986 void AccessibleDialogWindow::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 987 {
 988     OExternalLockGuard aGuard( this );
 989
 990     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 991         throw IndexOutOfBoundsException();
 992
 993     if ( m_pDialogWindow )
 994     {
 995         DlgEdObj* pDlgEdObj = m_aAccessibleChildren[nChildIndex].pDlgEdObj;
 996         if ( pDlgEdObj )
 997         {
 998             SdrView* pSdrView = m_pDialogWindow->GetView();
 999             if ( pSdrView )
1000             {
1001                 SdrPageView* pPgView = pSdrView->GetSdrPageView();
1002                 if ( pPgView )
1003                     pSdrView->MarkObj( pDlgEdObj, pPgView );
1004             }
1005         }
1006     }
1007 }
1008
1009 // -----------------------------------------------------------------------------
1010
1011 sal_Bool AccessibleDialogWindow::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
1012 {
1013     OExternalLockGuard aGuard( this );
1014
1015     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
1016         throw IndexOutOfBoundsException();
1017
1018     sal_Bool bSelected = sal_False;
1019     if ( m_pDialogWindow )
1020     {
1021         DlgEdObj* pDlgEdObj = m_aAccessibleChildren[nChildIndex].pDlgEdObj;
1022         if ( pDlgEdObj )
1023         {
1024             SdrView* pSdrView = m_pDialogWindow->GetView();
1025             if ( pSdrView )
1026                 bSelected = pSdrView->IsObjMarked( pDlgEdObj );
1027         }
1028     }
1029
1030     return bSelected;
1031 }
1032
1033 // -----------------------------------------------------------------------------
1034
1035 void AccessibleDialogWindow::clearAccessibleSelection(  ) throw (RuntimeException)
1036 {
1037     OExternalLockGuard aGuard( this );
1038
1039     if ( m_pDialogWindow )
1040     {
1041         SdrView* pSdrView = m_pDialogWindow->GetView();
1042         if ( pSdrView )
1043             pSdrView->UnmarkAll();
1044     }
1045 }
1046
1047 // -----------------------------------------------------------------------------
1048
1049 void AccessibleDialogWindow::selectAllAccessibleChildren(  ) throw (RuntimeException)
1050 {
1051     OExternalLockGuard aGuard( this );
1052
1053     if ( m_pDialogWindow )
1054     {
1055         SdrView* pSdrView = m_pDialogWindow->GetView();
1056         if ( pSdrView )
1057             pSdrView->MarkAll();
1058     }
1059 }
1060
1061 // -----------------------------------------------------------------------------
1062
1063 sal_Int32 AccessibleDialogWindow::getSelectedAccessibleChildCount(  ) throw (RuntimeException)
1064 {
1065     OExternalLockGuard aGuard( this );
1066
1067     sal_Int32 nRet = 0;
1068
1069     for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
1070     {
1071         if ( isAccessibleChildSelected( i ) )
1072             ++nRet;
1073     }
1074
1075     return nRet;
1076 }
1077
1078 // -----------------------------------------------------------------------------
1079
1080 Reference< XAccessible > AccessibleDialogWindow::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
1081 {
1082     OExternalLockGuard aGuard( this );
1083
1084     if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
1085         throw IndexOutOfBoundsException();
1086
1087     Reference< XAccessible > xChild;
1088
1089     for ( sal_Int32 i = 0, j = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
1090     {
1091         if ( isAccessibleChildSelected( i ) && ( j++ == nSelectedChildIndex ) )
1092         {
1093             xChild = getAccessibleChild( i );
1094             break;
1095         }
1096     }
1097
1098     return xChild;
1099 }
1100
1101 // -----------------------------------------------------------------------------
1102
1103 void AccessibleDialogWindow::deselectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
1104 {
1105     OExternalLockGuard aGuard( this );
1106
1107     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
1108         throw IndexOutOfBoundsException();
1109
1110     if ( m_pDialogWindow )
1111     {
1112         DlgEdObj* pDlgEdObj = m_aAccessibleChildren[nChildIndex].pDlgEdObj;
1113         if ( pDlgEdObj )
1114         {
1115             SdrView* pSdrView = m_pDialogWindow->GetView();
1116             if ( pSdrView )
1117             {
1118                 SdrPageView* pPgView = pSdrView->GetSdrPageView();
1119                 if ( pPgView )
1120                     pSdrView->MarkObj( pDlgEdObj, pPgView, TRUE );
1121             }
1122         }
1123     }
1124 }
1125
1126 // -----------------------------------------------------------------------------