LCOV - code coverage report
Current view: top level - svx/source/accessibility - AccessibleFrameSelector.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 324 0.0 %
Date: 2014-04-14 Functions: 0 44 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 "AccessibleFrameSelector.hxx"
      21             : #include <com/sun/star/awt/KeyEvent.hpp>
      22             : #include <com/sun/star/awt/KeyModifier.hpp>
      23             : #include <com/sun/star/awt/Key.hpp>
      24             : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
      25             : #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
      26             : #include <com/sun/star/accessibility/AccessibleRole.hpp>
      27             : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
      28             : #include <com/sun/star/awt/FocusChangeReason.hpp>
      29             : #include <cppuhelper/supportsservice.hxx>
      30             : #include <unotools/accessiblestatesethelper.hxx>
      31             : #include <unotools/accessiblerelationsethelper.hxx>
      32             : #include <osl/mutex.hxx>
      33             : #include <vcl/svapp.hxx>
      34             : #include <vcl/settings.hxx>
      35             : #include <svx/frmsel.hxx>
      36             : #include <svx/dialmgr.hxx>
      37             : #include "editeng/unolingu.hxx"
      38             : 
      39             : #include <svx/dialogs.hrc>
      40             : #include "frmsel.hrc"
      41             : 
      42             : #ifndef MNEMONIC_CHAR
      43             : #define MNEMONIC_CHAR ((sal_Unicode)'~')
      44             : #endif
      45             : 
      46             : namespace svx {
      47             : namespace a11y {
      48             : 
      49             : using ::com::sun::star::uno::Any;
      50             : using ::com::sun::star::uno::UNO_QUERY;
      51             : using ::com::sun::star::uno::Reference;
      52             : using ::com::sun::star::uno::Sequence;
      53             : using ::com::sun::star::uno::RuntimeException;
      54             : using ::com::sun::star::uno::XInterface;
      55             : using ::com::sun::star::lang::Locale;
      56             : using ::com::sun::star::lang::EventObject;
      57             : using ::com::sun::star::beans::XPropertyChangeListener;
      58             : using ::com::sun::star::awt::XFocusListener;
      59             : 
      60             : using namespace ::com::sun::star::accessibility;
      61             : 
      62             : namespace AwtKey                    = ::com::sun::star::awt::Key;
      63             : namespace AwtKeyModifier            = ::com::sun::star::awt::KeyModifier;
      64             : namespace AwtFocusChangeReason      = ::com::sun::star::awt::FocusChangeReason;
      65             : 
      66             : typedef ::com::sun::star::awt::Point        AwtPoint;
      67             : typedef ::com::sun::star::awt::Size         AwtSize;
      68             : typedef ::com::sun::star::awt::Rectangle    AwtRectangle;
      69             : typedef ::com::sun::star::awt::KeyEvent     AwtKeyEvent;
      70             : typedef ::com::sun::star::awt::FocusEvent   AwtFocusEvent;
      71             : 
      72             : 
      73             : 
      74           0 : AccFrameSelector::AccFrameSelector( FrameSelector& rFrameSel, FrameBorderType eBorder ) :
      75           0 :     Resource( SVX_RES( RID_SVXSTR_BORDER_CONTROL ) ),
      76             :     mpFrameSel( &rFrameSel ),
      77             :     meBorder( eBorder ),
      78             :     maFocusListeners( maFocusMutex ),
      79             :     maPropertyListeners( maPropertyMutex ),
      80           0 :     maNames( SVX_RES( ARR_TEXTS ) ),
      81           0 :     maDescriptions( SVX_RES(ARR_DESCRIPTIONS ) ),
      82           0 :     mnClientId( 0 )
      83             : {
      84           0 :     FreeResource();
      85             : 
      86           0 :     if ( mpFrameSel )
      87             :     {
      88           0 :         mpFrameSel->AddEventListener( LINK( this, AccFrameSelector, WindowEventListener ) );
      89             :     }
      90           0 : }
      91             : 
      92             : 
      93             : 
      94           0 : AccFrameSelector::~AccFrameSelector()
      95             : {
      96           0 :     RemoveFrameSelEventListener();
      97           0 : }
      98             : 
      99             : 
     100             : 
     101           0 : void AccFrameSelector::RemoveFrameSelEventListener()
     102             : {
     103           0 :     if ( mpFrameSel )
     104             :     {
     105           0 :         mpFrameSel->RemoveEventListener( LINK( this, AccFrameSelector, WindowEventListener ) );
     106             :     }
     107           0 : }
     108             : 
     109             : 
     110             : 
     111           0 : Reference< XAccessibleContext > AccFrameSelector::getAccessibleContext(  )
     112             :     throw (RuntimeException, std::exception)
     113             : {
     114           0 :     return this;
     115             : }
     116             : 
     117             : 
     118             : 
     119           0 : sal_Int32 AccFrameSelector::getAccessibleChildCount(  ) throw (RuntimeException, std::exception)
     120             : {
     121           0 :     SolarMutexGuard aGuard;
     122           0 :     IsValid();
     123           0 :     return (meBorder == FRAMEBORDER_NONE) ? mpFrameSel->GetEnabledBorderCount() : 0;
     124             : }
     125             : 
     126             : 
     127             : 
     128           0 : Reference< XAccessible > AccFrameSelector::getAccessibleChild( sal_Int32 i )
     129             :     throw (RuntimeException, std::exception)
     130             : {
     131           0 :     SolarMutexGuard aGuard;
     132           0 :     IsValid();
     133           0 :     Reference< XAccessible > xRet;
     134           0 :     if( meBorder == FRAMEBORDER_NONE )
     135           0 :         xRet = mpFrameSel->GetChildAccessible( i );
     136           0 :     if( !xRet.is() )
     137           0 :         throw RuntimeException();
     138           0 :     return xRet;
     139             : }
     140             : 
     141             : 
     142             : 
     143           0 : Reference< XAccessible > AccFrameSelector::getAccessibleParent(  )
     144             :     throw (RuntimeException, std::exception)
     145             : {
     146           0 :     SolarMutexGuard aGuard;
     147           0 :     IsValid();
     148           0 :     Reference< XAccessible > xRet;
     149           0 :     if(meBorder == FRAMEBORDER_NONE)
     150           0 :         xRet = mpFrameSel->GetParent()->GetAccessible( true );
     151             :     else
     152           0 :         xRet = mpFrameSel->CreateAccessible();
     153           0 :     return xRet;
     154             : }
     155             : 
     156             : 
     157             : 
     158           0 : sal_Int32 AccFrameSelector::getAccessibleIndexInParent(  )
     159             :     throw (RuntimeException, std::exception)
     160             : {
     161           0 :     SolarMutexGuard aGuard;
     162           0 :     IsValid();
     163             : 
     164           0 :     sal_Int32 nIdx = 0;
     165           0 :     if( meBorder == FRAMEBORDER_NONE )
     166             :     {
     167           0 :         Window* pTabPage = mpFrameSel->GetParent();
     168           0 :         sal_Int32 nChildren = pTabPage->GetChildCount();
     169           0 :         for( nIdx = 0; nIdx < nChildren; ++nIdx )
     170           0 :             if( pTabPage->GetChild( static_cast< sal_uInt16 >( nIdx ) ) == mpFrameSel )
     171           0 :                 break;
     172             :     }
     173             :     else
     174           0 :         nIdx = mpFrameSel->GetEnabledBorderIndex( meBorder );
     175             : 
     176           0 :     if( nIdx < 0 )
     177           0 :         throw RuntimeException();
     178           0 :     return nIdx;
     179             : }
     180             : 
     181             : 
     182             : 
     183           0 : sal_Int16 AccFrameSelector::getAccessibleRole(  ) throw (RuntimeException, std::exception)
     184             : {
     185           0 :     return meBorder == FRAMEBORDER_NONE ? AccessibleRole::OPTION_PANE : AccessibleRole::CHECK_BOX;
     186             : }
     187             : 
     188             : 
     189             : 
     190           0 : OUString AccFrameSelector::getAccessibleDescription(  )
     191             :     throw (RuntimeException, std::exception)
     192             : {
     193           0 :     SolarMutexGuard aGuard;
     194           0 :     IsValid();
     195           0 :     return maDescriptions.GetString(meBorder);
     196             : }
     197             : 
     198             : 
     199             : 
     200           0 : OUString AccFrameSelector::getAccessibleName(  )
     201             :     throw (RuntimeException, std::exception)
     202             : {
     203           0 :     SolarMutexGuard aGuard;
     204           0 :     IsValid();
     205           0 :     return maNames.GetString(meBorder);
     206             : }
     207             : 
     208             : 
     209             : 
     210           0 : Reference< XAccessibleRelationSet > AccFrameSelector::getAccessibleRelationSet(  )
     211             :     throw (RuntimeException, std::exception)
     212             : {
     213           0 :     SolarMutexGuard aGuard;
     214           0 :     IsValid();
     215             :     utl::AccessibleRelationSetHelper* pHelper;
     216           0 :     Reference< XAccessibleRelationSet > xRet = pHelper = new utl::AccessibleRelationSetHelper;
     217           0 :     if(meBorder == FRAMEBORDER_NONE)
     218             :     {
     219             :         //add the label relation
     220           0 :         Window *pLabeledBy = mpFrameSel->GetAccessibleRelationLabeledBy();
     221           0 :         if ( pLabeledBy && pLabeledBy != mpFrameSel )
     222             :         {
     223           0 :             AccessibleRelation aLabelRelation;
     224           0 :             aLabelRelation.RelationType = AccessibleRelationType::LABELED_BY;
     225           0 :             aLabelRelation.TargetSet.realloc(1);
     226           0 :             aLabelRelation.TargetSet.getArray()[0]  = pLabeledBy->GetAccessible();
     227           0 :             pHelper->AddRelation(aLabelRelation);
     228             :         }
     229           0 :         Window* pMemberOf = mpFrameSel->GetAccessibleRelationMemberOf();
     230           0 :         if ( pMemberOf && pMemberOf != mpFrameSel )
     231             :         {
     232           0 :             AccessibleRelation aMemberOfRelation;
     233           0 :             aMemberOfRelation.RelationType = AccessibleRelationType::MEMBER_OF;
     234           0 :             aMemberOfRelation.TargetSet.realloc(1);
     235           0 :             aMemberOfRelation.TargetSet.getArray()[0]  = pMemberOf->GetAccessible();
     236           0 :             pHelper->AddRelation(aMemberOfRelation);
     237             :         }
     238             :     }
     239           0 :     return xRet;
     240             : }
     241             : 
     242             : 
     243             : 
     244           0 : Reference< XAccessibleStateSet > AccFrameSelector::getAccessibleStateSet(  )
     245             :     throw (RuntimeException, std::exception)
     246             : {
     247           0 :     SolarMutexGuard aGuard;
     248           0 :     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
     249           0 :     Reference< XAccessibleStateSet > xRet = pStateSetHelper;
     250             : 
     251           0 :     if(!mpFrameSel)
     252           0 :         pStateSetHelper->AddState(AccessibleStateType::DEFUNC);
     253             :     else
     254             :     {
     255             :         const sal_Int16 aStandardStates[] =
     256             :         {
     257             :             AccessibleStateType::EDITABLE,
     258             :             AccessibleStateType::FOCUSABLE,
     259             :             AccessibleStateType::MULTI_SELECTABLE,
     260             :             AccessibleStateType::SELECTABLE,
     261             :             AccessibleStateType::SHOWING,
     262             :             AccessibleStateType::VISIBLE,
     263             :             AccessibleStateType::OPAQUE,
     264           0 :             0};
     265           0 :         sal_Int16 nState = 0;
     266           0 :         while(aStandardStates[nState])
     267             :         {
     268           0 :             pStateSetHelper->AddState(aStandardStates[nState++]);
     269             :         }
     270           0 :         if(mpFrameSel->IsEnabled())
     271             :         {
     272           0 :             pStateSetHelper->AddState(AccessibleStateType::ENABLED);
     273           0 :             pStateSetHelper->AddState(AccessibleStateType::SENSITIVE);
     274             :         }
     275             : 
     276           0 :         bool bIsParent = meBorder == FRAMEBORDER_NONE;
     277           0 :         if(mpFrameSel->HasFocus() &&
     278           0 :             (bIsParent || mpFrameSel->IsBorderSelected(meBorder)))
     279             :         {
     280           0 :             pStateSetHelper->AddState(AccessibleStateType::ACTIVE);
     281           0 :             pStateSetHelper->AddState(AccessibleStateType::FOCUSED);
     282           0 :             pStateSetHelper->AddState(AccessibleStateType::SELECTED);
     283             :         }
     284             :     }
     285           0 :     return xRet;
     286             : }
     287             : 
     288             : 
     289             : 
     290           0 : Locale AccFrameSelector::getLocale(  )
     291             :     throw (IllegalAccessibleComponentStateException, RuntimeException, std::exception)
     292             : {
     293           0 :     return Application::GetSettings().GetUILanguageTag().getLocale();
     294             : }
     295             : 
     296             : 
     297             : 
     298           0 : void AccFrameSelector::addPropertyChangeListener(
     299             :     const Reference< XPropertyChangeListener >& xListener )
     300             :         throw (RuntimeException)
     301             : {
     302           0 :     maPropertyListeners.addInterface( xListener );
     303           0 : }
     304             : 
     305             : 
     306             : 
     307           0 : void AccFrameSelector::removePropertyChangeListener( const Reference< XPropertyChangeListener >& xListener )
     308             :     throw (RuntimeException)
     309             : {
     310           0 :     maPropertyListeners.removeInterface( xListener );
     311           0 : }
     312             : 
     313             : 
     314             : 
     315           0 : sal_Bool AccFrameSelector::containsPoint( const AwtPoint& aPt )
     316             :     throw (RuntimeException, std::exception)
     317             : {
     318           0 :     SolarMutexGuard aGuard;
     319           0 :     IsValid();
     320             :     //aPt is relative to the frame selector
     321           0 :     return mpFrameSel->ContainsClickPoint( Point( aPt.X, aPt.Y ) );
     322             : }
     323             : 
     324             : 
     325             : 
     326           0 : Reference< XAccessible > AccFrameSelector::getAccessibleAtPoint(
     327             :     const AwtPoint& aPt )
     328             :         throw (RuntimeException, std::exception)
     329             : {
     330           0 :     SolarMutexGuard aGuard;
     331           0 :     IsValid();
     332             :     //aPt is relative to the frame selector
     333           0 :     return mpFrameSel->GetChildAccessible( Point( aPt.X, aPt.Y ) );
     334             : }
     335             : 
     336           0 : AwtRectangle AccFrameSelector::getBounds(  ) throw (RuntimeException, std::exception)
     337             : {
     338           0 :     SolarMutexGuard aGuard;
     339           0 :     IsValid();
     340           0 :     Size aSz;
     341           0 :     Point aPos;
     342           0 :     switch(meBorder)
     343             :     {
     344             :         case FRAMEBORDER_NONE:
     345           0 :             aSz = mpFrameSel->GetSizePixel();
     346           0 :             aPos = mpFrameSel->GetPosPixel();
     347           0 :         break;
     348             :         default:
     349           0 :             const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
     350           0 :             aPos = aSpot.TopLeft();
     351           0 :             aSz = aSpot.GetSize();
     352             :     }
     353           0 :     AwtRectangle aRet;
     354           0 :     aRet.X = aPos.X();
     355           0 :     aRet.Y = aPos.Y();
     356           0 :     aRet.Width = aSz.Width();
     357           0 :     aRet.Height = aSz.Height();
     358           0 :     return aRet;
     359             : }
     360             : 
     361             : 
     362             : 
     363           0 : AwtPoint AccFrameSelector::getLocation(  ) throw (RuntimeException, std::exception)
     364             : {
     365           0 :     SolarMutexGuard aGuard;
     366           0 :     IsValid();
     367           0 :     Point aPos;
     368           0 :     switch(meBorder)
     369             :     {
     370             :         case FRAMEBORDER_NONE:
     371           0 :             aPos = mpFrameSel->GetPosPixel();
     372           0 :         break;
     373             :         default:
     374           0 :             const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
     375           0 :             aPos = aSpot.TopLeft();
     376             :     }
     377           0 :     AwtPoint aRet(aPos.X(), aPos.Y());
     378           0 :     return aRet;
     379             : }
     380             : 
     381             : 
     382             : 
     383           0 : AwtPoint AccFrameSelector::getLocationOnScreen(  ) throw (RuntimeException, std::exception)
     384             : {
     385           0 :     SolarMutexGuard aGuard;
     386           0 :     IsValid();
     387           0 :     Point aPos;
     388           0 :     switch(meBorder)
     389             :     {
     390             :         case FRAMEBORDER_NONE:
     391           0 :             aPos = mpFrameSel->GetPosPixel();
     392           0 :         break;
     393             :         default:
     394           0 :             const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
     395           0 :             aPos = aSpot.TopLeft();
     396             :     }
     397           0 :     aPos = mpFrameSel->OutputToAbsoluteScreenPixel( aPos );
     398           0 :     AwtPoint aRet(aPos.X(), aPos.Y());
     399           0 :     return aRet;
     400             : }
     401             : 
     402             : 
     403             : 
     404           0 : AwtSize AccFrameSelector::getSize(  ) throw (RuntimeException, std::exception)
     405             : {
     406           0 :     SolarMutexGuard aGuard;
     407           0 :     IsValid();
     408           0 :     Size aSz;
     409           0 :     switch(meBorder)
     410             :     {
     411             :         case FRAMEBORDER_NONE:
     412           0 :             aSz = mpFrameSel->GetSizePixel();
     413           0 :         break;
     414             :         default:
     415           0 :             const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
     416           0 :             aSz = aSpot.GetSize();
     417             :     }
     418           0 :     AwtSize aRet(aSz.Width(), aSz.Height());
     419           0 :     return aRet;
     420             : }
     421             : 
     422             : 
     423             : 
     424           0 : sal_Bool AccFrameSelector::isShowing(  ) throw (RuntimeException)
     425             : {
     426           0 :     SolarMutexGuard aGuard;
     427           0 :     IsValid();
     428           0 :     return sal_True;
     429             : }
     430             : 
     431             : 
     432             : 
     433           0 : sal_Bool AccFrameSelector::isVisible(  ) throw (RuntimeException)
     434             : {
     435           0 :     SolarMutexGuard aGuard;
     436           0 :     IsValid();
     437           0 :     return sal_True;
     438             : }
     439             : 
     440             : 
     441             : 
     442           0 : sal_Bool AccFrameSelector::isFocusTraversable(  ) throw (RuntimeException)
     443             : {
     444           0 :     SolarMutexGuard aGuard;
     445           0 :     IsValid();
     446           0 :     return sal_True;
     447             : }
     448             : 
     449             : 
     450             : 
     451           0 : void AccFrameSelector::addFocusListener( const Reference< XFocusListener >& xListener ) throw (RuntimeException)
     452             : {
     453           0 :     maFocusListeners.addInterface( xListener );
     454           0 : }
     455             : 
     456             : 
     457             : 
     458           0 : void AccFrameSelector::removeFocusListener( const Reference< XFocusListener >& xListener ) throw (RuntimeException)
     459             : {
     460           0 :     maFocusListeners.removeInterface( xListener );
     461           0 : }
     462             : 
     463             : 
     464             : 
     465           0 : void AccFrameSelector::grabFocus(  ) throw (RuntimeException, std::exception)
     466             : {
     467           0 :     SolarMutexGuard aGuard;
     468           0 :     IsValid();
     469           0 :     mpFrameSel->GrabFocus();
     470           0 : }
     471             : 
     472             : 
     473             : 
     474           0 : Any AccFrameSelector::getAccessibleKeyBinding(  ) throw (RuntimeException)
     475             : {
     476           0 :     Any aRet;
     477           0 :     SolarMutexGuard aGuard;
     478           0 :     IsValid();
     479           0 :     Reference< XAccessibleRelationSet > xRet = new utl::AccessibleRelationSetHelper;
     480           0 :     if(meBorder == FRAMEBORDER_NONE)
     481             :     {
     482           0 :         Window* pPrev = mpFrameSel->GetWindow( WINDOW_PREV );
     483           0 :         if(pPrev && WINDOW_FIXEDTEXT == pPrev->GetType())
     484             :         {
     485           0 :             OUString sText = pPrev->GetText();
     486           0 :             sal_Int32 nFound = sText.indexOf(MNEMONIC_CHAR);
     487           0 :             if(-1 != nFound && ++nFound < sText.getLength())
     488             :             {
     489           0 :                 sText = sText.toAsciiUpperCase();
     490           0 :                 sal_Unicode cChar = sText[nFound];
     491           0 :                 AwtKeyEvent aEvent;
     492             : 
     493           0 :                 aEvent.KeyCode = 0;
     494           0 :                 aEvent.KeyChar = cChar;
     495           0 :                 aEvent.KeyFunc = 0;
     496           0 :                 if(cChar >= 'A' && cChar <= 'Z')
     497             :                 {
     498           0 :                      aEvent.KeyCode = AwtKey::A + cChar - 'A';
     499             :                 }
     500           0 :                 aEvent.Modifiers = AwtKeyModifier::MOD2;
     501           0 :                 aRet <<= aEvent;
     502           0 :             }
     503             :         }
     504             :     }
     505           0 :     return aRet;
     506             : }
     507             : 
     508             : 
     509             : 
     510           0 : sal_Int32 AccFrameSelector::getForeground(  )
     511             :         throw (RuntimeException, std::exception)
     512             : {
     513           0 :     SolarMutexGuard aGuard;
     514           0 :     IsValid();
     515           0 :     return mpFrameSel->GetControlForeground().GetColor();
     516             : }
     517             : 
     518             : 
     519             : 
     520           0 : sal_Int32 AccFrameSelector::getBackground(  )
     521             :         throw (RuntimeException, std::exception)
     522             : {
     523           0 :     SolarMutexGuard aGuard;
     524           0 :     IsValid();
     525           0 :     return mpFrameSel->GetControlBackground().GetColor();
     526             : }
     527             : 
     528             : 
     529             : 
     530           0 : void AccFrameSelector::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) throw (RuntimeException, std::exception)
     531             : {
     532           0 :     SolarMutexGuard aGuard;
     533             : 
     534           0 :     if ( xListener.is() )
     535             :     {
     536           0 :         if ( !mnClientId )
     537             :         {
     538           0 :             mnClientId = ::comphelper::AccessibleEventNotifier::registerClient();
     539             :         }
     540           0 :         ::comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
     541           0 :     }
     542           0 : }
     543             : 
     544             : 
     545             : 
     546           0 : void AccFrameSelector::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) throw (RuntimeException, std::exception)
     547             : {
     548           0 :     SolarMutexGuard aGuard;
     549             : 
     550           0 :     if ( xListener.is() && mnClientId != 0 &&
     551           0 :          ::comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener ) == 0 )
     552             :     {
     553             :         // no listeners anymore
     554             :         // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
     555             :         // and at least to us not firing any events anymore, in case somebody calls
     556             :         // NotifyAccessibleEvent, again
     557           0 :         ::comphelper::AccessibleEventNotifier::TClientId nId( mnClientId );
     558           0 :         mnClientId = 0;
     559           0 :         ::comphelper::AccessibleEventNotifier::revokeClient( nId );
     560           0 :     }
     561           0 : }
     562             : 
     563           0 : OUString AccFrameSelector::getImplementationName(  ) throw (RuntimeException, std::exception)
     564             : {
     565           0 :     return OUString("AccFrameSelector");
     566             : }
     567             : 
     568           0 : sal_Bool AccFrameSelector::supportsService( const OUString& rServiceName )
     569             :     throw (RuntimeException, std::exception)
     570             : {
     571           0 :     return cppu::supportsService(this, rServiceName);
     572             : }
     573             : 
     574           0 : Sequence< OUString > AccFrameSelector::getSupportedServiceNames(  )
     575             :     throw (RuntimeException, std::exception)
     576             : {
     577           0 :     Sequence< OUString > aRet(3);
     578           0 :     OUString* pArray = aRet.getArray();
     579           0 :     pArray[0] = "Accessible";
     580           0 :     pArray[1] = "AccessibleContext";
     581           0 :     pArray[2] = "AccessibleComponent";
     582           0 :     return aRet;
     583             : }
     584             : 
     585           0 : void AccFrameSelector::IsValid() throw (RuntimeException)
     586             : {
     587           0 :     if(!mpFrameSel)
     588           0 :         throw RuntimeException();
     589           0 : }
     590             : 
     591           0 : void    AccFrameSelector::NotifyFocusListeners(sal_Bool bGetFocus)
     592             : {
     593           0 :     SolarMutexGuard aGuard;
     594           0 :     AwtFocusEvent aEvent;
     595           0 :     aEvent.FocusFlags = 0;
     596           0 :     if(bGetFocus)
     597             :     {
     598           0 :         sal_uInt16 nFocusFlags = mpFrameSel->GetGetFocusFlags();
     599           0 :         if(nFocusFlags&GETFOCUS_TAB)
     600           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::TAB;
     601           0 :         if(nFocusFlags&GETFOCUS_CURSOR)
     602           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::CURSOR;
     603           0 :         if(nFocusFlags&GETFOCUS_MNEMONIC)
     604           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::MNEMONIC;
     605           0 :         if(nFocusFlags&GETFOCUS_FORWARD)
     606           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::FORWARD;
     607           0 :         if(nFocusFlags&GETFOCUS_BACKWARD)
     608           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::BACKWARD;
     609           0 :         if(nFocusFlags&GETFOCUS_AROUND)
     610           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::AROUND;
     611           0 :         if(nFocusFlags&GETFOCUS_UNIQUEMNEMONIC)
     612           0 :             aEvent.FocusFlags |= AwtFocusChangeReason::UNIQUEMNEMONIC;
     613             :     }
     614           0 :     aEvent.Temporary = sal_False;
     615             : 
     616           0 :     Reference < XAccessibleContext > xThis( this );
     617           0 :     aEvent.Source = xThis;
     618             : 
     619           0 :     ::cppu::OInterfaceIteratorHelper aIter( maFocusListeners );
     620           0 :     while( aIter.hasMoreElements() )
     621             :     {
     622           0 :         Reference < XFocusListener > xListener( aIter.next(), UNO_QUERY );
     623           0 :         if(bGetFocus)
     624           0 :             xListener->focusGained( aEvent );
     625             :         else
     626           0 :             xListener->focusLost( aEvent );
     627           0 :     }
     628           0 : }
     629             : 
     630             : 
     631             : 
     632           0 : IMPL_LINK( AccFrameSelector, WindowEventListener, VclSimpleEvent*, pEvent )
     633             : {
     634           0 :     VclWindowEvent* pWinEvent = dynamic_cast< VclWindowEvent* >( pEvent );
     635             :     DBG_ASSERT( pWinEvent, "AccFrameSelector::WindowEventListener - unknown window event" );
     636           0 :     if ( pWinEvent )
     637             :     {
     638           0 :         Window* pWindow = pWinEvent->GetWindow();
     639             :         DBG_ASSERT( pWindow, "AccFrameSelector::WindowEventListener: no window!" );
     640           0 :         if ( !pWindow->IsAccessibilityEventsSuppressed() || ( pWinEvent->GetId() == VCLEVENT_OBJECT_DYING ) )
     641             :         {
     642           0 :             ProcessWindowEvent( *pWinEvent );
     643             :         }
     644             :     }
     645             : 
     646           0 :     return 0;
     647             : }
     648             : 
     649             : 
     650             : 
     651           0 : void AccFrameSelector::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
     652             : {
     653           0 :     switch ( rVclWindowEvent.GetId() )
     654             :     {
     655             :         case VCLEVENT_WINDOW_GETFOCUS:
     656             :         {
     657           0 :             if ( meBorder == FRAMEBORDER_NONE )
     658             :             {
     659           0 :                 Any aOldValue, aNewValue;
     660           0 :                 aNewValue <<= AccessibleStateType::FOCUSED;
     661           0 :                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
     662             :             }
     663             :         }
     664           0 :         break;
     665             :         case VCLEVENT_WINDOW_LOSEFOCUS:
     666             :         {
     667           0 :             if ( meBorder == FRAMEBORDER_NONE )
     668             :             {
     669           0 :                 Any aOldValue, aNewValue;
     670           0 :                 aOldValue <<= AccessibleStateType::FOCUSED;
     671           0 :                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
     672             :             }
     673             :         }
     674           0 :         break;
     675             :         default:
     676             :         {
     677             :         }
     678           0 :         break;
     679             :     }
     680           0 : }
     681             : 
     682             : 
     683             : 
     684           0 : void AccFrameSelector::NotifyAccessibleEvent( const sal_Int16 _nEventId,
     685             :     const Any& _rOldValue, const Any& _rNewValue )
     686             : {
     687           0 :     if ( mnClientId )
     688             :     {
     689           0 :         Reference< XInterface > xSource( *this );
     690           0 :         AccessibleEventObject aEvent( xSource, _nEventId, _rNewValue, _rOldValue );
     691           0 :         ::comphelper::AccessibleEventNotifier::addEvent( mnClientId, aEvent );
     692             :     }
     693           0 : }
     694             : 
     695             : 
     696             : 
     697           0 : void AccFrameSelector::Invalidate()
     698             : {
     699           0 :     RemoveFrameSelEventListener();
     700           0 :     mpFrameSel = 0;
     701           0 :     EventObject aEvent;
     702           0 :     Reference < XAccessibleContext > xThis( this );
     703           0 :     aEvent.Source = xThis;
     704           0 :     maFocusListeners.disposeAndClear( aEvent );
     705           0 :     maPropertyListeners.disposeAndClear( aEvent );
     706           0 : }
     707             : 
     708             : 
     709             : 
     710             : } // namespace a11y
     711             : } // namespace svx
     712             : 
     713             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10