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