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