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