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