/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
#include "AccessibleFrameSelector.hxx"
#include <com/sun/star/awt/KeyEvent.hpp>
#include <com/sun/star/awt/KeyModifier.hpp>
#include <com/sun/star/awt/Key.hpp>
#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HDL_
#include <com/sun/star/accessibility/AccessibleStateType.hpp>
#endif
#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLERELATIONTYPE_HDL_
#include <com/sun/star/accessibility/AccessibleRelationType.hpp>
#endif
#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEROLE_HDL_
#include <com/sun/star/accessibility/AccessibleRole.hpp>
#endif
#include <com/sun/star/accessibility/AccessibleEventId.hpp>
#include <com/sun/star/awt/FocusChangeReason.hpp>
#include <unotools/accessiblestatesethelper.hxx>
#include <unotools/accessiblerelationsethelper.hxx>
#include <vos/mutex.hxx>
#include <vcl/svapp.hxx>
#include <svx/frmsel.hxx>
#include <svx/dialmgr.hxx>
#include "editeng/unolingu.hxx"
#ifndef _SVX_DIALOGS_HRC
#include <svx/dialogs.hrc>
#endif
#ifndef SVX_FRMSEL_HRC
#include "frmsel.hrc"
#endif
#ifndef MNEMONIC_CHAR
#define MNEMONIC_CHAR ((sal_Unicode)'~')
#endif
namespace svx {
namespace a11y {
using ::rtl::OUString;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::UNO_QUERY;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::uno::RuntimeException;
using ::com::sun::star::uno::XInterface;
using ::com::sun::star::lang::Locale;
using ::com::sun::star::lang::EventObject;
using ::com::sun::star::beans::XPropertyChangeListener;
using ::com::sun::star::awt::XFocusListener;
using namespace ::com::sun::star::accessibility;
namespace AwtKey = ::com::sun::star::awt::Key;
namespace AwtKeyModifier = ::com::sun::star::awt::KeyModifier;
namespace AwtFocusChangeReason = ::com::sun::star::awt::FocusChangeReason;
typedef ::com::sun::star::awt::Point AwtPoint;
typedef ::com::sun::star::awt::Size AwtSize;
typedef ::com::sun::star::awt::Rectangle AwtRectangle;
typedef ::com::sun::star::awt::KeyEvent AwtKeyEvent;
typedef ::com::sun::star::awt::FocusEvent AwtFocusEvent;
// ============================================================================
AccFrameSelector::AccFrameSelector( FrameSelector& rFrameSel, FrameBorderType eBorder ) :
Resource( SVX_RES( RID_SVXSTR_BORDER_CONTROL ) ),
mpFrameSel( &rFrameSel ),
meBorder( eBorder ),
maFocusListeners( maFocusMutex ),
maPropertyListeners( maPropertyMutex ),
maNames( SVX_RES( ARR_TEXTS ) ),
maDescriptions( SVX_RES(ARR_DESCRIPTIONS ) ),
mnClientId( 0 )
{
FreeResource();
if ( mpFrameSel )
{
mpFrameSel->AddEventListener( LINK( this, AccFrameSelector, WindowEventListener ) );
}
}
// ----------------------------------------------------------------------------
AccFrameSelector::~AccFrameSelector()
{
if ( mpFrameSel )
{
mpFrameSel->RemoveEventListener( LINK( this, AccFrameSelector, WindowEventListener ) );
}
}
// ----------------------------------------------------------------------------
Reference< XAccessibleContext > AccFrameSelector::getAccessibleContext( )
throw (RuntimeException)
{
return this;
}
// ----------------------------------------------------------------------------
sal_Int32 AccFrameSelector::getAccessibleChildCount( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return (meBorder == FRAMEBORDER_NONE) ? mpFrameSel->GetEnabledBorderCount() : 0;
}
// ----------------------------------------------------------------------------
Reference< XAccessible > AccFrameSelector::getAccessibleChild( sal_Int32 i )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
Reference< XAccessible > xRet;
if( meBorder == FRAMEBORDER_NONE )
xRet = mpFrameSel->GetChildAccessible( i );
if( !xRet.is() )
throw RuntimeException();
return xRet;
}
// ----------------------------------------------------------------------------
Reference< XAccessible > AccFrameSelector::getAccessibleParent( )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
Reference< XAccessible > xRet;
if(meBorder == FRAMEBORDER_NONE)
xRet = mpFrameSel->GetParent()->GetAccessible( sal_True );
else
xRet = mpFrameSel->CreateAccessible();
return xRet;
}
// ----------------------------------------------------------------------------
sal_Int32 AccFrameSelector::getAccessibleIndexInParent( )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
sal_Int32 nIdx = 0;
if( meBorder == FRAMEBORDER_NONE )
{
Window* pTabPage = mpFrameSel->GetParent();
sal_Int32 nChildren = pTabPage->GetChildCount();
for( nIdx = 0; nIdx < nChildren; ++nIdx )
if( pTabPage->GetChild( static_cast< sal_uInt16 >( nIdx ) ) == mpFrameSel )
break;
}
else
nIdx = mpFrameSel->GetEnabledBorderIndex( meBorder );
if( nIdx < 0 )
throw RuntimeException();
return nIdx;
}
// ----------------------------------------------------------------------------
sal_Int16 AccFrameSelector::getAccessibleRole( ) throw (RuntimeException)
{
// return AccessibleRole::OPTION_PANE;
//IAccessibility2 Implementation 2009-----
return meBorder == FRAMEBORDER_NONE ? AccessibleRole::OPTION_PANE : AccessibleRole::CHECK_BOX;
//-----IAccessibility2 Implementation 2009
}
// ----------------------------------------------------------------------------
OUString AccFrameSelector::getAccessibleDescription( )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return maDescriptions.GetString(meBorder);
}
// ----------------------------------------------------------------------------
OUString AccFrameSelector::getAccessibleName( )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return maNames.GetString(meBorder);
}
// ----------------------------------------------------------------------------
Reference< XAccessibleRelationSet > AccFrameSelector::getAccessibleRelationSet( )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
utl::AccessibleRelationSetHelper* pHelper;
Reference< XAccessibleRelationSet > xRet = pHelper = new utl::AccessibleRelationSetHelper;
//if(meBorder == FRAMEBORDER_NONE)
//{
// //add the label relation
// Window* pPrev = mpFrameSel->GetWindow( WINDOW_PREV );
// if(pPrev && WINDOW_FIXEDTEXT == pPrev->GetType())
// {
// AccessibleRelation aLabelRelation;
// aLabelRelation.RelationType = AccessibleRelationType::LABELED_BY;
// aLabelRelation.TargetSet.realloc(1);
// aLabelRelation.TargetSet.getArray()[0] = pPrev->GetAccessible();
// pHelper->AddRelation(aLabelRelation);
// }
//}
//IAccessibility2 Implementation 2009-----
if(meBorder == FRAMEBORDER_NONE)
{
//add the label relation
Window *pLabeledBy = mpFrameSel->GetAccessibleRelationLabeledBy();
if ( pLabeledBy && pLabeledBy != mpFrameSel )
{
AccessibleRelation aLabelRelation;
aLabelRelation.RelationType = AccessibleRelationType::LABELED_BY;
aLabelRelation.TargetSet.realloc(1);
aLabelRelation.TargetSet.getArray()[0] = pLabeledBy->GetAccessible();
pHelper->AddRelation(aLabelRelation);
}
Window* pMemberOf = mpFrameSel->GetAccessibleRelationMemberOf();
if ( pMemberOf && pMemberOf != mpFrameSel )
{
AccessibleRelation aMemberOfRelation;
aMemberOfRelation.RelationType = AccessibleRelationType::MEMBER_OF;
aMemberOfRelation.TargetSet.realloc(1);
aMemberOfRelation.TargetSet.getArray()[0] = pMemberOf->GetAccessible();
pHelper->AddRelation(aMemberOfRelation);
}
}
//-----IAccessibility2 Implementation 2009
return xRet;
}
// ----------------------------------------------------------------------------
Reference< XAccessibleStateSet > AccFrameSelector::getAccessibleStateSet( )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
Reference< XAccessibleStateSet > xRet = pStateSetHelper;
if(!mpFrameSel)
pStateSetHelper->AddState(AccessibleStateType::DEFUNC);
else
{
const sal_Int16 aStandardStates[] =
{
AccessibleStateType::EDITABLE,
AccessibleStateType::FOCUSABLE,
AccessibleStateType::MULTI_SELECTABLE,
AccessibleStateType::SELECTABLE,
AccessibleStateType::SHOWING,
AccessibleStateType::VISIBLE,
AccessibleStateType::OPAQUE,
0};
sal_Int16 nState = 0;
while(aStandardStates[nState])
{
pStateSetHelper->AddState(aStandardStates[nState++]);
}
if(mpFrameSel->IsEnabled())
{
pStateSetHelper->AddState(AccessibleStateType::ENABLED);
pStateSetHelper->AddState(AccessibleStateType::SENSITIVE);
}
sal_Bool bIsParent = meBorder == FRAMEBORDER_NONE;
if(mpFrameSel->HasFocus() &&
(bIsParent || mpFrameSel->IsBorderSelected(meBorder)))
{
pStateSetHelper->AddState(AccessibleStateType::ACTIVE);
pStateSetHelper->AddState(AccessibleStateType::FOCUSED);
pStateSetHelper->AddState(AccessibleStateType::SELECTED);
}
}
return xRet;
}
// ----------------------------------------------------------------------------
Locale AccFrameSelector::getLocale( )
throw (IllegalAccessibleComponentStateException, RuntimeException)
{
Locale aRet;
SvxLanguageToLocale( aRet, Application::GetSettings().GetUILanguage() );
return aRet;
}
// ----------------------------------------------------------------------------
void AccFrameSelector::addPropertyChangeListener(
const Reference< XPropertyChangeListener >& xListener )
throw (RuntimeException)
{
maPropertyListeners.addInterface( xListener );
}
// ----------------------------------------------------------------------------
void AccFrameSelector::removePropertyChangeListener( const Reference< XPropertyChangeListener >& xListener )
throw (RuntimeException)
{
maPropertyListeners.removeInterface( xListener );
}
// ----------------------------------------------------------------------------
sal_Bool AccFrameSelector::containsPoint( const AwtPoint& aPt )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
//aPt is relative to the frame selector
return mpFrameSel->ContainsClickPoint( Point( aPt.X, aPt.Y ) );
}
// ----------------------------------------------------------------------------
Reference< XAccessible > AccFrameSelector::getAccessibleAtPoint(
const AwtPoint& aPt )
throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
//aPt is relative to the frame selector
return mpFrameSel->GetChildAccessible( Point( aPt.X, aPt.Y ) );
}
AwtRectangle AccFrameSelector::getBounds( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
Size aSz;
Point aPos;
switch(meBorder)
{
case FRAMEBORDER_NONE:
aSz = mpFrameSel->GetSizePixel();
aPos = mpFrameSel->GetPosPixel();
break;
default:
const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
aPos = aSpot.TopLeft();
aSz = aSpot.GetSize();
}
AwtRectangle aRet;
aRet.X = aPos.X();
aRet.Y = aPos.Y();
aRet.Width = aSz.Width();
aRet.Height = aSz.Height();
return aRet;
}
// ----------------------------------------------------------------------------
AwtPoint AccFrameSelector::getLocation( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
Point aPos;
switch(meBorder)
{
case FRAMEBORDER_NONE:
aPos = mpFrameSel->GetPosPixel();
break;
default:
const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
aPos = aSpot.TopLeft();
}
AwtPoint aRet(aPos.X(), aPos.Y());
return aRet;
}
// ----------------------------------------------------------------------------
AwtPoint AccFrameSelector::getLocationOnScreen( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
Point aPos;
switch(meBorder)
{
case FRAMEBORDER_NONE:
aPos = mpFrameSel->GetPosPixel();
break;
default:
const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
aPos = aSpot.TopLeft();
}
aPos = mpFrameSel->OutputToAbsoluteScreenPixel( aPos );
AwtPoint aRet(aPos.X(), aPos.Y());
return aRet;
}
// ----------------------------------------------------------------------------
AwtSize AccFrameSelector::getSize( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
Size aSz;
switch(meBorder)
{
case FRAMEBORDER_NONE:
aSz = mpFrameSel->GetSizePixel();
break;
default:
const Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder );
aSz = aSpot.GetSize();
}
AwtSize aRet(aSz.Width(), aSz.Height());
return aRet;
}
// ----------------------------------------------------------------------------
sal_Bool AccFrameSelector::isShowing( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return sal_True;
}
// ----------------------------------------------------------------------------
sal_Bool AccFrameSelector::isVisible( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return sal_True;
}
// ----------------------------------------------------------------------------
sal_Bool AccFrameSelector::isFocusTraversable( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return sal_True;
}
// ----------------------------------------------------------------------------
void AccFrameSelector::addFocusListener( const Reference< XFocusListener >& xListener ) throw (RuntimeException)
{
maFocusListeners.addInterface( xListener );
}
// ----------------------------------------------------------------------------
void AccFrameSelector::removeFocusListener( const Reference< XFocusListener >& xListener ) throw (RuntimeException)
{
maFocusListeners.removeInterface( xListener );
}
// ----------------------------------------------------------------------------
void AccFrameSelector::grabFocus( ) throw (RuntimeException)
{
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
mpFrameSel->GrabFocus();
}
// ----------------------------------------------------------------------------
Any AccFrameSelector::getAccessibleKeyBinding( ) throw (RuntimeException)
{
Any aRet;
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
utl::AccessibleRelationSetHelper* pHelper;
Reference< XAccessibleRelationSet > xRet = pHelper = new utl::AccessibleRelationSetHelper;
if(meBorder == FRAMEBORDER_NONE)
{
Window* pPrev = mpFrameSel->GetWindow( WINDOW_PREV );
if(pPrev && WINDOW_FIXEDTEXT == pPrev->GetType())
{
String sText = pPrev->GetText();
xub_StrLen nFound = sText.Search( MNEMONIC_CHAR );
if(STRING_NOTFOUND != nFound && ++nFound < sText.Len())
{
sText.ToUpperAscii();
sal_Unicode cChar = sText.GetChar(nFound);
AwtKeyEvent aEvent;
aEvent.KeyCode = 0;
aEvent.KeyChar = cChar;
aEvent.KeyFunc = 0;
if(cChar >= 'A' && cChar <= 'Z')
{
aEvent.KeyCode = AwtKey::A + cChar - 'A';
}
aEvent.Modifiers = AwtKeyModifier::MOD2;
aRet <<= aEvent;
}
}
}
return aRet;
}
// ----------------------------------------------------------------------------
sal_Int32 AccFrameSelector::getForeground( )
throw (RuntimeException)
{
Any aRet;
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return mpFrameSel->GetControlForeground().GetColor();
}
// ----------------------------------------------------------------------------
sal_Int32 AccFrameSelector::getBackground( )
throw (RuntimeException)
{
Any aRet;
vos::OGuard aGuard(Application::GetSolarMutex());
IsValid();
return mpFrameSel->GetControlBackground().GetColor();
}
// ----------------------------------------------------------------------------
void AccFrameSelector::addEventListener( const Reference< XAccessibleEventListener >& xListener ) throw (RuntimeException)
{
vos::OGuard aGuard( Application::GetSolarMutex() );
if ( xListener.is() )
{
if ( !mnClientId )
{
mnClientId = ::comphelper::AccessibleEventNotifier::registerClient();
}
::comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener );
}
}
// ----------------------------------------------------------------------------
void AccFrameSelector::removeEventListener( const Reference< XAccessibleEventListener >& xListener ) throw (RuntimeException)
{
vos::OGuard aGuard( Application::GetSolarMutex() );
if ( xListener.is() && mnClientId != 0 &&
::comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener ) == 0 )
{
// no listeners anymore
// -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
// and at least to us not firing any events anymore, in case somebody calls
// NotifyAccessibleEvent, again
::comphelper::AccessibleEventNotifier::TClientId nId( mnClientId );
mnClientId = 0;
::comphelper::AccessibleEventNotifier::revokeClient( nId );
}
}
// ----------------------------------------------------------------------------
OUString AccFrameSelector::getImplementationName( ) throw (RuntimeException)
{
return OUString::createFromAscii("AccFrameSelector");
}
// ----------------------------------------------------------------------------
const sal_Char sAccessible[] = "Accessible";
const sal_Char sAccessibleContext[] = "AccessibleContext";
const sal_Char sAccessibleComponent[] = "AccessibleComponent";
sal_Bool AccFrameSelector::supportsService( const OUString& rServiceName )
throw (RuntimeException)
{
return rServiceName.equalsAsciiL( sAccessible , sizeof(sAccessible )-1 ) ||
rServiceName.equalsAsciiL( sAccessibleContext , sizeof(sAccessibleContext )-1 ) ||
rServiceName.equalsAsciiL( sAccessibleComponent, sizeof(sAccessibleComponent)-1 );
}
// ----------------------------------------------------------------------------
Sequence< OUString > AccFrameSelector::getSupportedServiceNames( )
throw (RuntimeException)
{
Sequence< OUString > aRet(3);
OUString* pArray = aRet.getArray();
pArray[0] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessible ) );
pArray[1] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleContext ) );
pArray[2] = OUString( RTL_CONSTASCII_USTRINGPARAM(sAccessibleComponent) );
return aRet;
}
// ----------------------------------------------------------------------------
void AccFrameSelector::IsValid() throw (RuntimeException)
{
if(!mpFrameSel)
throw RuntimeException();
}
// ----------------------------------------------------------------------------
void AccFrameSelector::NotifyFocusListeners(sal_Bool bGetFocus)
{
vos::OGuard aGuard(Application::GetSolarMutex());
AwtFocusEvent aEvent;
aEvent.FocusFlags = 0;
if(bGetFocus)
{
sal_uInt16 nFocusFlags = mpFrameSel->GetGetFocusFlags();
if(nFocusFlags&GETFOCUS_TAB)
aEvent.FocusFlags |= AwtFocusChangeReason::TAB;
if(nFocusFlags&GETFOCUS_CURSOR)
aEvent.FocusFlags |= AwtFocusChangeReason::CURSOR;
if(nFocusFlags&GETFOCUS_MNEMONIC)
aEvent.FocusFlags |= AwtFocusChangeReason::MNEMONIC;
if(nFocusFlags&GETFOCUS_FORWARD)
aEvent.FocusFlags |= AwtFocusChangeReason::FORWARD;
if(nFocusFlags&GETFOCUS_BACKWARD)
aEvent.FocusFlags |= AwtFocusChangeReason::BACKWARD;
if(nFocusFlags&GETFOCUS_AROUND)
aEvent.FocusFlags |= AwtFocusChangeReason::AROUND;
if(nFocusFlags&GETFOCUS_UNIQUEMNEMONIC)
aEvent.FocusFlags |= AwtFocusChangeReason::UNIQUEMNEMONIC;
// if(nFocusFlags&GETFOCUS_INIT)
// aEvent.FocusFlags |= AwtFocusChangeReason::
}
// else
//how can I find the current focus window?
// aEvent.NextFocus = ;
aEvent.Temporary = sal_False;
Reference < XAccessibleContext > xThis( this );
aEvent.Source = xThis;
::cppu::OInterfaceIteratorHelper aIter( maFocusListeners );
while( aIter.hasMoreElements() )
{
Reference < XFocusListener > xListener( aIter.next(), UNO_QUERY );
if(bGetFocus)
xListener->focusGained( aEvent );
else
xListener->focusLost( aEvent );
}
}
// ----------------------------------------------------------------------------
IMPL_LINK( AccFrameSelector, WindowEventListener, VclSimpleEvent*, pEvent )
{
VclWindowEvent* pWinEvent = dynamic_cast< VclWindowEvent* >( pEvent );
DBG_ASSERT( pWinEvent, "AccFrameSelector::WindowEventListener - unknown window event" );
if ( pWinEvent )
{
Window* pWindow = pWinEvent->GetWindow();
DBG_ASSERT( pWindow, "AccFrameSelector::WindowEventListener: no window!" );
if ( !pWindow->IsAccessibilityEventsSuppressed() || ( pWinEvent->GetId() == VCLEVENT_OBJECT_DYING ) )
{
ProcessWindowEvent( *pWinEvent );
}
}
return 0;
}
// ----------------------------------------------------------------------------
void AccFrameSelector::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
{
switch ( rVclWindowEvent.GetId() )
{
case VCLEVENT_WINDOW_GETFOCUS:
{
if ( meBorder == FRAMEBORDER_NONE )
{
Any aOldValue, aNewValue;
aNewValue <<= AccessibleStateType::FOCUSED;
NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
}
}
break;
case VCLEVENT_WINDOW_LOSEFOCUS:
{
if ( meBorder == FRAMEBORDER_NONE )
{
Any aOldValue, aNewValue;
aOldValue <<= AccessibleStateType::FOCUSED;
NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
}
}
break;
default:
{
}
break;
}
}
// ----------------------------------------------------------------------------
void AccFrameSelector::NotifyAccessibleEvent( const sal_Int16 _nEventId,
const Any& _rOldValue, const Any& _rNewValue )
{
if ( mnClientId )
{
Reference< XInterface > xSource( *this );
AccessibleEventObject aEvent( xSource, _nEventId, _rNewValue, _rOldValue );
::comphelper::AccessibleEventNotifier::addEvent( mnClientId, aEvent );
}
}
// ----------------------------------------------------------------------------
void AccFrameSelector::Invalidate()
{
if ( mpFrameSel )
{
mpFrameSel->RemoveEventListener( LINK( this, AccFrameSelector, WindowEventListener ) );
}
mpFrameSel = 0;
EventObject aEvent;
Reference < XAccessibleContext > xThis( this );
aEvent.Source = xThis;
maFocusListeners.disposeAndClear( aEvent );
maPropertyListeners.disposeAndClear( aEvent );
}
// ============================================================================
} // namespace a11y
} // namespace svx