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