toolkit/source/awt/vclxaccessiblecomponent.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 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  21 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  22 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  23 #include <com/sun/star/accessibility/XAccessibleEventListener.hpp>
  24 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  25 #include <toolkit/awt/vclxaccessiblecomponent.hxx>
  26 #include <toolkit/helper/externallock.hxx>
  27 #include <toolkit/awt/vclxwindow.hxx>
  28 #include <toolkit/helper/convert.hxx>
  29 #include <toolkit/awt/vclxfont.hxx>
  30 #include <vcl/dialog.hxx>
  31 #include <vcl/vclevent.hxx>
  32 #include <vcl/window.hxx>
  33 #include <tools/debug.hxx>
  34 #include <unotools/accessiblestatesethelper.hxx>
  35 #include <unotools/accessiblerelationsethelper.hxx>
  36 #include <vcl/svapp.hxx>
  37 #include <vcl/menu.hxx>
  38
  39 using namespace ::com::sun::star;
  40 using namespace ::comphelper;
  41
  42
  43 DBG_NAME(VCLXAccessibleComponent)
  44
  45
  46 VCLXAccessibleComponent::VCLXAccessibleComponent( VCLXWindow* pVCLXindow )
  47     : AccessibleExtendedComponentHelper_BASE( new VCLExternalSolarLock() )
  48     , OAccessibleImplementationAccess( )
  49 {
  50     DBG_CTOR( VCLXAccessibleComponent, 0 );
  51     mpVCLXindow = pVCLXindow;
  52     mxWindow = pVCLXindow;
  53
  54     m_pSolarLock = static_cast< VCLExternalSolarLock* >( getExternalLock( ) );
  55
  56     DBG_ASSERT( pVCLXindow->GetWindow(), "VCLXAccessibleComponent - no window!" );
  57     if ( pVCLXindow->GetWindow() )
  58     {
  59       pVCLXindow->GetWindow()->AddEventListener( LINK( this, VCLXAccessibleComponent, WindowEventListener ) );
  60       pVCLXindow->GetWindow()->AddChildEventListener( LINK( this, VCLXAccessibleComponent, WindowChildEventListener ) );
  61     }
  62
  63     // announce the XAccessible of our creator to the base class
  64     lateInit( pVCLXindow );
  65 }
  66
  67 VCLXAccessibleComponent::~VCLXAccessibleComponent()
  68 {
  69     DBG_DTOR( VCLXAccessibleComponent, 0 );
  70
  71     ensureDisposed();
  72
  73     if ( mpVCLXindow && mpVCLXindow->GetWindow() )
  74     {
  75         mpVCLXindow->GetWindow()->RemoveEventListener( LINK( this, VCLXAccessibleComponent, WindowEventListener ) );
  76         mpVCLXindow->GetWindow()->RemoveChildEventListener( LINK( this, VCLXAccessibleComponent, WindowChildEventListener ) );
  77     }
  78
  79     delete m_pSolarLock;
  80     m_pSolarLock = NULL;
  81     // This is not completely safe. If we assume that the base class dtor calls some method which
  82     // uses this lock, the we crash. However, as the base class' dtor does not have a chance to call _out_
  83     // virtual methods, this is no problem as long as the base class is safe, i.e. does not use the external
  84     // lock from within it's dtor. At the moment, we _know_ the base class is safe in this respect, so
  85     // let's assume it keeps this way.
  86     // @see OAccessibleContextHelper::OAccessibleContextHelper( IMutex* )
  87 }
  88
  89 IMPLEMENT_FORWARD_XINTERFACE3( VCLXAccessibleComponent, AccessibleExtendedComponentHelper_BASE, OAccessibleImplementationAccess, VCLXAccessibleComponent_BASE )
  90 IMPLEMENT_FORWARD_XTYPEPROVIDER3( VCLXAccessibleComponent, AccessibleExtendedComponentHelper_BASE, OAccessibleImplementationAccess, VCLXAccessibleComponent_BASE )
  91
  92 OUString VCLXAccessibleComponent::getImplementationName() throw (uno::RuntimeException)
  93 {
  94     return OUString("com.sun.star.comp.toolkit.AccessibleWindow");
  95 }
  96
  97 sal_Bool VCLXAccessibleComponent::supportsService( const OUString& rServiceName ) throw (uno::RuntimeException)
  98 {
  99     uno::Sequence< OUString > aNames( getSupportedServiceNames() );
 100     const OUString* pNames = aNames.getConstArray();
 101     const OUString* pEnd = pNames + aNames.getLength();
 102     for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
 103         ;
 104
 105     return pNames != pEnd;
 106 }
 107
 108 uno::Sequence< OUString > VCLXAccessibleComponent::getSupportedServiceNames() throw (uno::RuntimeException)
 109 {
 110     uno::Sequence< OUString > aNames(1);
 111     aNames[0] = OUString("com.sun.star.awt.AccessibleWindow");
 112     return aNames;
 113 }
 114
 115 IMPL_LINK( VCLXAccessibleComponent, WindowEventListener, VclSimpleEvent*, pEvent )
 116 {
 117     DBG_CHKTHIS(VCLXAccessibleComponent,0);
 118
 119     DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" );
 120
 121         /* Ignore VCLEVENT_WINDOW_ENDPOPUPMODE, because the UNO accessibility wrapper
 122          * might have been destroyed by the previous VCLEventListener (if no AT tool
 123          * is running), e.g. sub-toolbars in impress.
 124          */
 125     if ( pEvent && pEvent->ISA( VclWindowEvent ) && mxWindow.is() /* #122218# */ && (pEvent->GetId() != VCLEVENT_WINDOW_ENDPOPUPMODE) )
 126     {
 127         DBG_ASSERT( ((VclWindowEvent*)pEvent)->GetWindow(), "Window???" );
 128         if( !((VclWindowEvent*)pEvent)->GetWindow()->IsAccessibilityEventsSuppressed() || ( pEvent->GetId() == VCLEVENT_OBJECT_DYING ) )
 129         {
 130             ProcessWindowEvent( *(VclWindowEvent*)pEvent );
 131         }
 132     }
 133     return 0;
 134 }
 135
 136 IMPL_LINK( VCLXAccessibleComponent, WindowChildEventListener, VclSimpleEvent*, pEvent )
 137 {
 138     DBG_CHKTHIS(VCLXAccessibleComponent,0);
 139
 140     DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" );
 141     if ( pEvent && pEvent->ISA( VclWindowEvent ) && mxWindow.is() /* #i68079# */ )
 142     {
 143         DBG_ASSERT( ((VclWindowEvent*)pEvent)->GetWindow(), "Window???" );
 144         if( !((VclWindowEvent*)pEvent)->GetWindow()->IsAccessibilityEventsSuppressed() )
 145         {
 146             // #103087# to prevent an early release of the component
 147             uno::Reference< accessibility::XAccessibleContext > xTmp = this;
 148
 149             ProcessWindowChildEvent( *(VclWindowEvent*)pEvent );
 150         }
 151     }
 152     return 0;
 153 }
 154
 155 uno::Reference< accessibility::XAccessible > VCLXAccessibleComponent::GetChildAccessible( const VclWindowEvent& rVclWindowEvent )
 156 {
 157     // checks if the data in the window event is our direct child
 158     // and returns its accessible
 159
 160     // MT: Change this later, normaly a show/hide event shouldn't have the Window* in pData.
 161     Window* pChildWindow = (Window *) rVclWindowEvent.GetData();
 162     if( pChildWindow && GetWindow() == pChildWindow->GetAccessibleParentWindow() )
 163         return pChildWindow->GetAccessible( rVclWindowEvent.GetId() == VCLEVENT_WINDOW_SHOW );
 164     else
 165         return uno::Reference< accessibility::XAccessible > ();
 166 }
 167
 168 void VCLXAccessibleComponent::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
 169 {
 170     uno::Any aOldValue, aNewValue;
 171     uno::Reference< accessibility::XAccessible > xAcc;
 172
 173     switch ( rVclWindowEvent.GetId() )
 174     {
 175         case VCLEVENT_WINDOW_SHOW:  // send create on show for direct accessible children
 176         {
 177             xAcc = GetChildAccessible( rVclWindowEvent );
 178             if( xAcc.is() )
 179             {
 180                 aNewValue <<= xAcc;
 181                 NotifyAccessibleEvent( accessibility::AccessibleEventId::CHILD, aOldValue, aNewValue );
 182             }
 183         }
 184         break;
 185         case VCLEVENT_WINDOW_HIDE:  // send destroy on hide for direct accessible children
 186         {
 187             xAcc = GetChildAccessible( rVclWindowEvent );
 188             if( xAcc.is() )
 189             {
 190                 aOldValue <<= xAcc;
 191                 NotifyAccessibleEvent( accessibility::AccessibleEventId::CHILD, aOldValue, aNewValue );
 192             }
 193         }
 194         break;
 195     }
 196 }
 197
 198 void VCLXAccessibleComponent::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 199 {
 200     uno::Any aOldValue, aNewValue;
 201
 202     Window* pAccWindow = rVclWindowEvent.GetWindow();
 203     DBG_ASSERT( pAccWindow, "VCLXAccessibleComponent::ProcessWindowEvent - Window?" );
 204
 205     switch ( rVclWindowEvent.GetId() )
 206     {
 207         case VCLEVENT_OBJECT_DYING:
 208         {
 209             pAccWindow->RemoveEventListener( LINK( this, VCLXAccessibleComponent, WindowEventListener ) );
 210             pAccWindow->RemoveChildEventListener( LINK( this, VCLXAccessibleComponent, WindowChildEventListener ) );
 211             mxWindow.clear();
 212             mpVCLXindow = NULL;
 213         }
 214         break;
 215         case VCLEVENT_WINDOW_CHILDDESTROYED:
 216         {
 217             Window* pWindow = (Window*) rVclWindowEvent.GetData();
 218             DBG_ASSERT( pWindow, "VCLEVENT_WINDOW_CHILDDESTROYED - Window=?" );
 219             if ( pWindow->GetAccessible( sal_False ).is() )
 220             {
 221                 aOldValue <<= pWindow->GetAccessible( sal_False );
 222                 NotifyAccessibleEvent( accessibility::AccessibleEventId::CHILD, aOldValue, aNewValue );
 223             }
 224         }
 225         break;
 226         case VCLEVENT_WINDOW_ACTIVATE:
 227         {
 228             // avoid notification if a child frame is already active
 229             // only one frame may be active at a given time
 230             if ( !pAccWindow->HasActiveChildFrame() &&
 231                  ( getAccessibleRole() == accessibility::AccessibleRole::FRAME ||
 232                    getAccessibleRole() == accessibility::AccessibleRole::ALERT ||
 233                    getAccessibleRole() == accessibility::AccessibleRole::DIALOG ) )  // #i18891#
 234             {
 235                 aNewValue <<= accessibility::AccessibleStateType::ACTIVE;
 236                 NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 237             }
 238         }
 239         break;
 240         case VCLEVENT_WINDOW_DEACTIVATE:
 241         {
 242             if ( getAccessibleRole() == accessibility::AccessibleRole::FRAME ||
 243                  getAccessibleRole() == accessibility::AccessibleRole::ALERT ||
 244                  getAccessibleRole() == accessibility::AccessibleRole::DIALOG )  // #i18891#
 245             {
 246                 aOldValue <<= accessibility::AccessibleStateType::ACTIVE;
 247                 NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 248             }
 249         }
 250         break;
 251         case VCLEVENT_WINDOW_GETFOCUS:
 252         case VCLEVENT_CONTROL_GETFOCUS:
 253         {
 254             if( (pAccWindow->IsCompoundControl() && rVclWindowEvent.GetId() == VCLEVENT_CONTROL_GETFOCUS) ||
 255                 (!pAccWindow->IsCompoundControl() && rVclWindowEvent.GetId() == VCLEVENT_WINDOW_GETFOCUS) )
 256             {
 257                 // if multiple listeners were registered it is possible that the
 258                 // focus was changed during event processing (eg SfxTopWindow )
 259                 // #106082# allow ChildPathFocus only for CompoundControls, for windows the focus must be in the window itself
 260                 if( (pAccWindow->IsCompoundControl() && pAccWindow->HasChildPathFocus()) ||
 261                     (!pAccWindow->IsCompoundControl() && pAccWindow->HasFocus()) )
 262                 {
 263                     aNewValue <<= accessibility::AccessibleStateType::FOCUSED;
 264                     NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 265                 }
 266             }
 267         }
 268         break;
 269         case VCLEVENT_WINDOW_LOSEFOCUS:
 270         case VCLEVENT_CONTROL_LOSEFOCUS:
 271         {
 272             if( (pAccWindow->IsCompoundControl() && rVclWindowEvent.GetId() == VCLEVENT_CONTROL_LOSEFOCUS) ||
 273                 (!pAccWindow->IsCompoundControl() && rVclWindowEvent.GetId() == VCLEVENT_WINDOW_LOSEFOCUS) )
 274             {
 275                 aOldValue <<= accessibility::AccessibleStateType::FOCUSED;
 276                 NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 277             }
 278         }
 279         break;
 280         case VCLEVENT_WINDOW_FRAMETITLECHANGED:
 281         {
 282             OUString aOldName( *((OUString*) rVclWindowEvent.GetData()) );
 283             OUString aNewName( getAccessibleName() );
 284             aOldValue <<= aOldName;
 285             aNewValue <<= aNewName;
 286             NotifyAccessibleEvent( accessibility::AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue );
 287         }
 288         break;
 289         case VCLEVENT_WINDOW_ENABLED:
 290         {
 291             aNewValue <<= accessibility::AccessibleStateType::ENABLED;
 292             NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 293             aNewValue <<= accessibility::AccessibleStateType::SENSITIVE;
 294             NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 295         }
 296         break;
 297         case VCLEVENT_WINDOW_DISABLED:
 298         {
 299             aOldValue <<= accessibility::AccessibleStateType::SENSITIVE;
 300             NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 301
 302             aOldValue <<= accessibility::AccessibleStateType::ENABLED;
 303             NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 304         }
 305         break;
 306         case VCLEVENT_WINDOW_MOVE:
 307         case VCLEVENT_WINDOW_RESIZE:
 308         {
 309             NotifyAccessibleEvent( accessibility::AccessibleEventId::BOUNDRECT_CHANGED, aOldValue, aNewValue );
 310         }
 311         break;
 312         case VCLEVENT_WINDOW_MENUBARADDED:
 313         {
 314             MenuBar* pMenuBar = (MenuBar*) rVclWindowEvent.GetData();
 315             if ( pMenuBar )
 316             {
 317                 uno::Reference< accessibility::XAccessible > xChild( pMenuBar->GetAccessible() );
 318                 if ( xChild.is() )
 319                 {
 320                     aNewValue <<= xChild;
 321                     NotifyAccessibleEvent( accessibility::AccessibleEventId::CHILD, aOldValue, aNewValue );
 322                 }
 323             }
 324         }
 325         break;
 326         case VCLEVENT_WINDOW_MENUBARREMOVED:
 327         {
 328             MenuBar* pMenuBar = (MenuBar*) rVclWindowEvent.GetData();
 329             if ( pMenuBar )
 330             {
 331                 uno::Reference< accessibility::XAccessible > xChild( pMenuBar->GetAccessible() );
 332                 if ( xChild.is() )
 333                 {
 334                     aOldValue <<= xChild;
 335                     NotifyAccessibleEvent( accessibility::AccessibleEventId::CHILD, aOldValue, aNewValue );
 336                 }
 337             }
 338         }
 339         break;
 340         case VCLEVENT_WINDOW_MINIMIZE:
 341         {
 342             aNewValue <<= accessibility::AccessibleStateType::ICONIFIED;
 343             NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 344         }
 345         break;
 346         case VCLEVENT_WINDOW_NORMALIZE:
 347         {
 348             aOldValue <<= accessibility::AccessibleStateType::ICONIFIED;
 349             NotifyAccessibleEvent( accessibility::AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 350         }
 351         break;
 352         default:
 353         {
 354         }
 355         break;
 356     }
 357 }
 358
 359 void VCLXAccessibleComponent::disposing()
 360 {
 361     if ( mpVCLXindow && mpVCLXindow->GetWindow() )
 362     {
 363         mpVCLXindow->GetWindow()->RemoveEventListener( LINK( this, VCLXAccessibleComponent, WindowEventListener ) );
 364         mpVCLXindow->GetWindow()->RemoveChildEventListener( LINK( this, VCLXAccessibleComponent, WindowChildEventListener ) );
 365     }
 366
 367     AccessibleExtendedComponentHelper_BASE::disposing();
 368
 369     mxWindow.clear();
 370     mpVCLXindow = NULL;
 371 }
 372
 373 Window* VCLXAccessibleComponent::GetWindow() const
 374 {
 375     return GetVCLXWindow() ? GetVCLXWindow()->GetWindow() : NULL;
 376 }
 377
 378 void VCLXAccessibleComponent::FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet )
 379 {
 380     Window* pWindow = GetWindow();
 381     if ( pWindow )
 382     {
 383         Window *pLabeledBy = pWindow->GetAccessibleRelationLabeledBy();
 384         if ( pLabeledBy && pLabeledBy != pWindow )
 385         {
 386             uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 387             aSequence[0] = pLabeledBy->GetAccessible();
 388             rRelationSet.AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::LABELED_BY, aSequence ) );
 389         }
 390
 391         Window* pLabelFor = pWindow->GetAccessibleRelationLabelFor();
 392         if ( pLabelFor && pLabelFor != pWindow )
 393         {
 394             uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 395             aSequence[0] = pLabelFor->GetAccessible();
 396             rRelationSet.AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::LABEL_FOR, aSequence ) );
 397         }
 398
 399         Window* pMemberOf = pWindow->GetAccessibleRelationMemberOf();
 400         if ( pMemberOf && pMemberOf != pWindow )
 401         {
 402             uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
 403             aSequence[0] = pMemberOf->GetAccessible();
 404             rRelationSet.AddRelation( accessibility::AccessibleRelation( accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
 405         }
 406     }
 407 }
 408
 409 void VCLXAccessibleComponent::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 410 {
 411     Window* pWindow = GetWindow();
 412     if ( pWindow )
 413     {
 414         if ( pWindow->IsVisible() )
 415         {
 416             rStateSet.AddState( accessibility::AccessibleStateType::VISIBLE );
 417             rStateSet.AddState( accessibility::AccessibleStateType::SHOWING );
 418         }
 419         else
 420         {
 421             rStateSet.AddState( accessibility::AccessibleStateType::INVALID );
 422         }
 423
 424         if ( pWindow->IsEnabled() )
 425         {
 426             rStateSet.AddState( accessibility::AccessibleStateType::ENABLED );
 427             rStateSet.AddState( accessibility::AccessibleStateType::SENSITIVE );
 428         }
 429
 430         if ( pWindow->HasChildPathFocus() &&
 431              ( getAccessibleRole() == accessibility::AccessibleRole::FRAME ||
 432                getAccessibleRole() == accessibility::AccessibleRole::ALERT ||
 433                getAccessibleRole() == accessibility::AccessibleRole::DIALOG ) )  // #i18891#
 434             rStateSet.AddState( accessibility::AccessibleStateType::ACTIVE );
 435
 436         if ( pWindow->HasFocus() || ( pWindow->IsCompoundControl() && pWindow->HasChildPathFocus() ) )
 437             rStateSet.AddState( accessibility::AccessibleStateType::FOCUSED );
 438
 439         if ( pWindow->IsWait() )
 440             rStateSet.AddState( accessibility::AccessibleStateType::BUSY );
 441
 442         if ( pWindow->GetStyle() & WB_SIZEABLE )
 443             rStateSet.AddState( accessibility::AccessibleStateType::RESIZABLE );
 444
 445         if( pWindow->IsDialog() )
 446         {
 447             Dialog *pDlg = static_cast< Dialog* >( pWindow );
 448             if( pDlg->IsInExecute() )
 449                 rStateSet.AddState( accessibility::AccessibleStateType::MODAL );
 450         }
 451     }
 452     else
 453     {
 454         rStateSet.AddState( accessibility::AccessibleStateType::DEFUNC );
 455     }
 456
 457 /*
 458
 459 MUST BE SET FROM DERIVED CLASSES:
 460
 461 CHECKED
 462 COLLAPSED
 463 EXPANDED
 464 EXPANDABLE
 465 EDITABLE
 466 FOCUSABLE
 467 HORIZONTAL
 468 VERTICAL
 469 ICONIFIED
 470 MULTILINE
 471 MULTI_SELECTABLE
 472 PRESSED
 473 SELECTABLE
 474 SELECTED
 475 SINGLE_LINE
 476 TRANSIENT
 477
 478     */
 479 }
 480
 481
 482 // accessibility::XAccessibleContext
 483 sal_Int32 VCLXAccessibleComponent::getAccessibleChildCount() throw (uno::RuntimeException)
 484 {
 485     OExternalLockGuard aGuard( this );
 486
 487     sal_Int32 nChildren = 0;
 488     if ( GetWindow() )
 489         nChildren = GetWindow()->GetAccessibleChildWindowCount();
 490
 491     return nChildren;
 492 }
 493
 494 uno::Reference< accessibility::XAccessible > VCLXAccessibleComponent::getAccessibleChild( sal_Int32 i ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 495 {
 496     OExternalLockGuard aGuard( this );
 497
 498     if ( i >= getAccessibleChildCount() )
 499         throw lang::IndexOutOfBoundsException();
 500
 501     uno::Reference< accessibility::XAccessible > xAcc;
 502     if ( GetWindow() )
 503     {
 504         Window* pChild = GetWindow()->GetAccessibleChildWindow( (sal_uInt16)i );
 505         if ( pChild )
 506             xAcc = pChild->GetAccessible();
 507     }
 508
 509     return xAcc;
 510 }
 511
 512 uno::Reference< accessibility::XAccessible > VCLXAccessibleComponent::getVclParent() const
 513 {
 514     uno::Reference< accessibility::XAccessible > xAcc;
 515     if ( GetWindow() )
 516     {
 517         Window* pParent = GetWindow()->GetAccessibleParentWindow();
 518         if ( pParent )
 519             xAcc = pParent->GetAccessible();
 520     }
 521     return xAcc;
 522 }
 523
 524 uno::Reference< accessibility::XAccessible > VCLXAccessibleComponent::getAccessibleParent(  ) throw (uno::RuntimeException)
 525 {
 526     OExternalLockGuard aGuard( this );
 527
 528     uno::Reference< accessibility::XAccessible > xAcc( implGetForeignControlledParent() );
 529     if ( !xAcc.is() )
 530         // we do _not_ have a foreign-controlled parent -> default to our VCL parent
 531         xAcc = getVclParent();
 532
 533     return xAcc;
 534 }
 535
 536 sal_Int32 VCLXAccessibleComponent::getAccessibleIndexInParent(  ) throw (uno::RuntimeException)
 537 {
 538     OExternalLockGuard aGuard( this );
 539
 540     sal_Int32 nIndex = -1;
 541
 542     uno::Reference< accessibility::XAccessible > xAcc( implGetForeignControlledParent() );
 543     if ( xAcc.is() )
 544     {   // we _do_ have a foreign-controlled parent -> use the base class' implementation,
 545         // which goes the UNO way
 546         nIndex = AccessibleExtendedComponentHelper_BASE::getAccessibleIndexInParent( );
 547     }
 548     else
 549     {
 550         if ( GetWindow() )
 551         {
 552             Window* pParent = GetWindow()->GetAccessibleParentWindow();
 553             if ( pParent )
 554             {
 555                 //  Iterate over all the parent's children and search for this object.
 556                 // this should be compatible with the code in SVX
 557                 uno::Reference< accessibility::XAccessible > xParentAcc( pParent->GetAccessible() );
 558                 if ( xParentAcc.is() )
 559                 {
 560                     uno::Reference< accessibility::XAccessibleContext > xParentContext ( xParentAcc->getAccessibleContext() );
 561                     if ( xParentContext.is() )
 562                     {
 563                         sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
 564                         for ( sal_Int32 i=0; i<nChildCount; i++ )
 565                         {
 566                             uno::Reference< accessibility::XAccessible > xChild( xParentContext->getAccessibleChild(i) );
 567                             if ( xChild.is() )
 568                             {
 569                                 uno::Reference< accessibility::XAccessibleContext > xChildContext = xChild->getAccessibleContext();
 570                                 if ( xChildContext == (accessibility::XAccessibleContext*) this )
 571                                 {
 572                                     nIndex = i;
 573                                     break;
 574                                 }
 575                             }
 576                         }
 577                     }
 578                 }
 579             }
 580         }
 581     }
 582     return nIndex;
 583 }
 584
 585 sal_Int16 VCLXAccessibleComponent::getAccessibleRole(  ) throw (uno::RuntimeException)
 586 {
 587     OExternalLockGuard aGuard( this );
 588
 589     sal_Int16 nRole = 0;
 590
 591     if ( GetWindow() )
 592         nRole = GetWindow()->GetAccessibleRole();
 593
 594     return nRole;
 595 }
 596
 597 OUString VCLXAccessibleComponent::getAccessibleDescription(  ) throw (uno::RuntimeException)
 598 {
 599     OExternalLockGuard aGuard( this );
 600
 601     OUString aDescription;
 602
 603     if ( GetWindow() )
 604         aDescription = GetWindow()->GetAccessibleDescription();
 605
 606     return aDescription;
 607 }
 608
 609 OUString VCLXAccessibleComponent::getAccessibleName(  ) throw (uno::RuntimeException)
 610 {
 611     OExternalLockGuard aGuard( this );
 612
 613     OUString aName;
 614     if ( GetWindow() )
 615     {
 616         aName = GetWindow()->GetAccessibleName();
 617 #if OSL_DEBUG_LEVEL > 1
 618         aName += OUString(" (Type = ");
 619         aName += OUString::valueOf(static_cast<sal_Int32>(GetWindow()->GetType()));
 620         aName += OUString( ")");
 621 #endif
 622     }
 623     return aName;
 624 }
 625
 626 uno::Reference< accessibility::XAccessibleRelationSet > VCLXAccessibleComponent::getAccessibleRelationSet(  ) throw (uno::RuntimeException)
 627 {
 628     OExternalLockGuard aGuard( this );
 629
 630     utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 631     uno::Reference< accessibility::XAccessibleRelationSet > xSet = pRelationSetHelper;
 632     FillAccessibleRelationSet( *pRelationSetHelper );
 633     return xSet;
 634 }
 635
 636 uno::Reference< accessibility::XAccessibleStateSet > VCLXAccessibleComponent::getAccessibleStateSet(  ) throw (uno::RuntimeException)
 637 {
 638     OExternalLockGuard aGuard( this );
 639
 640     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 641     uno::Reference< accessibility::XAccessibleStateSet > xSet = pStateSetHelper;
 642     FillAccessibleStateSet( *pStateSetHelper );
 643     return xSet;
 644 }
 645
 646 lang::Locale VCLXAccessibleComponent::getLocale() throw (accessibility::IllegalAccessibleComponentStateException, uno::RuntimeException)
 647 {
 648     OExternalLockGuard aGuard( this );
 649
 650     return Application::GetSettings().GetLanguageTag().getLocale();
 651 }
 652
 653 uno::Reference< accessibility::XAccessible > VCLXAccessibleComponent::getAccessibleAtPoint( const awt::Point& rPoint ) throw (uno::RuntimeException)
 654 {
 655     OExternalLockGuard aGuard( this );
 656
 657     uno::Reference< accessibility::XAccessible > xChild;
 658     for ( sal_uInt32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
 659     {
 660         uno::Reference< accessibility::XAccessible > xAcc = getAccessibleChild( i );
 661         if ( xAcc.is() )
 662         {
 663             uno::Reference< accessibility::XAccessibleComponent > xComp( xAcc->getAccessibleContext(), uno::UNO_QUERY );
 664             if ( xComp.is() )
 665             {
 666                 Rectangle aRect = VCLRectangle( xComp->getBounds() );
 667                 Point aPos = VCLPoint( rPoint );
 668                 if ( aRect.IsInside( aPos ) )
 669                 {
 670                     xChild = xAcc;
 671                     break;
 672                 }
 673             }
 674         }
 675     }
 676
 677     return xChild;
 678 }
 679
 680 // accessibility::XAccessibleComponent
 681 awt::Rectangle VCLXAccessibleComponent::implGetBounds() throw (uno::RuntimeException)
 682 {
 683     awt::Rectangle aBounds ( 0, 0, 0, 0 );
 684
 685     Window* pWindow = GetWindow();
 686     if ( pWindow )
 687     {
 688         Rectangle aRect = pWindow->GetWindowExtentsRelative( NULL );
 689         aBounds = AWTRectangle( aRect );
 690         Window* pParent = pWindow->GetAccessibleParentWindow();
 691         if ( pParent )
 692         {
 693             Rectangle aParentRect = pParent->GetWindowExtentsRelative( NULL );
 694             awt::Point aParentScreenLoc = AWTPoint( aParentRect.TopLeft() );
 695             aBounds.X -= aParentScreenLoc.X;
 696             aBounds.Y -= aParentScreenLoc.Y;
 697         }
 698     }
 699
 700     uno::Reference< accessibility::XAccessible > xParent( implGetForeignControlledParent() );
 701     if ( xParent.is() )
 702     {   // hmm, we can't rely on our VCL coordinates, as in the Accessibility Hierarchy, somebody gave
 703         // us a parent which is different from our VCL parent
 704         // (actually, we did not check if it's really different ...)
 705
 706         // the screen location of the foreign parent
 707         uno::Reference< accessibility::XAccessibleComponent > xParentComponent( xParent->getAccessibleContext(), uno::UNO_QUERY );
 708         DBG_ASSERT( xParentComponent.is(), "VCLXAccessibleComponent::implGetBounds: invalid (foreign) parent component!" );
 709
 710         awt::Point aScreenLocForeign( 0, 0 );
 711         if ( xParentComponent.is() )
 712             aScreenLocForeign = xParentComponent->getLocationOnScreen();
 713
 714         // the screen location of the VCL parent
 715         xParent = getVclParent();
 716         if ( xParent.is() )
 717             xParentComponent = xParentComponent.query( xParent->getAccessibleContext() );
 718
 719         awt::Point aScreenLocVCL( 0, 0 );
 720         if ( xParentComponent.is() )
 721             aScreenLocVCL = xParentComponent->getLocationOnScreen();
 722
 723         // the difference between them
 724         awt::Size aOffset( aScreenLocVCL.X - aScreenLocForeign.X, aScreenLocVCL.Y - aScreenLocForeign.Y );
 725         // move the bounds
 726         aBounds.X += aOffset.Width;
 727         aBounds.Y += aOffset.Height;
 728     }
 729
 730     return aBounds;
 731 }
 732
 733 awt::Point VCLXAccessibleComponent::getLocationOnScreen(  ) throw (uno::RuntimeException)
 734 {
 735     OExternalLockGuard aGuard( this );
 736
 737     awt::Point aPos;
 738     if ( GetWindow() )
 739     {
 740         Rectangle aRect = GetWindow()->GetWindowExtentsRelative( NULL );
 741         aPos.X = aRect.Left();
 742         aPos.Y = aRect.Top();
 743     }
 744
 745     return aPos;
 746 }
 747
 748 void VCLXAccessibleComponent::grabFocus(  ) throw (uno::RuntimeException)
 749 {
 750     OExternalLockGuard aGuard( this );
 751
 752     uno::Reference< accessibility::XAccessibleStateSet > xStates = getAccessibleStateSet();
 753     if ( mxWindow.is() && xStates.is() && xStates->contains( accessibility::AccessibleStateType::FOCUSABLE ) )
 754         mxWindow->setFocus();
 755 }
 756
 757 sal_Int32 SAL_CALL VCLXAccessibleComponent::getForeground(  ) throw (uno::RuntimeException)
 758 {
 759     OExternalLockGuard aGuard( this );
 760
 761     sal_Int32 nColor = 0;
 762     Window* pWindow = GetWindow();
 763     if ( pWindow )
 764     {
 765         if ( pWindow->IsControlForeground() )
 766             nColor = pWindow->GetControlForeground().GetColor();
 767         else
 768         {
 769             Font aFont;
 770             if ( pWindow->IsControlFont() )
 771                 aFont = pWindow->GetControlFont();
 772             else
 773                 aFont = pWindow->GetFont();
 774             nColor = aFont.GetColor().GetColor();
 775         }
 776     }
 777
 778     return nColor;
 779 }
 780
 781 sal_Int32 SAL_CALL VCLXAccessibleComponent::getBackground(  ) throw (uno::RuntimeException)
 782 {
 783     OExternalLockGuard aGuard( this );
 784
 785     sal_Int32 nColor = 0;
 786     Window* pWindow = GetWindow();
 787     if ( pWindow )
 788     {
 789         if ( pWindow->IsControlBackground() )
 790             nColor = pWindow->GetControlBackground().GetColor();
 791         else
 792             nColor = pWindow->GetBackground().GetColor().GetColor();
 793     }
 794
 795     return nColor;
 796 }
 797
 798 // XAccessibleExtendedComponent
 799
 800 uno::Reference< awt::XFont > SAL_CALL VCLXAccessibleComponent::getFont(  ) throw (uno::RuntimeException)
 801 {
 802     OExternalLockGuard aGuard( this );
 803
 804     uno::Reference< awt::XFont > xFont;
 805     Window* pWindow = GetWindow();
 806     if ( pWindow )
 807     {
 808         uno::Reference< awt::XDevice > xDev( pWindow->GetComponentInterface(), uno::UNO_QUERY );
 809         if ( xDev.is() )
 810         {
 811             Font aFont;
 812             if ( pWindow->IsControlFont() )
 813                 aFont = pWindow->GetControlFont();
 814             else
 815                 aFont = pWindow->GetFont();
 816             VCLXFont* pVCLXFont = new VCLXFont;
 817             pVCLXFont->Init( *xDev.get(), aFont );
 818             xFont = pVCLXFont;
 819         }
 820     }
 821
 822     return xFont;
 823 }
 824
 825 OUString SAL_CALL VCLXAccessibleComponent::getTitledBorderText(  ) throw (uno::RuntimeException)
 826 {
 827     OExternalLockGuard aGuard( this );
 828
 829     OUString sRet;
 830     if ( GetWindow() )
 831         sRet = GetWindow()->GetText();
 832
 833     return sRet;
 834 }
 835
 836 OUString SAL_CALL VCLXAccessibleComponent::getToolTipText(  ) throw (uno::RuntimeException)
 837 {
 838     OExternalLockGuard aGuard( this );
 839
 840     OUString sRet;
 841     if ( GetWindow() )
 842         sRet = GetWindow()->GetQuickHelpText();
 843
 844     return sRet;
 845 }
 846
 847 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */