LCOV - code coverage report
Current view: top level - toolkit/source/awt - vclxaccessiblecomponent.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 416 0.0 %
Date: 2014-04-14 Functions: 0 42 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10