toolkit/source/awt/vclxaccessiblecomponent.cxx

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