diff options
Diffstat (limited to 'svx/source/accessibility')
24 files changed, 10419 insertions, 0 deletions
diff --git a/svx/source/accessibility/AccessibleControlShape.cxx b/svx/source/accessibility/AccessibleControlShape.cxx new file mode 100644 index 000000000..45b7edd75 --- /dev/null +++ b/svx/source/accessibility/AccessibleControlShape.cxx @@ -0,0 +1,879 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svx/AccessibleControlShape.hxx> +#include <svx/AccessibleShapeInfo.hxx> +#include <DescriptionGenerator.hxx> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/drawing/XControlShape.hpp> +#include <com/sun/star/accessibility/AccessibleRelationType.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/reflection/ProxyFactory.hpp> +#include <com/sun/star/util/XModeChangeBroadcaster.hpp> +#include <com/sun/star/container/XContainer.hpp> +#include <comphelper/processfactory.hxx> +#include <comphelper/property.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <svx/IAccessibleParent.hxx> +#include <svx/svdouno.hxx> +#include <svx/ShapeTypeHandler.hxx> +#include <svx/SvxShapeTypes.hxx> +#include <comphelper/accessiblewrapper.hxx> +#include <svx/svdview.hxx> +#include <svx/svdpagv.hxx> +#include <svx/strings.hrc> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <sal/log.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> + +using namespace ::accessibility; +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::reflection; +using namespace ::com::sun::star::drawing; +using namespace ::com::sun::star::container; + +namespace +{ + OUString lcl_getNamePropertyName( ) + { + return "Name"; + } + OUString lcl_getDescPropertyName( ) + { + return "HelpText"; + } + OUString lcl_getLabelPropertyName( ) + { + return "Label"; + } + OUString lcl_getLabelControlPropertyName( ) + { + return "LabelControl"; + } + // return the property which should be used as AccessibleName + OUString lcl_getPreferredAccNameProperty( const Reference< XPropertySetInfo >& _rxPSI ) + { + if ( _rxPSI.is() && _rxPSI->hasPropertyByName( lcl_getLabelPropertyName() ) ) + return lcl_getLabelPropertyName(); + else + return lcl_getNamePropertyName(); + } + + // determines whether or not a state which belongs to the inner context needs to be forwarded to the "composed" + // context + bool isComposedState( const sal_Int16 _nState ) + { + return ( ( AccessibleStateType::INVALID != _nState ) + && ( AccessibleStateType::DEFUNC != _nState ) + && ( AccessibleStateType::ICONIFIED != _nState ) + && ( AccessibleStateType::RESIZABLE != _nState ) + && ( AccessibleStateType::SELECTABLE != _nState ) + && ( AccessibleStateType::SHOWING != _nState ) + && ( AccessibleStateType::MANAGES_DESCENDANTS != _nState ) + && ( AccessibleStateType::VISIBLE != _nState ) + ); + } + + /// determines whether the given control is in alive mode + bool isAliveMode( const Reference< XControl >& _rxControl ) + { + OSL_PRECOND( _rxControl.is(), "AccessibleControlShape::isAliveMode: invalid control" ); + return _rxControl.is() && !_rxControl->isDesignMode(); + } +} + +AccessibleControlShape::AccessibleControlShape ( + const AccessibleShapeInfo& rShapeInfo, + const AccessibleShapeTreeInfo& rShapeTreeInfo) + : AccessibleShape (rShapeInfo, rShapeTreeInfo) + , m_bListeningForName( false ) + , m_bListeningForDesc( false ) + , m_bMultiplexingStates( false ) + , m_bDisposeNativeContext( false ) + , m_bWaitingForControl( false ) +{ + m_pChildManager = new comphelper::OWrappedAccessibleChildrenManager( comphelper::getProcessComponentContext() ); + + osl_atomic_increment( &m_refCount ); + { + m_pChildManager->setOwningAccessible( this ); + } + osl_atomic_decrement( &m_refCount ); +} + +AccessibleControlShape::~AccessibleControlShape() +{ + m_pChildManager.clear(); + + if ( m_xControlContextProxy.is() ) + m_xControlContextProxy->setDelegator( nullptr ); + m_xControlContextProxy.clear(); + m_xControlContextTypeAccess.clear(); + m_xControlContextComponent.clear(); + // this should remove the _only_ three "real" reference (means not delegated to + // ourself) to this proxy, and thus delete it +} + +namespace { + Reference< XContainer > lcl_getControlContainer( const OutputDevice* _pWin, const SdrView* _pView ) + { + Reference< XContainer > xReturn; + DBG_ASSERT( _pView, "lcl_getControlContainer: invalid view!" ); + if ( _pView && _pView->GetSdrPageView()) + { + xReturn.set(_pView->GetSdrPageView()->GetControlContainer( *_pWin ), css::uno::UNO_QUERY); + } + return xReturn; + } +} + +void AccessibleControlShape::Init() +{ + AccessibleShape::Init(); + + OSL_ENSURE( !m_xControlContextProxy.is(), "AccessibleControlShape::Init: already initialized!" ); + try + { + // What we need to do here is merge the functionality of the AccessibleContext of our UNO control + // with our own AccessibleContext-related functionality. + + // The problem is that we do not know the interfaces our "inner" context supports - this may be any + // XAccessibleXXX interface (or even any other) which makes sense for it. + + // In theory, we could implement all possible interfaces ourself, and re-route all functionality to + // the inner context (except those we implement ourself, like XAccessibleComponent). But this is in no + // way future-proof - as soon as an inner context appears which implements an additional interface, + // we would need to adjust our implementation to support this new interface, too. Bad idea. + + // The usual solution for such a problem is aggregation. Aggregation means using UNO's own mechanism + // for merging an inner with an outer component, and get a component which behaves as it is exactly one. + // This is what XAggregation is for. Unfortunately, aggregation requires _exact_ control over the ref count + // of the inner object, which we do not have at all. + // Bad, too. + + // But there is a solution: com.sun.star.reflection.ProxyFactory. This service is able to create a proxy + // for any component, which supports _exactly_ the same interfaces as the component. In addition, it can + // be aggregated, as by definition the proxy's ref count is exactly 1 when returned from the factory. + // Sounds better. Though this yields the problem of slightly degraded performance, it's the only solution + // I'm aware of at the moment... + + // get the control which belongs to our model (relative to our view) + const vcl::Window* pViewWindow = maShapeTreeInfo.GetWindow(); + SdrUnoObj* pUnoObjectImpl = dynamic_cast<SdrUnoObj*>(SdrObject::getSdrObjectFromXShape(mxShape)); + SdrView* pView = maShapeTreeInfo.GetSdrView(); + OSL_ENSURE( pView && pViewWindow && pUnoObjectImpl, "AccessibleControlShape::Init: no view, or no view window, no SdrUnoObj!" ); + + if ( pView && pViewWindow && pUnoObjectImpl ) + { + // get the context of the control - it will be our "inner" context + m_xUnoControl = pUnoObjectImpl->GetUnoControl( *pView, *pViewWindow->GetOutDev() ); + + if ( !m_xUnoControl.is() ) + { + // the control has not yet been created. Though speaking strictly, it is a bug that + // our instance here is created without an existing control (because an AccessibleControlShape + // is a representation of a view object, and can only live if the view it should represent + // is complete, which implies a living control), it's by far the easiest and most riskless way + // to fix this here in this class. + // Okay, we will add as listener to the control container where we expect our control to appear. + OSL_ENSURE( !m_bWaitingForControl, "AccessibleControlShape::Init: already waiting for the control!" ); + + Reference< XContainer > xControlContainer = lcl_getControlContainer( pViewWindow->GetOutDev(), maShapeTreeInfo.GetSdrView() ); + OSL_ENSURE( xControlContainer.is(), "AccessibleControlShape::Init: unable to find my ControlContainer!" ); + if ( xControlContainer.is() ) + { + xControlContainer->addContainerListener( this ); + m_bWaitingForControl = true; + } + } + else + { + Reference< XModeChangeBroadcaster > xControlModes( m_xUnoControl, UNO_QUERY ); + Reference< XAccessible > xControlAccessible( xControlModes, UNO_QUERY ); + Reference< XAccessibleContext > xNativeControlContext; + if ( xControlAccessible.is() ) + xNativeControlContext = xControlAccessible->getAccessibleContext(); + OSL_ENSURE( xNativeControlContext.is(), "AccessibleControlShape::Init: no AccessibleContext for the control!" ); + m_aControlContext = WeakReference< XAccessibleContext >( xNativeControlContext ); + + // add as listener to the context - we want to multiplex some states + if ( isAliveMode( m_xUnoControl ) && xNativeControlContext.is() ) + { // (but only in alive mode) + startStateMultiplexing( ); + } + + // now that we have all information about our control, do some adjustments + adjustAccessibleRole(); + initializeComposedState(); + + // some initialization for our child manager, which is used in alive mode only + if ( isAliveMode( m_xUnoControl ) ) + { + Reference< XAccessibleStateSet > xStates( getAccessibleStateSet( ) ); + OSL_ENSURE( xStates.is(), "AccessibleControlShape::AccessibleControlShape: no inner state set!" ); + m_pChildManager->setTransientChildren( !xStates.is() || xStates->contains( AccessibleStateType::MANAGES_DESCENDANTS ) ); + } + + // finally, aggregate a proxy for the control context + // first a factory for the proxy + Reference< XProxyFactory > xFactory = ProxyFactory::create( comphelper::getProcessComponentContext() ); + // then the proxy itself + if ( xNativeControlContext.is() ) + { + m_xControlContextProxy = xFactory->createProxy( xNativeControlContext ); + m_xControlContextTypeAccess.set( xNativeControlContext, UNO_QUERY_THROW ); + m_xControlContextComponent.set( xNativeControlContext, UNO_QUERY_THROW ); + + // aggregate the proxy + osl_atomic_increment( &m_refCount ); + if ( m_xControlContextProxy.is() ) + { + // At this point in time, the proxy has a ref count of exactly one - in m_xControlContextProxy. + // Remember to _not_ reset this member unless the delegator of the proxy has been reset, too! + m_xControlContextProxy->setDelegator( *this ); + } + osl_atomic_decrement( &m_refCount ); + + m_bDisposeNativeContext = true; + + // Finally, we need to add ourself as mode listener to the control. In case the mode switches, + // we need to dispose ourself. + xControlModes->addModeChangeListener( this ); + } + } + } + } + catch( const Exception& ) + { + OSL_FAIL( "AccessibleControlShape::Init: could not \"aggregate\" the controls XAccessibleContext!" ); + } +} + +void SAL_CALL AccessibleControlShape::grabFocus() +{ + if ( !m_xUnoControl.is() || !isAliveMode( m_xUnoControl ) ) + { + // in design mode, we simply forward the request to the base class + AccessibleShape::grabFocus(); + } + else + { + Reference< XWindow > xWindow( m_xUnoControl, UNO_QUERY ); + OSL_ENSURE( xWindow.is(), "AccessibleControlShape::grabFocus: invalid control!" ); + if ( xWindow.is() ) + xWindow->setFocus(); + } +} + +OUString SAL_CALL AccessibleControlShape::getImplementationName() +{ + return "com.sun.star.comp.accessibility.AccessibleControlShape"; +} + +OUString AccessibleControlShape::CreateAccessibleBaseName() +{ + OUString sName; + + ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape); + switch (nShapeType) + { + case DRAWING_CONTROL: + sName = "ControlShape"; + break; + default: + sName = "UnknownAccessibleControlShape"; + if (mxShape.is()) + sName += ": " + mxShape->getShapeType(); + } + + return sName; +} + +OUString + AccessibleControlShape::CreateAccessibleDescription() +{ + DescriptionGenerator aDG (mxShape); + ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape); + switch (nShapeType) + { + case DRAWING_CONTROL: + { + // check if we can obtain the "Desc" property from the model + OUString sDesc( getControlModelStringProperty( lcl_getDescPropertyName() ) ); + if ( sDesc.isEmpty() ) + { // no -> use the default + aDG.Initialize (STR_ObjNameSingulUno); + aDG.AddProperty ("ControlBackground", DescriptionGenerator::PropertyType::Color); + aDG.AddProperty ( "ControlBorder", DescriptionGenerator::PropertyType::Integer); + } + // ensure that we are listening to the Name property + m_bListeningForDesc = ensureListeningState( m_bListeningForDesc, true, lcl_getDescPropertyName() ); + } + break; + + default: + aDG.Initialize (u"Unknown accessible control shape"); + if (mxShape.is()) + { + aDG.AppendString (u"service name="); + aDG.AppendString (mxShape->getShapeType()); + } + } + + return aDG(); +} + +IMPLEMENT_FORWARD_REFCOUNT( AccessibleControlShape, AccessibleShape ) +IMPLEMENT_GET_IMPLEMENTATION_ID( AccessibleControlShape ) + +void SAL_CALL AccessibleControlShape::propertyChange( const PropertyChangeEvent& _rEvent ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + // check if it is the name or the description + if ( _rEvent.PropertyName == lcl_getNamePropertyName() + || _rEvent.PropertyName == lcl_getLabelPropertyName() ) + { + SetAccessibleName( + CreateAccessibleName(), + AccessibleContextBase::AutomaticallyCreated); + } + else if ( _rEvent.PropertyName == lcl_getDescPropertyName() ) + { + SetAccessibleDescription( + CreateAccessibleDescription(), + AccessibleContextBase::AutomaticallyCreated); + } +#if OSL_DEBUG_LEVEL > 0 + else + { + OSL_FAIL( "AccessibleControlShape::propertyChange: where did this come from?" ); + } +#endif +} + +Any SAL_CALL AccessibleControlShape::queryInterface( const Type& _rType ) +{ + Any aReturn = AccessibleShape::queryInterface( _rType ); + if ( !aReturn.hasValue() ) + { + aReturn = AccessibleControlShape_Base::queryInterface( _rType ); + if ( !aReturn.hasValue() && m_xControlContextProxy.is() ) + aReturn = m_xControlContextProxy->queryAggregation( _rType ); + } + return aReturn; +} + +Sequence< Type > SAL_CALL AccessibleControlShape::getTypes() +{ + Sequence< Type > aShapeTypes = AccessibleShape::getTypes(); + Sequence< Type > aOwnTypes = AccessibleControlShape_Base::getTypes(); + + Sequence< Type > aAggregateTypes; + if ( m_xControlContextTypeAccess.is() ) + aAggregateTypes = m_xControlContextTypeAccess->getTypes(); + + // remove duplicates + return comphelper::combineSequences(comphelper::concatSequences( aShapeTypes, aOwnTypes), aAggregateTypes ); +} + +void SAL_CALL AccessibleControlShape::notifyEvent( const AccessibleEventObject& _rEvent ) +{ + if ( AccessibleEventId::STATE_CHANGED == _rEvent.EventId ) + { + // multiplex this change + sal_Int16 nLostState( 0 ), nGainedState( 0 ); + _rEvent.OldValue >>= nLostState; + _rEvent.NewValue >>= nGainedState; + + // don't multiplex states which the inner context is not responsible for + if ( isComposedState( nLostState ) ) + AccessibleShape::ResetState( nLostState ); + + if ( isComposedState( nGainedState ) ) + AccessibleShape::SetState( nGainedState ); + } + else + { + AccessibleEventObject aTranslatedEvent( _rEvent ); + + { + ::osl::MutexGuard aGuard( m_aMutex ); + + // let the child manager translate the event + aTranslatedEvent.Source = *this; + m_pChildManager->translateAccessibleEvent( _rEvent, aTranslatedEvent ); + + // see if any of these notifications affect our child manager + m_pChildManager->handleChildNotification( _rEvent ); + } + + FireEvent( aTranslatedEvent ); + } +} + +void SAL_CALL AccessibleControlShape::modeChanged(const ModeChangeEvent& rSource) +{ + // did it come from our inner context (the real one, not it's proxy!)? + SAL_INFO("sw.uno", "AccessibleControlShape::modeChanged"); + Reference<XControl> xSource(rSource.Source, UNO_QUERY); // for faster compare + if(xSource.get() != m_xUnoControl.get()) + { + SAL_WARN("sw.uno", "AccessibleControlShape::modeChanged: where did this come from?"); + return; + } + SolarMutexGuard g; + // If our "pseudo-aggregated" inner context does not live anymore, + // we don't want to live, too. This is accomplished by asking our + // parent to replace this object with a new one. Disposing this + // object and sending notifications about the replacement are in + // the responsibility of our parent. + const bool bReplaced = mpParent->ReplaceChild(this, mxShape, 0, maShapeTreeInfo); + SAL_WARN_IF(!bReplaced, "sw.uno", "AccessibleControlShape::modeChanged: replacing ourselves away did fail"); +} + +void SAL_CALL AccessibleControlShape::disposing (const EventObject& _rSource) +{ + AccessibleShape::disposing( _rSource ); +} + +bool AccessibleControlShape::ensureListeningState( + const bool _bCurrentlyListening, const bool _bNeedNewListening, + const OUString& _rPropertyName ) +{ + if ( ( _bCurrentlyListening == _bNeedNewListening ) || !ensureControlModelAccess() ) + // nothing to do + return _bCurrentlyListening; + + try + { + if ( !m_xModelPropsMeta.is() || m_xModelPropsMeta->hasPropertyByName( _rPropertyName ) ) + { + // add or revoke as listener + if ( _bNeedNewListening ) + m_xControlModel->addPropertyChangeListener( _rPropertyName, static_cast< XPropertyChangeListener* >( this ) ); + else + m_xControlModel->removePropertyChangeListener( _rPropertyName, static_cast< XPropertyChangeListener* >( this ) ); + } + else + OSL_FAIL( "AccessibleControlShape::ensureListeningState: this property does not exist at this model!" ); + } + catch( const Exception& ) + { + OSL_FAIL( "AccessibleControlShape::ensureListeningState: could not change the listening state!" ); + } + + return _bNeedNewListening; +} + +sal_Int32 SAL_CALL AccessibleControlShape::getAccessibleChildCount( ) +{ + if ( !m_xUnoControl.is() ) + return 0; + else if ( !isAliveMode( m_xUnoControl ) ) + // no special action required when in design mode + return AccessibleShape::getAccessibleChildCount( ); + else + { + // in alive mode, we have the full control over our children - they are determined by the children + // of the context of our UNO control + Reference< XAccessibleContext > xControlContext( m_aControlContext ); + OSL_ENSURE( xControlContext.is(), "AccessibleControlShape::getAccessibleChildCount: control context already dead! How this!" ); + return xControlContext.is() ? xControlContext->getAccessibleChildCount() : 0; + } +} + +Reference< XAccessible > SAL_CALL AccessibleControlShape::getAccessibleChild( sal_Int32 i ) +{ + Reference< XAccessible > xChild; + if ( !m_xUnoControl.is() ) + { + throw IndexOutOfBoundsException(); + } + if ( !isAliveMode( m_xUnoControl ) ) + { + // no special action required when in design mode - let the base class handle this + xChild = AccessibleShape::getAccessibleChild( i ); + } + else + { + // in alive mode, we have the full control over our children - they are determined by the children + // of the context of our UNO control + + Reference< XAccessibleContext > xControlContext( m_aControlContext ); + OSL_ENSURE( xControlContext.is(), "AccessibleControlShape::getAccessibleChildCount: control context already dead! How this!" ); + if ( xControlContext.is() ) + { + Reference< XAccessible > xInnerChild( xControlContext->getAccessibleChild( i ) ); + OSL_ENSURE( xInnerChild.is(), "AccessibleControlShape::getAccessibleChild: control context returned nonsense!" ); + if ( xInnerChild.is() ) + { + // we need to wrap this inner child into an own implementation + xChild = m_pChildManager->getAccessibleWrapperFor( xInnerChild ); + } + } + } + +#if OSL_DEBUG_LEVEL > 0 + sal_Int32 nChildIndex = -1; + Reference< XAccessibleContext > xContext; + if ( xChild.is() ) + xContext = xChild->getAccessibleContext( ); + if ( xContext.is() ) + nChildIndex = xContext->getAccessibleIndexInParent( ); + SAL_WARN_IF( nChildIndex != i, "svx", "AccessibleControlShape::getAccessibleChild: index mismatch," + " nChildIndex=" << nChildIndex << " vs i=" << i ); +#endif + return xChild; +} + +Reference< XAccessibleRelationSet > SAL_CALL AccessibleControlShape::getAccessibleRelationSet( ) +{ + rtl::Reference<utl::AccessibleRelationSetHelper> pRelationSetHelper = new utl::AccessibleRelationSetHelper; + ensureControlModelAccess(); + AccessibleControlShape* pCtlAccShape = GetLabeledByControlShape(); + if(pCtlAccShape) + { + Reference < XAccessible > xAcc (pCtlAccShape->getAccessibleContext(), UNO_QUERY); + + css::uno::Sequence< css::uno::Reference< css::uno::XInterface > > aSequence { xAcc }; + if( getAccessibleRole() == AccessibleRole::RADIO_BUTTON ) + { + pRelationSetHelper->AddRelation( AccessibleRelation( AccessibleRelationType::MEMBER_OF, aSequence ) ); + } + else + { + pRelationSetHelper->AddRelation( AccessibleRelation( AccessibleRelationType::LABELED_BY, aSequence ) ); + } + } + return pRelationSetHelper; +} + +OUString AccessibleControlShape::CreateAccessibleName() +{ + ensureControlModelAccess(); + + OUString sName; + sal_Int16 aAccessibleRole = getAccessibleRole(); + if ( aAccessibleRole != AccessibleRole::SHAPE + && aAccessibleRole != AccessibleRole::RADIO_BUTTON ) + { + AccessibleControlShape* pCtlAccShape = GetLabeledByControlShape(); + if(pCtlAccShape) + { + sName = pCtlAccShape->CreateAccessibleName(); + } + } + + if (sName.isEmpty()) + { + // check if we can obtain the "Name" resp. "Label" property from the model + const OUString& rAccNameProperty = lcl_getPreferredAccNameProperty( m_xModelPropsMeta ); + sName = getControlModelStringProperty( rAccNameProperty ); + if ( !sName.getLength() ) + { // no -> use the default + sName = AccessibleShape::CreateAccessibleName(); + } + } + + // now that somebody first asked us for our name, ensure that we are listening to name changes on the model + m_bListeningForName = ensureListeningState( m_bListeningForName, true, lcl_getPreferredAccNameProperty( m_xModelPropsMeta ) ); + + return sName; +} + +void SAL_CALL AccessibleControlShape::disposing() +{ + // ensure we're not listening + m_bListeningForName = ensureListeningState( m_bListeningForName, false, lcl_getPreferredAccNameProperty( m_xModelPropsMeta ) ); + m_bListeningForDesc = ensureListeningState( m_bListeningForDesc, false, lcl_getDescPropertyName() ); + + if ( m_bMultiplexingStates ) + stopStateMultiplexing( ); + + // dispose the child cache/map + m_pChildManager->dispose(); + + // release the model + m_xControlModel.clear(); + m_xModelPropsMeta.clear(); + m_aControlContext = WeakReference< XAccessibleContext >(); + + // stop listening at the control container (should never be necessary here, but who knows...) + if ( m_bWaitingForControl ) + { + OSL_FAIL( "AccessibleControlShape::disposing: this should never happen!" ); + Reference< XContainer > xContainer = lcl_getControlContainer( maShapeTreeInfo.GetWindow()->GetOutDev(), maShapeTreeInfo.GetSdrView() ); + if ( xContainer.is() ) + { + m_bWaitingForControl = false; + xContainer->removeContainerListener( this ); + } + } + + // forward the disposal to our inner context + if ( m_bDisposeNativeContext ) + { + // don't listen for mode changes anymore + Reference< XModeChangeBroadcaster > xControlModes( m_xUnoControl, UNO_QUERY ); + OSL_ENSURE( xControlModes.is(), "AccessibleControlShape::disposing: don't have a mode broadcaster anymore!" ); + if ( xControlModes.is() ) + xControlModes->removeModeChangeListener( this ); + + if ( m_xControlContextComponent.is() ) + m_xControlContextComponent->dispose(); + // do _not_ clear m_xControlContextProxy! This has to be done in the dtor for correct ref-count handling + + // no need to dispose the proxy/inner context anymore + m_bDisposeNativeContext = false; + } + + m_xUnoControl.clear(); + + // let the base do its stuff + AccessibleShape::disposing(); +} + +bool AccessibleControlShape::ensureControlModelAccess() +{ + if ( m_xControlModel.is() ) + return true; + + try + { + Reference< XControlShape > xShape( mxShape, UNO_QUERY ); + if ( xShape.is() ) + m_xControlModel.set(xShape->getControl(), css::uno::UNO_QUERY); + + if ( m_xControlModel.is() ) + m_xModelPropsMeta = m_xControlModel->getPropertySetInfo(); + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "AccessibleControlShape::ensureControlModelAccess" ); + } + + return m_xControlModel.is(); +} + +void AccessibleControlShape::startStateMultiplexing() +{ + OSL_PRECOND( !m_bMultiplexingStates, "AccessibleControlShape::startStateMultiplexing: already multiplexing!" ); + +#if OSL_DEBUG_LEVEL > 0 + // we should have a control, and it should be in alive mode + OSL_PRECOND( isAliveMode( m_xUnoControl ), + "AccessibleControlShape::startStateMultiplexing: should be done in alive mode only!" ); +#endif + // we should have the native context of the control + Reference< XAccessibleEventBroadcaster > xBroadcaster( m_aControlContext.get(), UNO_QUERY ); + OSL_ENSURE( xBroadcaster.is(), "AccessibleControlShape::startStateMultiplexing: no AccessibleEventBroadcaster on the native context!" ); + + if ( xBroadcaster.is() ) + { + xBroadcaster->addAccessibleEventListener( this ); + m_bMultiplexingStates = true; + } +} + +void AccessibleControlShape::stopStateMultiplexing() +{ + OSL_PRECOND( m_bMultiplexingStates, "AccessibleControlShape::stopStateMultiplexing: not multiplexing!" ); + + // we should have the native context of the control + Reference< XAccessibleEventBroadcaster > xBroadcaster( m_aControlContext.get(), UNO_QUERY ); + OSL_ENSURE( xBroadcaster.is(), "AccessibleControlShape::stopStateMultiplexing: no AccessibleEventBroadcaster on the native context!" ); + + if ( xBroadcaster.is() ) + { + xBroadcaster->removeAccessibleEventListener( this ); + m_bMultiplexingStates = false; + } +} + +OUString AccessibleControlShape::getControlModelStringProperty( const OUString& _rPropertyName ) const +{ + OUString sReturn; + try + { + if ( const_cast< AccessibleControlShape* >( this )->ensureControlModelAccess() ) + { + if ( !m_xModelPropsMeta.is() || m_xModelPropsMeta->hasPropertyByName( _rPropertyName ) ) + // ask only if a) the control does not have a PropertySetInfo object or b) it has, and the + // property in question is available + m_xControlModel->getPropertyValue( _rPropertyName ) >>= sReturn; + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "svx", "OAccessibleControlContext::getModelStringProperty" ); + } + return sReturn; +} + +void AccessibleControlShape::adjustAccessibleRole( ) +{ + // if we're in design mode, we are a simple SHAPE, in alive mode, we use the role of our inner context + if ( !isAliveMode( m_xUnoControl ) ) + return; + + // we're in alive mode -> determine the role of the inner context + Reference< XAccessibleContext > xNativeContext( m_aControlContext ); + OSL_PRECOND( xNativeContext.is(), "AccessibleControlShape::adjustAccessibleRole: no inner context!" ); + if ( xNativeContext.is() ) + SetAccessibleRole( xNativeContext->getAccessibleRole( ) ); +} + +#ifdef DBG_UTIL + +bool AccessibleControlShape::SetState( sal_Int16 _nState ) +{ + OSL_ENSURE( !isAliveMode( m_xUnoControl ) || !isComposedState( _nState ), + "AccessibleControlShape::SetState: a state which should be determined by the control context is set from outside!" ); + return AccessibleShape::SetState( _nState ); +} +#endif // DBG_UTIL + +void AccessibleControlShape::initializeComposedState() +{ + if ( !isAliveMode( m_xUnoControl ) ) + // no action necessary for design mode + return; + + // get our own state set implementation + ::utl::AccessibleStateSetHelper* pComposedStates = mxStateSet.get(); + OSL_PRECOND( pComposedStates, + "AccessibleControlShape::initializeComposedState: no composed set!" ); + + // we need to reset some states of the composed set, because they either do not apply + // for controls in alive mode, or are in the responsibility of the UNO-control, anyway + pComposedStates->RemoveState( AccessibleStateType::ENABLED ); // this is controlled by the UNO-control + pComposedStates->RemoveState( AccessibleStateType::SENSITIVE ); // this is controlled by the UNO-control + pComposedStates->RemoveState( AccessibleStateType::FOCUSABLE ); // this is controlled by the UNO-control + pComposedStates->RemoveState( AccessibleStateType::SELECTABLE ); // this does not hold for an alive UNO-control +#if OSL_DEBUG_LEVEL > 0 + // now, only states which are not in the responsibility of the UNO control should be part of this state set + { + const Sequence< sal_Int16 > aInitStates = pComposedStates->getStates(); + for ( sal_Int16 state : aInitStates ) + OSL_ENSURE( !isComposedState( state ), + "AccessibleControlShape::initializeComposedState: invalid initial composed state (should be controlled by the UNO-control)!" ); + } +#endif + + // get my inner context + Reference< XAccessibleContext > xInnerContext( m_aControlContext ); + OSL_PRECOND( xInnerContext.is(), "AccessibleControlShape::initializeComposedState: no inner context!" ); + if ( !xInnerContext.is() ) + return; + + // get all states of the inner context + Reference< XAccessibleStateSet > xInnerStates( xInnerContext->getAccessibleStateSet() ); + OSL_ENSURE( xInnerStates.is(), "AccessibleControlShape::initializeComposedState: no inner states!" ); + Sequence< sal_Int16 > aInnerStates; + if ( xInnerStates.is() ) + aInnerStates = xInnerStates->getStates(); + + // look which one are to be propagated to the composed context + for ( const sal_Int16 nState : std::as_const(aInnerStates) ) + { + if ( isComposedState( nState ) && !pComposedStates->contains( nState ) ) + { + pComposedStates->AddState( nState ); + } + } +} + +void SAL_CALL AccessibleControlShape::elementInserted( const css::container::ContainerEvent& _rEvent ) +{ + Reference< XContainer > xContainer( _rEvent.Source, UNO_QUERY ); + Reference< XControl > xControl( _rEvent.Element, UNO_QUERY ); + + OSL_ENSURE( xContainer.is() && xControl.is(), + "AccessibleControlShape::elementInserted: invalid event description!" ); + + if ( !xControl.is() ) + return; + + ensureControlModelAccess(); + + Reference< XInterface > xNewNormalized( xControl->getModel(), UNO_QUERY ); + Reference< XInterface > xMyModelNormalized( m_xControlModel, UNO_QUERY ); + if ( !(xNewNormalized && xMyModelNormalized) ) + return; + + // now finally the control for the model we're responsible for has been inserted into the container + Reference< XInterface > xKeepAlive( *this ); + + // first, we're not interested in any more container events + if ( xContainer.is() ) + { + xContainer->removeContainerListener( this ); + m_bWaitingForControl = false; + } + + // second, we need to replace ourself with a new version, which now can be based on the + // control + OSL_VERIFY( mpParent->ReplaceChild ( this, mxShape, 0, maShapeTreeInfo ) ); +} + +void SAL_CALL AccessibleControlShape::elementRemoved( const css::container::ContainerEvent& ) +{ + // not interested in +} + +void SAL_CALL AccessibleControlShape::elementReplaced( const css::container::ContainerEvent& ) +{ + // not interested in +} + +AccessibleControlShape* AccessibleControlShape::GetLabeledByControlShape( ) +{ + if(m_xControlModel.is()) + { + const OUString& rAccLabelControlProperty = lcl_getLabelControlPropertyName(); + Any sCtlLabelBy; + // get the "label by" property value of the control + if (::comphelper::hasProperty(rAccLabelControlProperty, m_xControlModel)) + { + sCtlLabelBy = m_xControlModel->getPropertyValue(rAccLabelControlProperty); + if( sCtlLabelBy.hasValue() ) + { + Reference< XPropertySet > xAsSet (sCtlLabelBy, UNO_QUERY); + AccessibleControlShape* pCtlAccShape = mpParent->GetAccControlShapeFromModel(xAsSet.get()); + return pCtlAccShape; + } + } + } + return nullptr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleEmptyEditSource.cxx b/svx/source/accessibility/AccessibleEmptyEditSource.cxx new file mode 100644 index 000000000..e1426d239 --- /dev/null +++ b/svx/source/accessibility/AccessibleEmptyEditSource.cxx @@ -0,0 +1,329 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +// Global header + + +#include <memory> +#include <svl/itemset.hxx> +#include <editeng/editdata.hxx> +#include <editeng/outliner.hxx> +#include <svx/svdmodel.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdpool.hxx> + + +// Project-local header + + +#include "AccessibleEmptyEditSource.hxx" +#include <svx/unoshtxt.hxx> + +namespace accessibility +{ + namespace { + + /** This class simply wraps a SvxTextEditSource, forwarding all + methods except the GetBroadcaster() call + */ + class AccessibleProxyEditSource_Impl : public SvxEditSource + { + public: + /** Construct AccessibleEmptyEditSource_Impl + + @param rBrdCast + + Proxy broadcaster to allow seamless flipping of edit source implementations. ProxyEditSource and EmptyEditSource + */ + AccessibleProxyEditSource_Impl( SdrObject& rObj, + SdrView& rView, + const OutputDevice& rViewWindow ); + + // from the SvxEditSource interface + SvxTextForwarder* GetTextForwarder() override; + SvxViewForwarder* GetViewForwarder() override; + SvxEditViewForwarder* GetEditViewForwarder( bool bCreate = false ) override; + + std::unique_ptr<SvxEditSource> Clone() const override; + + void UpdateData() override; + + SfxBroadcaster& GetBroadcaster() const override; + + private: + SvxTextEditSource maEditSource; + + }; + + /** Dummy class, faking exactly one empty paragraph for EditEngine accessibility + */ + class AccessibleEmptyEditSource_Impl : public SvxEditSource, public SvxViewForwarder, public SvxTextForwarder, public SfxBroadcaster + { + public: + + AccessibleEmptyEditSource_Impl() {} + + // SvxEditSource + SvxTextForwarder* GetTextForwarder() override { return this; } + SvxViewForwarder* GetViewForwarder() override { return this; } + std::unique_ptr<SvxEditSource> Clone() const override { return nullptr; } + void UpdateData() override {} + SfxBroadcaster& GetBroadcaster() const override { return *const_cast<AccessibleEmptyEditSource_Impl*>(this); } + + // SvxTextForwarder + sal_Int32 GetParagraphCount() const override { return 1; } + sal_Int32 GetTextLen( sal_Int32 /*nParagraph*/ ) const override { return 0; } + OUString GetText( const ESelection& /*rSel*/ ) const override { return OUString(); } + SfxItemSet GetAttribs( const ESelection& /*rSel*/, EditEngineAttribs /*nOnlyHardAttrib*/ = EditEngineAttribs::All ) const override + { + // AW: Very dangerous: The former implementation used a SfxItemPool created on the + // fly which of course was deleted again ASAP. Thus, the returned SfxItemSet was using + // a deleted Pool by design. + return SfxItemSet(SdrObject::GetGlobalDrawObjectItemPool()); + } + SfxItemSet GetParaAttribs( sal_Int32 /*nPara*/ ) const override { return GetAttribs(ESelection()); } + void SetParaAttribs( sal_Int32 /*nPara*/, const SfxItemSet& /*rSet*/ ) override {} + void RemoveAttribs( const ESelection& /*rSelection*/ ) override {} + void GetPortions( sal_Int32 /*nPara*/, std::vector<sal_Int32>& /*rList*/ ) const override {} + + SfxItemState GetItemState( const ESelection& /*rSel*/, sal_uInt16 /*nWhich*/ ) const override { return SfxItemState::UNKNOWN; } + SfxItemState GetItemState( sal_Int32 /*nPara*/, sal_uInt16 /*nWhich*/ ) const override { return SfxItemState::UNKNOWN; } + + SfxItemPool* GetPool() const override { return nullptr; } + + void QuickInsertText( const OUString& /*rText*/, const ESelection& /*rSel*/ ) override {} + void QuickInsertField( const SvxFieldItem& /*rFld*/, const ESelection& /*rSel*/ ) override {} + void QuickSetAttribs( const SfxItemSet& /*rSet*/, const ESelection& /*rSel*/ ) override {} + void QuickInsertLineBreak( const ESelection& /*rSel*/ ) override {} + + const SfxItemSet * GetEmptyItemSetPtr() override { return nullptr; } + + void AppendParagraph() override {} + sal_Int32 AppendTextPortion( sal_Int32 /*nPara*/, const OUString & /*rText*/, const SfxItemSet & /*rSet*/ ) override { return 0; } + + //XTextCopy + void CopyText(const SvxTextForwarder& ) override {} + + OUString CalcFieldValue( const SvxFieldItem& /*rField*/, sal_Int32 /*nPara*/, sal_Int32 /*nPos*/, std::optional<Color>& /*rpTxtColor*/, std::optional<Color>& /*rpFldColor*/ ) override + { + return OUString(); + } + void FieldClicked( const SvxFieldItem& ) override {} + + bool IsValid() const override { return true; } + + LanguageType GetLanguage( sal_Int32, sal_Int32 ) const override { return LANGUAGE_DONTKNOW; } + sal_Int32 GetFieldCount( sal_Int32 ) const override { return 0; } + EFieldInfo GetFieldInfo( sal_Int32, sal_uInt16 ) const override { return EFieldInfo(); } + EBulletInfo GetBulletInfo( sal_Int32 ) const override { return EBulletInfo(); } + tools::Rectangle GetCharBounds( sal_Int32, sal_Int32 ) const override { return tools::Rectangle(); } + tools::Rectangle GetParaBounds( sal_Int32 ) const override { return tools::Rectangle(); } + MapMode GetMapMode() const override { return MapMode(); } + OutputDevice* GetRefDevice() const override { return nullptr; } + bool GetIndexAtPoint( const Point&, sal_Int32&, sal_Int32& ) const override { return false; } + bool GetWordIndices( sal_Int32, sal_Int32, sal_Int32&, sal_Int32& ) const override { return false; } + bool GetAttributeRun( sal_Int32&, sal_Int32&, sal_Int32, sal_Int32, bool ) const override { return false; } + sal_Int32 GetLineCount( sal_Int32 nPara ) const override { return nPara == 0 ? 1 : 0; } + sal_Int32 GetLineLen( sal_Int32, sal_Int32 ) const override { return 0; } + void GetLineBoundaries( /*out*/sal_Int32 & rStart, /*out*/sal_Int32 & rEnd, sal_Int32 /*nParagraph*/, sal_Int32 /*nLine*/ ) const override { rStart = rEnd = 0; } + sal_Int32 GetLineNumberAtIndex( sal_Int32 /*nPara*/, sal_Int32 /*nIndex*/ ) const override { return 0; } + + // the following two methods would, strictly speaking, require + // a switch to a real EditSource, too. Fortunately, the + // AccessibleEditableTextPara implementation currently always + // calls GetEditViewForwarder(true) before doing + // changes. Thus, we rely on this behaviour here (problem + // when that changes: via accessibility API, it would no + // longer be possible to enter text in previously empty + // shapes). + bool Delete( const ESelection& ) override { return false; } + bool InsertText( const OUString&, const ESelection& ) override { return false; } + bool QuickFormatDoc( bool ) override { return true; } + sal_Int16 GetDepth( sal_Int32 ) const override { return -1; } + bool SetDepth( sal_Int32, sal_Int16 ) override { return true; } + + Point LogicToPixel( const Point& rPoint, const MapMode& /*rMapMode*/ ) const override { return rPoint; } + Point PixelToLogic( const Point& rPoint, const MapMode& /*rMapMode*/ ) const override { return rPoint; } + + }; + + } + + // Implementing AccessibleProxyEditSource_Impl + + + AccessibleProxyEditSource_Impl::AccessibleProxyEditSource_Impl( SdrObject& rObj, + SdrView& rView, + const OutputDevice& rViewWindow ) : + maEditSource( rObj, nullptr, rView, rViewWindow ) + { + } + + SvxTextForwarder* AccessibleProxyEditSource_Impl::GetTextForwarder() + { + return maEditSource.GetTextForwarder(); + } + + SvxViewForwarder* AccessibleProxyEditSource_Impl::GetViewForwarder() + { + return maEditSource.GetViewForwarder(); + } + + SvxEditViewForwarder* AccessibleProxyEditSource_Impl::GetEditViewForwarder( bool bCreate ) + { + return maEditSource.GetEditViewForwarder( bCreate ); + } + + std::unique_ptr<SvxEditSource> AccessibleProxyEditSource_Impl::Clone() const + { + return maEditSource.Clone(); + } + + void AccessibleProxyEditSource_Impl::UpdateData() + { + maEditSource.UpdateData(); + } + + SfxBroadcaster& AccessibleProxyEditSource_Impl::GetBroadcaster() const + { + return maEditSource.GetBroadcaster(); + } + + + // Implementing AccessibleEmptyEditSource + + + AccessibleEmptyEditSource::AccessibleEmptyEditSource( SdrObject& rObj, + SdrView& rView, + const OutputDevice& rViewWindow ) : + mpEditSource( new AccessibleEmptyEditSource_Impl() ), + mrObj(rObj), + mrView(rView), + mrViewWindow(rViewWindow), + mbEditSourceEmpty( true ) + { + StartListening( mrObj.getSdrModelFromSdrObject() ); + } + + AccessibleEmptyEditSource::~AccessibleEmptyEditSource() + { + if( !mbEditSourceEmpty ) + { + // deregister as listener + if (mpEditSource) + EndListening( mpEditSource->GetBroadcaster() ); + } + else + { + EndListening( mrObj.getSdrModelFromSdrObject() ); + } + } + + SvxTextForwarder* AccessibleEmptyEditSource::GetTextForwarder() + { + if (!mpEditSource) + return nullptr; + + return mpEditSource->GetTextForwarder(); + } + + SvxViewForwarder* AccessibleEmptyEditSource::GetViewForwarder() + { + if (!mpEditSource) + return nullptr; + + return mpEditSource->GetViewForwarder(); + } + + void AccessibleEmptyEditSource::Switch2ProxyEditSource() + { + // deregister EmptyEditSource model listener + EndListening( mrObj.getSdrModelFromSdrObject() ); + + ::std::unique_ptr< SvxEditSource > pProxySource( new AccessibleProxyEditSource_Impl(mrObj, mrView, mrViewWindow) ); + mpEditSource.swap(pProxySource); + + // register as listener + StartListening( mpEditSource->GetBroadcaster() ); + + // we've irrevocably a full EditSource now. + mbEditSourceEmpty = false; + } + + SvxEditViewForwarder* AccessibleEmptyEditSource::GetEditViewForwarder( bool bCreate ) + { + if (!mpEditSource) + return nullptr; + + // switch edit source, if not yet done + if( mbEditSourceEmpty && bCreate ) + Switch2ProxyEditSource(); + + return mpEditSource->GetEditViewForwarder( bCreate ); + } + + std::unique_ptr<SvxEditSource> AccessibleEmptyEditSource::Clone() const + { + if (!mpEditSource) + return nullptr; + + return mpEditSource->Clone(); + } + + void AccessibleEmptyEditSource::UpdateData() + { + if (mpEditSource) + mpEditSource->UpdateData(); + } + + SfxBroadcaster& AccessibleEmptyEditSource::GetBroadcaster() const + { + return *const_cast<AccessibleEmptyEditSource*>(this); + } + + void AccessibleEmptyEditSource::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) + { + const SdrHint* pSdrHint = ( rHint.GetId() == SfxHintId::ThisIsAnSdrHint ? static_cast<const SdrHint*>(&rHint) : nullptr ); + + if( pSdrHint && pSdrHint->GetKind() == SdrHintKind::BeginEdit && + &mrObj == pSdrHint->GetObject() && mpEditSource ) + { + // switch edit source, if not yet done. This is necessary + // to become a full-fledged EditSource the first time a + // user start entering text in a previously empty object. + if( mbEditSourceEmpty ) + Switch2ProxyEditSource(); + } + else if (pSdrHint && pSdrHint->GetObject()!=nullptr) + { + // When the SdrObject just got a para outliner object then + // switch the edit source. + if (pSdrHint->GetObject()->GetOutlinerParaObject() != nullptr) + Switch2ProxyEditSource(); + } + + // forward messages + Broadcast( rHint ); + } + +} // end of namespace accessibility + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleEmptyEditSource.hxx b/svx/source/accessibility/AccessibleEmptyEditSource.hxx new file mode 100644 index 000000000..6cfceeda4 --- /dev/null +++ b/svx/source/accessibility/AccessibleEmptyEditSource.hxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_ACCESSIBILITY_ACCESSIBLEEMPTYEDITSOURCE_HXX +#define INCLUDED_SVX_SOURCE_ACCESSIBILITY_ACCESSIBLEEMPTYEDITSOURCE_HXX + +#include <svl/SfxBroadcaster.hxx> +#include <svl/lstner.hxx> + +#include <memory> +#include <editeng/unoedsrc.hxx> + +class SdrObject; +class SdrView; +class OutputDevice; + +namespace accessibility +{ + /** Proxy edit source for shapes without text + + Extracted from old SvxDummyEditSource + */ + class AccessibleEmptyEditSource : public SvxEditSource, public SfxListener, public SfxBroadcaster + { + public: + /** Create proxy edit source for shapes without text + + Since the views don't broadcast their dying, make sure that + this object gets destroyed if the view becomes invalid + + The window is necessary, since our views can display on multiple windows + + Make sure you only create such an object if the shape _really_ + does not contain text. + */ + AccessibleEmptyEditSource( SdrObject& rObj, SdrView& rView, const OutputDevice& rViewWindow ); + virtual ~AccessibleEmptyEditSource() override; + + // from the SvxEditSource interface + SvxTextForwarder* GetTextForwarder() override; + SvxViewForwarder* GetViewForwarder() override; + + std::unique_ptr<SvxEditSource> Clone() const override; + + // this method internally switches from empty to proxy mode, + // creating an SvxTextEditSource for the functionality. + SvxEditViewForwarder* GetEditViewForwarder( bool bCreate = false ) override; + + void UpdateData() override; + SfxBroadcaster& GetBroadcaster() const override; + + // from the SfxListener interface + void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; + + private: + void Switch2ProxyEditSource(); + + /** Pointer to edit source implementation. This is switched on + a GetEditViewForwarder( true ) call, to actually create a + SvxTextEditSource. + + @dyn + */ + std::unique_ptr< SvxEditSource > mpEditSource; + + SdrObject& mrObj; + SdrView& mrView; + const OutputDevice& mrViewWindow; + + bool mbEditSourceEmpty; + }; + +} // namespace accessibility + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleFrameSelector.cxx b/svx/source/accessibility/AccessibleFrameSelector.cxx new file mode 100644 index 000000000..3c3007fc0 --- /dev/null +++ b/svx/source/accessibility/AccessibleFrameSelector.cxx @@ -0,0 +1,380 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <AccessibleFrameSelector.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <svx/frmsel.hxx> +#include <svx/dialmgr.hxx> + +#include <frmsel.hrc> + +namespace svx::a11y { + +using ::com::sun::star::uno::Any; +using ::com::sun::star::uno::Reference; +using ::com::sun::star::uno::Sequence; +using ::com::sun::star::uno::RuntimeException; + +using namespace ::com::sun::star::accessibility; + + +AccFrameSelector::AccFrameSelector(FrameSelector& rFrameSel) + : mpFrameSel(&rFrameSel) +{ +} + +AccFrameSelector::~AccFrameSelector() +{ +} + +IMPLEMENT_FORWARD_XINTERFACE2( AccFrameSelector, OAccessibleComponentHelper, OAccessibleHelper_Base ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( AccFrameSelector, OAccessibleComponentHelper, OAccessibleHelper_Base ) + +Reference< XAccessibleContext > AccFrameSelector::getAccessibleContext( ) +{ + return this; +} + +sal_Int32 AccFrameSelector::getAccessibleChildCount( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return mpFrameSel->GetEnabledBorderCount(); +} + +Reference< XAccessible > AccFrameSelector::getAccessibleChild( sal_Int32 i ) +{ + SolarMutexGuard aGuard; + IsValid(); + Reference< XAccessible > xRet = mpFrameSel->GetChildAccessible( i ); + if( !xRet.is() ) + throw RuntimeException(); + return xRet; +} + +Reference< XAccessible > AccFrameSelector::getAccessibleParent( ) +{ + SolarMutexGuard aGuard; + IsValid(); + Reference< XAccessible > xRet = mpFrameSel->getAccessibleParent(); + return xRet; +} + +sal_Int16 AccFrameSelector::getAccessibleRole( ) +{ + return AccessibleRole::OPTION_PANE; +} + +OUString AccFrameSelector::getAccessibleDescription( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return SvxResId(RID_SVXSTR_FRMSEL_DESCRIPTIONS[0].first); +} + +OUString AccFrameSelector::getAccessibleName( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return SvxResId(RID_SVXSTR_FRMSEL_TEXTS[0].first); +} + +Reference< XAccessibleRelationSet > AccFrameSelector::getAccessibleRelationSet( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return mpFrameSel->get_accessible_relation_set(); +} + +Reference< XAccessibleStateSet > AccFrameSelector::getAccessibleStateSet( ) +{ + SolarMutexGuard aGuard; + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + 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); + } + + if (mpFrameSel->HasFocus()) + { + pStateSetHelper->AddState(AccessibleStateType::ACTIVE); + pStateSetHelper->AddState(AccessibleStateType::FOCUSED); + pStateSetHelper->AddState(AccessibleStateType::SELECTED); + } + } + return pStateSetHelper; +} + +Reference< XAccessible > AccFrameSelector::getAccessibleAtPoint( + const css::awt::Point& aPt ) +{ + SolarMutexGuard aGuard; + IsValid(); + //aPt is relative to the frame selector + return mpFrameSel->GetChildAccessible( Point( aPt.X, aPt.Y ) ); +} + +void AccFrameSelector::grabFocus( ) +{ + SolarMutexGuard aGuard; + IsValid(); + mpFrameSel->GrabFocus(); +} + +sal_Int32 AccFrameSelector::getForeground( ) +{ + SolarMutexGuard aGuard; + + //see FrameSelector::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetLabelTextColor()); +} + +sal_Int32 AccFrameSelector::getBackground( ) +{ + SolarMutexGuard aGuard; + + //see FrameSelector::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetDialogColor()); +} + +css::awt::Rectangle AccFrameSelector::implGetBounds() +{ + SolarMutexGuard aGuard; + IsValid(); + + css::awt::Rectangle aRet; + + const Point aOutPos; + Size aOutSize(mpFrameSel->GetOutputSizePixel()); + + aRet.X = aOutPos.X(); + aRet.Y = aOutPos.Y(); + aRet.Width = aOutSize.Width(); + aRet.Height = aOutSize.Height(); + + return aRet; +} + +void AccFrameSelector::IsValid() +{ + if(!mpFrameSel) + throw RuntimeException(); +} + +void AccFrameSelector::Invalidate() +{ + mpFrameSel = nullptr; +} + +AccFrameSelectorChild::AccFrameSelectorChild(FrameSelector& rFrameSel, FrameBorderType eBorder) + : mpFrameSel(&rFrameSel) + , meBorder(eBorder) +{ +} + +AccFrameSelectorChild::~AccFrameSelectorChild() +{ +} + +IMPLEMENT_FORWARD_XINTERFACE2( AccFrameSelectorChild, OAccessibleComponentHelper, OAccessibleHelper_Base ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( AccFrameSelectorChild, OAccessibleComponentHelper, OAccessibleHelper_Base ) + +Reference< XAccessibleContext > AccFrameSelectorChild::getAccessibleContext( ) +{ + return this; +} + +sal_Int32 AccFrameSelectorChild::getAccessibleChildCount( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return 0; +} + +Reference< XAccessible > AccFrameSelectorChild::getAccessibleChild( sal_Int32 ) +{ + throw RuntimeException(); +} + +Reference< XAccessible > AccFrameSelectorChild::getAccessibleParent( ) +{ + SolarMutexGuard aGuard; + IsValid(); + Reference< XAccessible > xRet = mpFrameSel->CreateAccessible(); + return xRet; +} + +sal_Int16 AccFrameSelectorChild::getAccessibleRole( ) +{ + return AccessibleRole::CHECK_BOX; +} + +OUString AccFrameSelectorChild::getAccessibleDescription( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return SvxResId(RID_SVXSTR_FRMSEL_DESCRIPTIONS[static_cast<sal_uInt32>(meBorder)].first); +} + +OUString AccFrameSelectorChild::getAccessibleName( ) +{ + SolarMutexGuard aGuard; + IsValid(); + return SvxResId(RID_SVXSTR_FRMSEL_TEXTS[static_cast<sal_uInt32>(meBorder)].first); +} + +Reference< XAccessibleRelationSet > AccFrameSelectorChild::getAccessibleRelationSet( ) +{ + SolarMutexGuard aGuard; + IsValid(); + Reference< XAccessibleRelationSet > xRet = new utl::AccessibleRelationSetHelper; + return xRet; +} + +Reference< XAccessibleStateSet > AccFrameSelectorChild::getAccessibleStateSet( ) +{ + SolarMutexGuard aGuard; + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + 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); + } + + if (mpFrameSel->HasFocus() && mpFrameSel->IsBorderSelected(meBorder)) + { + pStateSetHelper->AddState(AccessibleStateType::ACTIVE); + pStateSetHelper->AddState(AccessibleStateType::FOCUSED); + pStateSetHelper->AddState(AccessibleStateType::SELECTED); + } + } + return pStateSetHelper; +} + +Reference< XAccessible > AccFrameSelectorChild::getAccessibleAtPoint( + const css::awt::Point& aPt ) +{ + SolarMutexGuard aGuard; + IsValid(); + //aPt is relative to the frame selector + return mpFrameSel->GetChildAccessible( Point( aPt.X, aPt.Y ) ); +} + +css::awt::Rectangle AccFrameSelectorChild::implGetBounds( ) +{ + SolarMutexGuard aGuard; + IsValid(); + const tools::Rectangle aSpot = mpFrameSel->GetClickBoundRect( meBorder ); + Point aPos = aSpot.TopLeft(); + Size aSz = aSpot.GetSize(); + css::awt::Rectangle aRet; + aRet.X = aPos.X(); + aRet.Y = aPos.Y(); + aRet.Width = aSz.Width(); + aRet.Height = aSz.Height(); + return aRet; +} + +void AccFrameSelectorChild::grabFocus( ) +{ + SolarMutexGuard aGuard; + IsValid(); + mpFrameSel->GrabFocus(); +} + +sal_Int32 AccFrameSelectorChild::getForeground( ) +{ + SolarMutexGuard aGuard; + + //see FrameSelector::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetLabelTextColor()); +} + +sal_Int32 AccFrameSelectorChild::getBackground( ) +{ + SolarMutexGuard aGuard; + + //see FrameSelector::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetDialogColor()); +} + +void AccFrameSelectorChild::IsValid() +{ + if(!mpFrameSel) + throw RuntimeException(); +} + +void AccFrameSelectorChild::Invalidate() +{ + mpFrameSel = nullptr; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleGraphicShape.cxx b/svx/source/accessibility/AccessibleGraphicShape.cxx new file mode 100644 index 000000000..d94ce4886 --- /dev/null +++ b/svx/source/accessibility/AccessibleGraphicShape.cxx @@ -0,0 +1,144 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svx/AccessibleGraphicShape.hxx> + +#include <svx/ShapeTypeHandler.hxx> +#include <svx/SvxShapeTypes.hxx> +#include <svx/svdobj.hxx> + +#include <com/sun/star/drawing/XShape.hpp> +#include <com/sun/star/drawing/XShapeDescriptor.hpp> +#include <comphelper/sequence.hxx> +#include <cppuhelper/queryinterface.hxx> + +using namespace ::accessibility; +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; + +// internal +AccessibleGraphicShape::AccessibleGraphicShape ( + const AccessibleShapeInfo& rShapeInfo, + const AccessibleShapeTreeInfo& rShapeTreeInfo) + : AccessibleShape (rShapeInfo, rShapeTreeInfo) +{ +} + + +AccessibleGraphicShape::~AccessibleGraphicShape() +{ +} + +// XAccessibleImage +OUString SAL_CALL AccessibleGraphicShape::getAccessibleImageDescription() +{ + if (m_pShape) + return m_pShape->GetTitle(); + return AccessibleShape::getAccessibleDescription (); +} + + +sal_Int32 SAL_CALL AccessibleGraphicShape::getAccessibleImageHeight() +{ + return AccessibleShape::getSize().Height; +} + + +sal_Int32 SAL_CALL AccessibleGraphicShape::getAccessibleImageWidth() +{ + return AccessibleShape::getSize().Width; +} + +// XInterface +css::uno::Any SAL_CALL + AccessibleGraphicShape::queryInterface (const css::uno::Type & rType) +{ + css::uno::Any aReturn = AccessibleShape::queryInterface (rType); + if ( ! aReturn.hasValue()) + aReturn = ::cppu::queryInterface (rType, + static_cast<XAccessibleImage*>(this)); + return aReturn; +} + + +void SAL_CALL + AccessibleGraphicShape::acquire() + noexcept +{ + AccessibleShape::acquire (); +} + + +void SAL_CALL + AccessibleGraphicShape::release() + noexcept +{ + AccessibleShape::release (); +} + +// XServiceInfo +OUString SAL_CALL + AccessibleGraphicShape::getImplementationName() +{ + return "AccessibleGraphicShape"; +} + + +css::uno::Sequence< OUString> SAL_CALL + AccessibleGraphicShape::getSupportedServiceNames() +{ + ThrowIfDisposed (); + const css::uno::Sequence<OUString> vals { "com.sun.star.drawing.AccessibleGraphicShape" }; + return comphelper::concatSequences(AccessibleShape::getSupportedServiceNames(), vals); +} + +// XTypeProvider +uno::Sequence<uno::Type> SAL_CALL + AccessibleGraphicShape::getTypes() +{ + // Get list of types from the context base implementation... + return comphelper::concatSequences(AccessibleShape::getTypes(), + uno::Sequence { cppu::UnoType<XAccessibleImage>::get() }); +} + + +/// Create the base name of this object, i.e. the name without appended number. +OUString + AccessibleGraphicShape::CreateAccessibleBaseName() +{ + OUString sName; + + ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape); + switch (nShapeType) + { + case DRAWING_GRAPHIC_OBJECT: + sName = "GraphicObjectShape"; + break; + + default: + sName = "UnknownAccessibleGraphicShape"; + uno::Reference<drawing::XShapeDescriptor> xDescriptor (mxShape); + if (xDescriptor.is()) + sName += ": " + xDescriptor->getShapeType(); + } + + return sName; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleOLEShape.cxx b/svx/source/accessibility/AccessibleOLEShape.cxx new file mode 100644 index 000000000..9275ad180 --- /dev/null +++ b/svx/source/accessibility/AccessibleOLEShape.cxx @@ -0,0 +1,172 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svx/AccessibleOLEShape.hxx> + +#include <svx/ShapeTypeHandler.hxx> +#include <svx/SvxShapeTypes.hxx> +#include <svx/svdoole2.hxx> + +#include <comphelper/sequence.hxx> +#include <cppuhelper/queryinterface.hxx> + +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/drawing/XShape.hpp> +#include <com/sun/star/drawing/XShapeDescriptor.hpp> + +using namespace ::accessibility; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; + +// internal +AccessibleOLEShape::AccessibleOLEShape ( + const AccessibleShapeInfo& rShapeInfo, + const AccessibleShapeTreeInfo& rShapeTreeInfo) + : AccessibleShape (rShapeInfo, rShapeTreeInfo) +{ +} + + +AccessibleOLEShape::~AccessibleOLEShape() +{ +} + +// XAccessibleAction +sal_Int32 SAL_CALL AccessibleOLEShape::getAccessibleActionCount() +{ + return 0; +} + + +sal_Bool SAL_CALL AccessibleOLEShape::doAccessibleAction (sal_Int32 /*nIndex*/) +{ + throw lang::IndexOutOfBoundsException(); +} + + +OUString SAL_CALL AccessibleOLEShape::getAccessibleActionDescription (sal_Int32 /*nIndex*/) +{ + throw lang::IndexOutOfBoundsException(); +} + + +Reference<XAccessibleKeyBinding> SAL_CALL AccessibleOLEShape::getAccessibleActionKeyBinding (sal_Int32 /*nIndex*/) +{ + throw lang::IndexOutOfBoundsException(); +} + +// XInterface +css::uno::Any SAL_CALL + AccessibleOLEShape::queryInterface (const css::uno::Type & rType) +{ + css::uno::Any aReturn = AccessibleShape::queryInterface (rType); + if ( ! aReturn.hasValue()) + aReturn = ::cppu::queryInterface (rType, + static_cast<XAccessibleAction*>(this)); + return aReturn; +} + + +void SAL_CALL + AccessibleOLEShape::acquire() + noexcept +{ + AccessibleShape::acquire (); +} + + +void SAL_CALL + AccessibleOLEShape::release() + noexcept +{ + AccessibleShape::release (); +} + +// XServiceInfo +OUString SAL_CALL + AccessibleOLEShape::getImplementationName() +{ + return "AccessibleOLEShape"; +} + + +css::uno::Sequence< OUString> SAL_CALL + AccessibleOLEShape::getSupportedServiceNames() +{ + ThrowIfDisposed(); + const css::uno::Sequence<OUString> vals { "com.sun.star.drawing.AccessibleOLEShape" }; + return comphelper::concatSequences(AccessibleShape::getSupportedServiceNames(), vals); +} + +// XTypeProvider +uno::Sequence<uno::Type> SAL_CALL AccessibleOLEShape::getTypes() +{ + // Get list of types from the context base implementation... + return comphelper::concatSequences(AccessibleShape::getTypes(), + uno::Sequence { cppu::UnoType<XAccessibleAction>::get() } ); +} + +// XAccessibleExtendedAttributes +uno::Any SAL_CALL AccessibleOLEShape::getExtendedAttributes() +{ + uno::Any strRet; + OUString style; + if( m_pShape ) + { + style = "style:" + static_cast<SdrOle2Obj*>(m_pShape)->GetStyleString(); + } + style += ";"; + strRet <<= style; + return strRet; +} + +/// Set this object's name if is different to the current name. +OUString + AccessibleOLEShape::CreateAccessibleBaseName() +{ + OUString sName; + + ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape); + switch (nShapeType) + { + case DRAWING_APPLET: + sName = "AppletOLEShape"; + break; + case DRAWING_FRAME: + sName = "FrameOLEShape"; + break; + case DRAWING_OLE: + sName = "OLEShape"; + break; + case DRAWING_PLUGIN: + sName = "PluginOLEShape"; + break; + + default: + sName = "UnknownAccessibleOLEShape"; + uno::Reference<drawing::XShapeDescriptor> xDescriptor (mxShape); + if (xDescriptor.is()) + sName += ": " + xDescriptor->getShapeType(); + } + + return sName; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleShape.cxx b/svx/source/accessibility/AccessibleShape.cxx new file mode 100644 index 000000000..03996fe7f --- /dev/null +++ b/svx/source/accessibility/AccessibleShape.cxx @@ -0,0 +1,1314 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svx/AccessibleShape.hxx> +#include <svx/AccessibleShapeInfo.hxx> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleRelationType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/drawing/XShapes.hpp> +#include <com/sun/star/document/XShapeEventBroadcaster.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/drawing/FillStyle.hpp> +#include <com/sun/star/text/XText.hpp> +#include <sal/log.hxx> +#include <editeng/unoedsrc.hxx> +#include <svx/AccessibleTextHelper.hxx> +#include <svx/ChildrenManager.hxx> +#include <svx/IAccessibleParent.hxx> +#include <svx/IAccessibleViewForwarder.hxx> +#include <svx/unoshtxt.hxx> +#include <svx/svdobj.hxx> +#include <svx/unoapi.hxx> +#include <svx/svdpage.hxx> +#include <svx/ShapeTypeHandler.hxx> +#include <svx/SvxShapeTypes.hxx> + +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> +#include <unotools/accessiblestatesethelper.hxx> +#include <unotools/accessiblerelationsethelper.hxx> +#include <svx/svdview.hxx> +#include <tools/diagnose_ex.h> +#include <cppuhelper/queryinterface.hxx> +#include <comphelper/sequence.hxx> +#include "AccessibleEmptyEditSource.hxx" + +#include <algorithm> +#include <memory> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; +using ::com::sun::star::uno::Reference; +using ::com::sun::star::lang::IndexOutOfBoundsException; +using ::com::sun::star::uno::RuntimeException; + +namespace accessibility { + +namespace { + +OUString GetOptionalProperty ( + const Reference<beans::XPropertySet>& rxSet, + const OUString& rsPropertyName) +{ + OUString sValue; + + if (rxSet.is()) + { + const Reference<beans::XPropertySetInfo> xInfo (rxSet->getPropertySetInfo()); + if ( ! xInfo.is() || xInfo->hasPropertyByName(rsPropertyName)) + { + try + { + rxSet->getPropertyValue(rsPropertyName) >>= sValue; + } + catch (beans::UnknownPropertyException&) + { + // This exception should only be thrown when the property + // does not exits (of course) and the XPropertySetInfo is + // not available. + } + } + } + return sValue; +} + +} // end of anonymous namespace + +// internal +AccessibleShape::AccessibleShape ( + const AccessibleShapeInfo& rShapeInfo, + const AccessibleShapeTreeInfo& rShapeTreeInfo) + : AccessibleContextBase (rShapeInfo.mxParent,AccessibleRole::SHAPE), + mxShape (rShapeInfo.mxShape), + maShapeTreeInfo (rShapeTreeInfo), + m_nIndexInParent(-1), + mpParent (rShapeInfo.mpChildrenManager) +{ + m_pShape = SdrObject::getSdrObjectFromXShape(mxShape); + UpdateNameAndDescription(); +} + +AccessibleShape::~AccessibleShape() +{ + mpChildrenManager.reset(); + mpText.reset(); + SAL_INFO("svx", "~AccessibleShape"); + + // Unregistering from the various broadcasters should be unnecessary + // since this destructor would not have been called if one of the + // broadcasters would still hold a strong reference to this object. +} + +void AccessibleShape::Init() +{ + // Update the OPAQUE and SELECTED shape. + UpdateStates (); + + // Create a children manager when this shape has children of its own. + Reference<drawing::XShapes> xShapes (mxShape, uno::UNO_QUERY); + if (xShapes.is() && xShapes->getCount() > 0) + mpChildrenManager.reset( new ChildrenManager ( + this, xShapes, maShapeTreeInfo, *this) ); + if (mpChildrenManager != nullptr) + mpChildrenManager->Update(); + + // Register at model as document::XEventListener. + if (mxShape.is() && maShapeTreeInfo.GetModelBroadcaster().is()) + maShapeTreeInfo.GetModelBroadcaster()->addShapeEventListener(mxShape, + static_cast<document::XShapeEventListener*>(this)); + + // Beware! Here we leave the paths of the UNO API and descend into the + // depths of the core. Necessary for making the edit engine + // accessible. + Reference<text::XText> xText (mxShape, uno::UNO_QUERY); + if (!xText.is()) + return; + + SdrView* pView = maShapeTreeInfo.GetSdrView (); + const vcl::Window* pWindow = maShapeTreeInfo.GetWindow (); + if (!(pView != nullptr && pWindow != nullptr && mxShape.is())) + return; + + // #107948# Determine whether shape text is empty + SdrObject* pSdrObject = SdrObject::getSdrObjectFromXShape(mxShape); + if( !pSdrObject ) + return; + + SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( pSdrObject ); + const bool hasOutlinerParaObject = (pTextObj && pTextObj->CanCreateEditOutlinerParaObject()) || (pSdrObject->GetOutlinerParaObject() != nullptr); + + // create AccessibleTextHelper to handle this shape's text + if( !hasOutlinerParaObject ) + { + // empty text -> use proxy edit source to delay creation of EditEngine + mpText.reset( new AccessibleTextHelper( std::make_unique<AccessibleEmptyEditSource >(*pSdrObject, *pView, *pWindow->GetOutDev()) ) ); + } + else + { + // non-empty text -> use full-fledged edit source right away + mpText.reset( new AccessibleTextHelper( std::make_unique<SvxTextEditSource >(*pSdrObject, nullptr, *pView, *pWindow->GetOutDev()) ) ); + } + if( pWindow->HasFocus() ) + mpText->SetFocus(); + + mpText->SetEventSource(this); +} + + +void AccessibleShape::UpdateStates() +{ + if (mxStateSet == nullptr) + return; + + // Set the opaque state for certain shape types when their fill style is + // solid. + bool bShapeIsOpaque = false; + switch (ShapeTypeHandler::Instance().GetTypeId (mxShape)) + { + case DRAWING_PAGE: + case DRAWING_RECTANGLE: + case DRAWING_TEXT: + { + uno::Reference<beans::XPropertySet> xSet (mxShape, uno::UNO_QUERY); + if (xSet.is()) + { + try + { + drawing::FillStyle aFillStyle; + bShapeIsOpaque = ( xSet->getPropertyValue ("FillStyle") >>= aFillStyle) + && aFillStyle == drawing::FillStyle_SOLID; + } + catch (css::beans::UnknownPropertyException&) + { + // Ignore. + } + } + } + } + if (bShapeIsOpaque) + mxStateSet->AddState (AccessibleStateType::OPAQUE); + else + mxStateSet->RemoveState (AccessibleStateType::OPAQUE); + + // Set the selected state. + bool bShapeIsSelected = false; + // XXX fix_me this has to be done with an extra interface later on + if ( m_pShape && maShapeTreeInfo.GetSdrView() ) + { + bShapeIsSelected = maShapeTreeInfo.GetSdrView()->IsObjMarked(m_pShape); + } + + if (bShapeIsSelected) + mxStateSet->AddState (AccessibleStateType::SELECTED); + else + mxStateSet->RemoveState (AccessibleStateType::SELECTED); +} + +OUString AccessibleShape::GetStyle() const +{ + return ShapeTypeHandler::CreateAccessibleBaseName( mxShape ); +} + +bool AccessibleShape::SetState (sal_Int16 aState) +{ + bool bStateHasChanged = false; + + if (aState == AccessibleStateType::FOCUSED && mpText != nullptr) + { + // Offer FOCUSED state to edit engine and detect whether the state + // changes. + bool bIsFocused = mpText->HaveFocus (); + mpText->SetFocus(); + bStateHasChanged = (bIsFocused != mpText->HaveFocus ()); + } + else + bStateHasChanged = AccessibleContextBase::SetState (aState); + + return bStateHasChanged; +} + + +bool AccessibleShape::ResetState (sal_Int16 aState) +{ + bool bStateHasChanged = false; + + if (aState == AccessibleStateType::FOCUSED && mpText != nullptr) + { + // Try to remove FOCUSED state from the edit engine and detect + // whether the state changes. + bool bIsFocused = mpText->HaveFocus (); + mpText->SetFocus (false); + bStateHasChanged = (bIsFocused != mpText->HaveFocus ()); + } + else + bStateHasChanged = AccessibleContextBase::ResetState (aState); + + return bStateHasChanged; +} + + +bool AccessibleShape::GetState (sal_Int16 aState) +{ + if (aState == AccessibleStateType::FOCUSED && mpText != nullptr) + { + // Just delegate the call to the edit engine. The state is not + // merged into the state set. + return mpText->HaveFocus(); + } + else + return AccessibleContextBase::GetState (aState); +} + +// OverWrite the parent's getAccessibleName method +OUString SAL_CALL AccessibleShape::getAccessibleName() +{ + ThrowIfDisposed (); + if (m_pShape && !m_pShape->GetTitle().isEmpty()) + return CreateAccessibleName() + " " + m_pShape->GetTitle(); + else + return CreateAccessibleName(); +} + +OUString SAL_CALL AccessibleShape::getAccessibleDescription() +{ + ThrowIfDisposed (); + if( m_pShape && !m_pShape->GetDescription().isEmpty()) + return m_pShape->GetDescription() ; + else + return " "; +} + +// XAccessibleContext +/** The children of this shape come from two sources: The children from + group or scene shapes and the paragraphs of text. +*/ +sal_Int32 SAL_CALL + AccessibleShape::getAccessibleChildCount () +{ + if (IsDisposed()) + { + return 0; + } + + sal_Int32 nChildCount = 0; + + // Add the number of shapes that are children of this shape. + if (mpChildrenManager != nullptr) + nChildCount += mpChildrenManager->GetChildCount (); + // Add the number text paragraphs. + if (mpText != nullptr) + nChildCount += mpText->GetChildCount (); + + return nChildCount; +} + + +/** Forward the request to the shape. Return the requested shape or throw + an exception for a wrong index. +*/ +uno::Reference<XAccessible> SAL_CALL + AccessibleShape::getAccessibleChild (sal_Int32 nIndex) +{ + ThrowIfDisposed (); + + uno::Reference<XAccessible> xChild; + + // Depending on the index decide whether to delegate this call to the + // children manager or the edit engine. + if ((mpChildrenManager != nullptr) + && (nIndex < mpChildrenManager->GetChildCount())) + { + xChild = mpChildrenManager->GetChild (nIndex); + } + else if (mpText != nullptr) + { + sal_Int32 nI = nIndex; + if (mpChildrenManager != nullptr) + nI -= mpChildrenManager->GetChildCount(); + xChild = mpText->GetChild (nI); + } + else + throw lang::IndexOutOfBoundsException ( + "shape has no child with index " + OUString::number(nIndex), + static_cast<uno::XWeak*>(this)); + + return xChild; +} + +uno::Reference<XAccessibleRelationSet> SAL_CALL + AccessibleShape::getAccessibleRelationSet() +{ + ::osl::MutexGuard aGuard (m_aMutex); + if (mpParent == nullptr) + return uno::Reference<XAccessibleRelationSet>(); + + rtl::Reference<::utl::AccessibleRelationSetHelper> pRelationSet = new utl::AccessibleRelationSetHelper; + + //this mxshape is the captioned shape + uno::Sequence< uno::Reference< uno::XInterface > > aSequence { mpParent->GetAccessibleCaption(mxShape) }; + if(aSequence[0]) + { + pRelationSet->AddRelation( + AccessibleRelation( AccessibleRelationType::DESCRIBED_BY, aSequence ) ); + } + return pRelationSet; +} + +/** Return a copy of the state set. + Possible states are: + ENABLED + SHOWING + VISIBLE +*/ +uno::Reference<XAccessibleStateSet> SAL_CALL + AccessibleShape::getAccessibleStateSet() +{ + ::osl::MutexGuard aGuard (m_aMutex); + + if (IsDisposed()) + { + // Return a minimal state set that only contains the DEFUNC state. + return AccessibleContextBase::getAccessibleStateSet (); + } + + ::utl::AccessibleStateSetHelper* pStateSet = mxStateSet.get(); + + if (!pStateSet) + return Reference<XAccessibleStateSet>(); + + // Merge current FOCUSED state from edit engine. + if (mpText) + { + if (mpText->HaveFocus()) + pStateSet->AddState (AccessibleStateType::FOCUSED); + else + pStateSet->RemoveState (AccessibleStateType::FOCUSED); + } + //Just when the document is not read-only,set states EDITABLE,RESIZABLE,MOVEABLE + css::uno::Reference<XAccessible> xTempAcc = getAccessibleParent(); + if( xTempAcc.is() ) + { + css::uno::Reference<XAccessibleContext> + xTempAccContext = xTempAcc->getAccessibleContext(); + if( xTempAccContext.is() ) + { + css::uno::Reference<XAccessibleStateSet> rState = + xTempAccContext->getAccessibleStateSet(); + if (rState.is()) + { + const css::uno::Sequence<short> aStates = rState->getStates(); + if (std::find(aStates.begin(), aStates.end(), AccessibleStateType::EDITABLE) != aStates.end()) + { + pStateSet->AddState (AccessibleStateType::EDITABLE); + pStateSet->AddState (AccessibleStateType::RESIZABLE); + pStateSet->AddState (AccessibleStateType::MOVEABLE); + } + } + } + } + + // Create a copy of the state set that may be modified by the + // caller without affecting the current state set. + Reference<XAccessibleStateSet> xStateSet(new ::utl::AccessibleStateSetHelper(*pStateSet)); + + if (mpParent && mpParent->IsDocumentSelAll()) + { + ::utl::AccessibleStateSetHelper* pCopyStateSet = + static_cast<::utl::AccessibleStateSetHelper*>(xStateSet.get()); + pCopyStateSet->AddState (AccessibleStateType::SELECTED); + } + + return xStateSet; +} + +// XAccessibleComponent +/** The implementation below is at the moment straightforward. It iterates + over all children (and thereby instances all children which have not + been already instantiated) until a child covering the specified point is + found. + This leaves room for improvement. For instance, first iterate only over + the already instantiated children and only if no match is found + instantiate the remaining ones. +*/ +uno::Reference<XAccessible > SAL_CALL + AccessibleShape::getAccessibleAtPoint ( + const awt::Point& aPoint) +{ + ::osl::MutexGuard aGuard (m_aMutex); + + sal_Int32 nChildCount = getAccessibleChildCount (); + for (sal_Int32 i=0; i<nChildCount; ++i) + { + Reference<XAccessible> xChild (getAccessibleChild (i)); + if (xChild.is()) + { + Reference<XAccessibleComponent> xChildComponent ( + xChild->getAccessibleContext(), uno::UNO_QUERY); + if (xChildComponent.is()) + { + awt::Rectangle aBBox (xChildComponent->getBounds()); + if ( (aPoint.X >= aBBox.X) + && (aPoint.Y >= aBBox.Y) + && (aPoint.X < aBBox.X+aBBox.Width) + && (aPoint.Y < aBBox.Y+aBBox.Height) ) + return xChild; + } + } + } + + // Have not found a child under the given point. Returning empty + // reference to indicate this. + return uno::Reference<XAccessible>(); +} + + +awt::Rectangle SAL_CALL AccessibleShape::getBounds() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard (m_aMutex); + + ThrowIfDisposed (); + awt::Rectangle aBoundingBox; + if ( mxShape.is() ) + { + + static constexpr OUStringLiteral sBoundRectName = u"BoundRect"; + static constexpr OUStringLiteral sAnchorPositionName = u"AnchorPosition"; + + // Get the shape's bounding box in internal coordinates (in 100th of + // mm). Use the property BoundRect. Only if that is not supported ask + // the shape for its position and size directly. + Reference<beans::XPropertySet> xSet (mxShape, uno::UNO_QUERY); + Reference<beans::XPropertySetInfo> xSetInfo; + bool bFoundBoundRect = false; + if (xSet.is()) + { + xSetInfo = xSet->getPropertySetInfo (); + if (xSetInfo.is()) + { + if (xSetInfo->hasPropertyByName (sBoundRectName)) + { + try + { + uno::Any aValue = xSet->getPropertyValue (sBoundRectName); + aValue >>= aBoundingBox; + bFoundBoundRect = true; + } + catch (beans::UnknownPropertyException const&) + { + // Handled below (bFoundBoundRect stays false). + } + } + else + SAL_WARN("svx", "no property BoundRect"); + } + } + + // Fallback when there is no BoundRect Property. + if ( ! bFoundBoundRect ) + { + awt::Point aPosition (mxShape->getPosition()); + awt::Size aSize (mxShape->getSize()); + aBoundingBox = awt::Rectangle ( + aPosition.X, aPosition.Y, + aSize.Width, aSize.Height); + + // While BoundRects have absolute positions, the position returned + // by XPosition::getPosition is relative. Get the anchor position + // (usually not (0,0) for Writer shapes). + if (xSetInfo.is()) + { + if (xSetInfo->hasPropertyByName (sAnchorPositionName)) + { + uno::Any aPos = xSet->getPropertyValue (sAnchorPositionName); + awt::Point aAnchorPosition; + aPos >>= aAnchorPosition; + aBoundingBox.X += aAnchorPosition.X; + aBoundingBox.Y += aAnchorPosition.Y; + } + } + } + + // Transform coordinates from internal to pixel. + if (maShapeTreeInfo.GetViewForwarder() == nullptr) + throw uno::RuntimeException ( + "AccessibleShape has no valid view forwarder", + static_cast<uno::XWeak*>(this)); + ::Size aPixelSize = maShapeTreeInfo.GetViewForwarder()->LogicToPixel ( + ::Size (aBoundingBox.Width, aBoundingBox.Height)); + ::Point aPixelPosition = maShapeTreeInfo.GetViewForwarder()->LogicToPixel ( + ::Point (aBoundingBox.X, aBoundingBox.Y)); + + // Clip the shape's bounding box with the bounding box of its parent. + Reference<XAccessibleComponent> xParentComponent ( + getAccessibleParent(), uno::UNO_QUERY); + if (xParentComponent.is()) + { + // Make the coordinates relative to the parent. + awt::Point aParentLocation (xParentComponent->getLocationOnScreen()); + int x = aPixelPosition.getX() - aParentLocation.X; + int y = aPixelPosition.getY() - aParentLocation.Y; + + // Clip with parent (with coordinates relative to itself). + ::tools::Rectangle aBBox ( + x, y, x + aPixelSize.getWidth(), y + aPixelSize.getHeight()); + awt::Size aParentSize (xParentComponent->getSize()); + ::tools::Rectangle aParentBBox (0,0, aParentSize.Width, aParentSize.Height); + aBBox = aBBox.GetIntersection (aParentBBox); + aBoundingBox = awt::Rectangle ( + aBBox.Left(), + aBBox.Top(), + aBBox.getWidth(), + aBBox.getHeight()); + } + else + { + SAL_INFO("svx", "parent does not support component"); + aBoundingBox = awt::Rectangle ( + aPixelPosition.getX(), aPixelPosition.getY(), + aPixelSize.getWidth(), aPixelSize.getHeight()); + } + } + + return aBoundingBox; +} + + +awt::Point SAL_CALL AccessibleShape::getLocation() +{ + ThrowIfDisposed (); + awt::Rectangle aBoundingBox (getBounds()); + return awt::Point (aBoundingBox.X, aBoundingBox.Y); +} + + +awt::Point SAL_CALL AccessibleShape::getLocationOnScreen() +{ + ThrowIfDisposed (); + + // Get relative position... + awt::Point aLocation (getLocation ()); + + // ... and add absolute position of the parent. + uno::Reference<XAccessibleComponent> xParentComponent ( + getAccessibleParent(), uno::UNO_QUERY); + if (xParentComponent.is()) + { + awt::Point aParentLocation (xParentComponent->getLocationOnScreen()); + aLocation.X += aParentLocation.X; + aLocation.Y += aParentLocation.Y; + } + else + SAL_WARN("svx", "parent does not support XAccessibleComponent"); + return aLocation; +} + + +awt::Size SAL_CALL AccessibleShape::getSize() +{ + ThrowIfDisposed (); + awt::Rectangle aBoundingBox (getBounds()); + return awt::Size (aBoundingBox.Width, aBoundingBox.Height); +} + + +sal_Int32 SAL_CALL AccessibleShape::getForeground() +{ + ThrowIfDisposed (); + sal_Int32 nColor (0x0ffffffL); + + try + { + uno::Reference<beans::XPropertySet> aSet (mxShape, uno::UNO_QUERY); + if (aSet.is()) + { + uno::Any aColor; + aColor = aSet->getPropertyValue ("LineColor"); + aColor >>= nColor; + } + } + catch (const css::beans::UnknownPropertyException &) + { + // Ignore exception and return default color. + } + return nColor; +} + + +sal_Int32 SAL_CALL AccessibleShape::getBackground() +{ + ThrowIfDisposed (); + Color nColor; + + try + { + uno::Reference<beans::XPropertySet> aSet (mxShape, uno::UNO_QUERY); + if (aSet.is()) + { + uno::Any aColor; + aColor = aSet->getPropertyValue ("FillColor"); + aColor >>= nColor; + aColor = aSet->getPropertyValue ("FillTransparence"); + short nTrans=0; + aColor >>= nTrans; + Color crBk(nColor); + if (nTrans == 0 ) + { + crBk.SetAlpha(0); + } + else + { + nTrans = short(256 - nTrans / 100. * 256); + crBk.SetAlpha(255 - sal_uInt8(nTrans)); + } + nColor = crBk; + } + } + catch (const css::beans::UnknownPropertyException &) + { + // Ignore exception and return default color. + } + return sal_Int32(nColor); +} + +// XAccessibleEventBroadcaster +void SAL_CALL AccessibleShape::addAccessibleEventListener ( + const Reference<XAccessibleEventListener >& rxListener) +{ + if (rBHelper.bDisposed || rBHelper.bInDispose) + { + uno::Reference<uno::XInterface> xThis ( + static_cast<lang::XComponent *>(this), uno::UNO_QUERY); + rxListener->disposing (lang::EventObject (xThis)); + } + else + { + AccessibleContextBase::addAccessibleEventListener (rxListener); + if (mpText != nullptr) + mpText->AddEventListener (rxListener); + } +} + + +void SAL_CALL AccessibleShape::removeAccessibleEventListener ( + const Reference<XAccessibleEventListener >& rxListener) +{ + AccessibleContextBase::removeAccessibleEventListener (rxListener); + if (mpText != nullptr) + mpText->RemoveEventListener (rxListener); +} + +// XInterface +css::uno::Any SAL_CALL + AccessibleShape::queryInterface (const css::uno::Type & rType) +{ + css::uno::Any aReturn = AccessibleContextBase::queryInterface (rType); + if ( ! aReturn.hasValue()) + aReturn = ::cppu::queryInterface (rType, + static_cast<XAccessibleComponent*>(this), + static_cast<XAccessibleExtendedComponent*>(this), + static_cast< css::accessibility::XAccessibleSelection* >(this), + static_cast< css::accessibility::XAccessibleExtendedAttributes* >(this), + static_cast<document::XShapeEventListener*>(this), + static_cast<lang::XUnoTunnel*>(this), + static_cast<XAccessibleGroupPosition*>(this), + static_cast<XAccessibleHypertext*>(this) + ); + return aReturn; +} + + +void SAL_CALL + AccessibleShape::acquire() + noexcept +{ + AccessibleContextBase::acquire (); +} + + +void SAL_CALL + AccessibleShape::release() + noexcept +{ + AccessibleContextBase::release (); +} + +// XAccessibleSelection +void SAL_CALL AccessibleShape::selectAccessibleChild( sal_Int32 ) +{ +} + + +sal_Bool SAL_CALL AccessibleShape::isAccessibleChildSelected( sal_Int32 nChildIndex ) +{ + uno::Reference<XAccessible> xAcc = getAccessibleChild( nChildIndex ); + uno::Reference<XAccessibleContext> xContext; + if( xAcc.is() ) + { + xContext = xAcc->getAccessibleContext(); + } + + if( xContext.is() ) + { + if( xContext->getAccessibleRole() == AccessibleRole::PARAGRAPH ) + { + uno::Reference< css::accessibility::XAccessibleText > + xText(xAcc, uno::UNO_QUERY); + if( xText.is() ) + { + if( xText->getSelectionStart() >= 0 ) return true; + } + } + else if( xContext->getAccessibleRole() == AccessibleRole::SHAPE ) + { + Reference< XAccessibleStateSet > pRState = xContext->getAccessibleStateSet(); + if( !pRState.is() ) + return false; + + const uno::Sequence<short> aStates = pRState->getStates(); + return std::find(aStates.begin(), aStates.end(), AccessibleStateType::SELECTED) != aStates.end(); + } + } + + return false; +} + + +void SAL_CALL AccessibleShape::clearAccessibleSelection( ) +{ +} + + +void SAL_CALL AccessibleShape::selectAllAccessibleChildren( ) +{ +} + + +sal_Int32 SAL_CALL AccessibleShape::getSelectedAccessibleChildCount() +{ + sal_Int32 nCount = 0; + sal_Int32 TotalCount = getAccessibleChildCount(); + for( sal_Int32 i = 0; i < TotalCount; i++ ) + if( isAccessibleChildSelected(i) ) nCount++; + + return nCount; +} + + +Reference<XAccessible> SAL_CALL AccessibleShape::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) +{ + if ( nSelectedChildIndex > getSelectedAccessibleChildCount() ) + throw IndexOutOfBoundsException(); + sal_Int32 i1, i2; + for( i1 = 0, i2 = 0; i1 < getAccessibleChildCount(); i1++ ) + if( isAccessibleChildSelected(i1) ) + { + if( i2 == nSelectedChildIndex ) + return getAccessibleChild( i1 ); + i2++; + } + return Reference<XAccessible>(); +} + + +void SAL_CALL AccessibleShape::deselectAccessibleChild( sal_Int32 ) +{ + +} + +// XAccessibleExtendedAttributes +uno::Any SAL_CALL AccessibleShape::getExtendedAttributes() +{ + uno::Any strRet; + OUString style; + if( getAccessibleRole() != AccessibleRole::SHAPE ) return strRet; + if( m_pShape ) + { + style = "style:" + GetStyle(); + } + style += ";"; + strRet <<= style; + return strRet; +} + +// XServiceInfo +OUString SAL_CALL + AccessibleShape::getImplementationName() +{ + return "AccessibleShape"; +} + + +uno::Sequence<OUString> SAL_CALL + AccessibleShape::getSupportedServiceNames() +{ + ThrowIfDisposed (); + const css::uno::Sequence<OUString> vals { "com.sun.star.drawing.AccessibleShape" }; + return comphelper::concatSequences(AccessibleContextBase::getSupportedServiceNames(), vals); +} + +// XTypeProvider +uno::Sequence<uno::Type> SAL_CALL + AccessibleShape::getTypes() +{ + ThrowIfDisposed (); + // Get list of types from the context base implementation, ... + uno::Sequence<uno::Type> aTypeList (AccessibleContextBase::getTypes()); + // ... get list of types from component base implementation, ... + uno::Sequence<uno::Type> aComponentTypeList (AccessibleComponentBase::getTypes()); + // ... define local types + uno::Sequence<uno::Type> localTypesList = { + cppu::UnoType<lang::XEventListener>::get(), + cppu::UnoType<document::XEventListener>::get(), + cppu::UnoType<lang::XUnoTunnel>::get() + }; + + return comphelper::concatSequences(aTypeList, aComponentTypeList, localTypesList); +} + +// lang::XEventListener +/** Disposing calls are accepted only from the model: Just reset the + reference to the model in the shape tree info. Otherwise this object + remains functional. +*/ +void AccessibleShape::disposing (const lang::EventObject& aEvent) +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard (m_aMutex); + + try + { + if (aEvent.Source == maShapeTreeInfo.GetModelBroadcaster()) + { + // Remove reference to model broadcaster to allow it to pass + // away. + maShapeTreeInfo.SetModelBroadcaster(nullptr); + } + + } + catch (uno::RuntimeException const&) + { + TOOLS_WARN_EXCEPTION("svx", "caught exception while disposing"); + } +} + +// document::XShapeEventListener +void SAL_CALL + AccessibleShape::notifyShapeEvent (const document::EventObject& rEventObject) +{ + if (rEventObject.EventName != "ShapeModified") + return; + + //Need to update text children when receiving ShapeModified hint when exiting edit mode for text box + if (mpText) + mpText->UpdateChildren(); + + + // Some property of a shape has been modified. Send an event + // that indicates a change of the visible data to all listeners. + CommitChange ( + AccessibleEventId::VISIBLE_DATA_CHANGED, + uno::Any(), + uno::Any()); + + // Name and Description may have changed. Update the local + // values accordingly. + UpdateNameAndDescription(); +} + +// lang::XUnoTunnel +UNO3_GETIMPLEMENTATION_IMPL(AccessibleShape) + +// IAccessibleViewForwarderListener +void AccessibleShape::ViewForwarderChanged() +{ + // Inform all listeners that the graphical representation (i.e. size + // and/or position) of the shape has changed. + CommitChange (AccessibleEventId::VISIBLE_DATA_CHANGED, + uno::Any(), + uno::Any()); + + // Tell children manager of the modified view forwarder. + if (mpChildrenManager != nullptr) + mpChildrenManager->ViewForwarderChanged(); + + // update our children that our screen position might have changed + if( mpText ) + mpText->UpdateChildren(); +} + +// protected internal +// Set this object's name if is different to the current name. +OUString AccessibleShape::CreateAccessibleBaseName() +{ + return ShapeTypeHandler::CreateAccessibleBaseName( mxShape ); +} + + +OUString AccessibleShape::CreateAccessibleName() +{ + return GetFullAccessibleName(this); +} + +OUString AccessibleShape::GetFullAccessibleName (AccessibleShape *shape) +{ + OUString sName (shape->CreateAccessibleBaseName()); + // Append the shape's index to the name to disambiguate between shapes + // of the same type. If such an index where not given to the + // constructor then use the z-order instead. If even that does not exist + // we throw an exception. + OUString nameStr; + if (shape->m_pShape) + nameStr = shape->m_pShape->GetName(); + if (nameStr.isEmpty()) + { + sName += " "; + } + else + { + sName = nameStr; + } + + //If the new produced name if not the same with last,notify name changed + //Event + if (aAccName != sName && !aAccName.isEmpty()) + { + uno::Any aOldValue, aNewValue; + aOldValue <<= aAccName; + aNewValue <<= sName; + CommitChange( + AccessibleEventId::NAME_CHANGED, + aNewValue, + aOldValue); + } + aAccName = sName; + return sName; +} + +// protected +void AccessibleShape::disposing() +{ + SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard (m_aMutex); + + // Make sure to send an event that this object loses the focus in the + // case that it has the focus. + ::utl::AccessibleStateSetHelper* pStateSet = mxStateSet.get(); + if (pStateSet != nullptr) + pStateSet->RemoveState (AccessibleStateType::FOCUSED); + + // Unregister from model. + if (mxShape.is() && maShapeTreeInfo.GetModelBroadcaster().is()) + maShapeTreeInfo.GetModelBroadcaster()->removeShapeEventListener(mxShape, + static_cast<document::XShapeEventListener*>(this)); + + // Release the child containers. + if (mpChildrenManager != nullptr) + { + mpChildrenManager.reset(); + } + if (mpText != nullptr) + { + mpText->Dispose(); + mpText.reset(); + } + + // Cleanup. Remove references to objects to allow them to be + // destroyed. + mxShape = nullptr; + maShapeTreeInfo.dispose(); + + // Call base classes. + AccessibleContextBase::dispose (); +} + +sal_Int32 SAL_CALL + AccessibleShape::getAccessibleIndexInParent() +{ + ThrowIfDisposed (); + // Use a simple but slow solution for now. Optimize later. + + sal_Int32 nIndex = m_nIndexInParent; + if ( -1 == nIndex ) + nIndex = AccessibleContextBase::getAccessibleIndexInParent(); + return nIndex; +} + + +void AccessibleShape::UpdateNameAndDescription() +{ + // Ignore missing title, name, or description. There are fallbacks for + // them. + try + { + Reference<beans::XPropertySet> xSet (mxShape, uno::UNO_QUERY_THROW); + + // Get the accessible name. + OUString sString = GetOptionalProperty(xSet, "Title"); + if (!sString.isEmpty()) + { + SetAccessibleName(sString, AccessibleContextBase::FromShape); + } + else + { + sString = GetOptionalProperty(xSet, "Name"); + if (!sString.isEmpty()) + SetAccessibleName(sString, AccessibleContextBase::FromShape); + } + + // Get the accessible description. + sString = GetOptionalProperty(xSet, "Description"); + if (!sString.isEmpty()) + SetAccessibleDescription(sString, AccessibleContextBase::FromShape); + } + catch (uno::RuntimeException&) + { + } +} + +// Return this object's role. +sal_Int16 SAL_CALL AccessibleShape::getAccessibleRole() +{ + sal_Int16 nAccessibleRole = AccessibleRole::SHAPE ; + switch (ShapeTypeHandler::Instance().GetTypeId (mxShape)) + { + case DRAWING_GRAPHIC_OBJECT: + nAccessibleRole = AccessibleRole::GRAPHIC ; break; + case DRAWING_OLE: + nAccessibleRole = AccessibleRole::EMBEDDED_OBJECT ; break; + + default: + nAccessibleRole = AccessibleContextBase::getAccessibleRole(); + break; + } + + return nAccessibleRole; +} + +namespace { + +//sort the drawing objects from up to down, from left to right +struct XShapePosCompareHelper +{ + bool operator() ( const uno::Reference<drawing::XShape>& xshape1, + const uno::Reference<drawing::XShape>& xshape2 ) const + { + SdrObject* pObj1 = SdrObject::getSdrObjectFromXShape(xshape1); + SdrObject* pObj2 = SdrObject::getSdrObjectFromXShape(xshape2); + if(pObj1 && pObj2) + return pObj1->GetOrdNum() < pObj2->GetOrdNum(); + else + return false; + } +}; + +} +//end of group position + +// XAccessibleGroupPosition +uno::Sequence< sal_Int32 > SAL_CALL +AccessibleShape::getGroupPosition( const uno::Any& ) +{ + // we will return the: + // [0] group level + // [1] similar items counts in the group + // [2] the position of the object in the group + uno::Sequence< sal_Int32 > aRet{ 0, 0, 0 }; + + css::uno::Reference<XAccessible> xParent = getAccessibleParent(); + if (!xParent.is()) + { + return aRet; + } + SdrObject *pObj = SdrObject::getSdrObjectFromXShape(mxShape); + + + if(pObj == nullptr ) + { + return aRet; + } + + // Compute object's group level. + sal_Int32 nGroupLevel = 0; + SdrObject * pUper = pObj->getParentSdrObjectFromSdrObject(); + while( pUper ) + { + ++nGroupLevel; + pUper = pUper->getParentSdrObjectFromSdrObject(); + } + + css::uno::Reference<XAccessibleContext> xParentContext = xParent->getAccessibleContext(); + if( xParentContext->getAccessibleRole() == AccessibleRole::DOCUMENT || + xParentContext->getAccessibleRole() == AccessibleRole::DOCUMENT_PRESENTATION || + xParentContext->getAccessibleRole() == AccessibleRole::DOCUMENT_SPREADSHEET || + xParentContext->getAccessibleRole() == AccessibleRole::DOCUMENT_TEXT )//Document + { + Reference< XAccessibleGroupPosition > xGroupPosition( xParent,uno::UNO_QUERY ); + if ( xGroupPosition.is() ) + { + aRet = xGroupPosition->getGroupPosition( uno::Any( getAccessibleContext() ) ); + } + return aRet; + } + if (xParentContext->getAccessibleRole() != AccessibleRole::SHAPE) + { + return aRet; + } + + SdrObjList *pGrpList = nullptr; + if( pObj->getParentSdrObjectFromSdrObject() ) + pGrpList = pObj->getParentSdrObjectFromSdrObject()->GetSubList(); + else + return aRet; + + std::vector< uno::Reference<drawing::XShape> > vXShapes; + if (pGrpList) + { + const size_t nObj = pGrpList->GetObjCount(); + for(size_t i = 0 ; i < nObj ; ++i) + { + SdrObject *pSubObj = pGrpList->GetObj(i); + if (pSubObj && + xParentContext->getAccessibleChild(i)->getAccessibleContext()->getAccessibleRole() != AccessibleRole::GROUP_BOX) + { + vXShapes.push_back( GetXShapeForSdrObject(pSubObj) ); + } + } + } + + std::sort( vXShapes.begin(), vXShapes.end(), XShapePosCompareHelper() ); + + //get the index of the selected object in the group + //we start counting position from 1 + sal_Int32 nPos = 1; + for ( const auto& rpShape : vXShapes ) + { + if ( rpShape.get() == mxShape.get() ) + { + sal_Int32* pArray = aRet.getArray(); + pArray[0] = nGroupLevel; + pArray[1] = vXShapes.size(); + pArray[2] = nPos; + break; + } + nPos++; + } + + return aRet; +} + +OUString AccessibleShape::getObjectLink( const uno::Any& ) +{ + OUString aRet; + + SdrObject *pObj = SdrObject::getSdrObjectFromXShape(mxShape); + if(pObj == nullptr ) + { + return aRet; + } + if (maShapeTreeInfo.GetDocumentWindow().is()) + { + Reference< XAccessibleGroupPosition > xGroupPosition( maShapeTreeInfo.GetDocumentWindow(), uno::UNO_QUERY ); + if (xGroupPosition.is()) + { + aRet = xGroupPosition->getObjectLink( uno::Any( getAccessibleContext() ) ); + } + } + return aRet; +} + +// XAccessibleHypertext +sal_Int32 SAL_CALL AccessibleShape::getHyperLinkCount() +{ + // MT: Introduced with IA2 CWS, but SvxAccessibleHyperlink was redundant to svx::AccessibleHyperlink which we introduced meanwhile. + // Code need to be adapted... + return 0; + + /* + SvxAccessibleHyperlink* pLink = new SvxAccessibleHyperlink(m_pShape,this); + if (pLink->IsValidHyperlink()) + return 1; + else + return 0; + */ +} +uno::Reference< XAccessibleHyperlink > SAL_CALL + AccessibleShape::getHyperLink( sal_Int32 ) +{ + uno::Reference< XAccessibleHyperlink > xRet; + // MT: Introduced with IA2 CWS, but SvxAccessibleHyperlink was redundant to svx::AccessibleHyperlink which we introduced meanwhile. + // Code need to be adapted... + /* + SvxAccessibleHyperlink* pLink = new SvxAccessibleHyperlink(m_pShape,this); + if (pLink->IsValidHyperlink()) + xRet = pLink; + if( !xRet.is() ) + throw css::lang::IndexOutOfBoundsException(); + */ + return xRet; +} +sal_Int32 SAL_CALL AccessibleShape::getHyperLinkIndex( sal_Int32 ) +{ + return 0; +} +// XAccessibleText +sal_Int32 SAL_CALL AccessibleShape::getCaretPosition( ){return 0;} +sal_Bool SAL_CALL AccessibleShape::setCaretPosition( sal_Int32 ){return false;} +sal_Unicode SAL_CALL AccessibleShape::getCharacter( sal_Int32 ){return 0;} +css::uno::Sequence< css::beans::PropertyValue > SAL_CALL AccessibleShape::getCharacterAttributes( sal_Int32, const css::uno::Sequence< OUString >& ) +{ + uno::Sequence< css::beans::PropertyValue > aValues(0); + return aValues; +} +css::awt::Rectangle SAL_CALL AccessibleShape::getCharacterBounds( sal_Int32 ) +{ + return css::awt::Rectangle(0, 0, 0, 0 ); +} +sal_Int32 SAL_CALL AccessibleShape::getCharacterCount( ){return 0;} +sal_Int32 SAL_CALL AccessibleShape::getIndexAtPoint( const css::awt::Point& ){return 0;} +OUString SAL_CALL AccessibleShape::getSelectedText( ){return OUString();} +sal_Int32 SAL_CALL AccessibleShape::getSelectionStart( ){return 0;} +sal_Int32 SAL_CALL AccessibleShape::getSelectionEnd( ){return 0;} +sal_Bool SAL_CALL AccessibleShape::setSelection( sal_Int32, sal_Int32 ){return true;} +OUString SAL_CALL AccessibleShape::getText( ){return OUString();} +OUString SAL_CALL AccessibleShape::getTextRange( sal_Int32, sal_Int32 ){return OUString();} +css::accessibility::TextSegment SAL_CALL AccessibleShape::getTextAtIndex( sal_Int32, sal_Int16 ) +{ + css::accessibility::TextSegment aResult; + return aResult; +} +css::accessibility::TextSegment SAL_CALL AccessibleShape::getTextBeforeIndex( sal_Int32, sal_Int16 ) +{ + css::accessibility::TextSegment aResult; + return aResult; +} +css::accessibility::TextSegment SAL_CALL AccessibleShape::getTextBehindIndex( sal_Int32, sal_Int16 ) +{ + css::accessibility::TextSegment aResult; + return aResult; +} +sal_Bool SAL_CALL AccessibleShape::copyText( sal_Int32, sal_Int32 ){return true;} +sal_Bool SAL_CALL AccessibleShape::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType ){return false;} + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleShapeInfo.cxx b/svx/source/accessibility/AccessibleShapeInfo.cxx new file mode 100644 index 000000000..7a70ca4d7 --- /dev/null +++ b/svx/source/accessibility/AccessibleShapeInfo.cxx @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svx/AccessibleShapeInfo.hxx> + + +namespace accessibility { + +AccessibleShapeInfo::AccessibleShapeInfo ( + const css::uno::Reference<css::drawing::XShape>& rxShape, + const css::uno::Reference<css::accessibility::XAccessible>& rxParent, + IAccessibleParent* pChildrenManager) + : mxShape (rxShape), + mxParent (rxParent), + mpChildrenManager (pChildrenManager) +{ + // empty. +} + + +AccessibleShapeInfo::AccessibleShapeInfo ( + const css::uno::Reference<css::drawing::XShape>& rxShape, + const css::uno::Reference<css::accessibility::XAccessible>& rxParent) + : mxShape (rxShape), + mxParent (rxParent), + mpChildrenManager (nullptr) +{ + // empty. +} + +AccessibleShapeInfo::AccessibleShapeInfo (const AccessibleShapeInfo &rOther) + : mxShape (rOther.mxShape), + mxParent (rOther.mxParent), + mpChildrenManager (rOther.mpChildrenManager) +{ + // empty. +} + + +AccessibleShapeInfo::~AccessibleShapeInfo() +{ + // empty. +} + +} // end of namespace accessibility. + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleShapeTreeInfo.cxx b/svx/source/accessibility/AccessibleShapeTreeInfo.cxx new file mode 100644 index 000000000..df6136f94 --- /dev/null +++ b/svx/source/accessibility/AccessibleShapeTreeInfo.cxx @@ -0,0 +1,117 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include <svx/AccessibleShapeTreeInfo.hxx> +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; +using ::com::sun::star::uno::Reference; + +namespace accessibility { + +AccessibleShapeTreeInfo::AccessibleShapeTreeInfo() + : mpView (nullptr), + mpWindow (nullptr), + mpViewForwarder (nullptr) +{ + // Empty. +} + + +AccessibleShapeTreeInfo::AccessibleShapeTreeInfo (const AccessibleShapeTreeInfo& rInfo) + : mxDocumentWindow (rInfo.mxDocumentWindow), + mxModelBroadcaster (rInfo.mxModelBroadcaster), + mpView (rInfo.mpView), + mxController (rInfo.mxController), + mpWindow (rInfo.mpWindow), + mpViewForwarder (rInfo.mpViewForwarder) +{ + // Empty. +} + +void AccessibleShapeTreeInfo::dispose() +{ + mxDocumentWindow.clear(); + mxModelBroadcaster.clear(); + mpView = nullptr; + mxController.clear(); + mpWindow.reset(); + mpViewForwarder = nullptr; +} + +AccessibleShapeTreeInfo& AccessibleShapeTreeInfo::operator= (const AccessibleShapeTreeInfo& rInfo) +{ + if ( this != &rInfo ) + { + mxDocumentWindow = rInfo.mxDocumentWindow; + mxModelBroadcaster = rInfo.mxModelBroadcaster; + mpView = rInfo.mpView; + mxController = rInfo.mxController; + mpWindow = rInfo.mpWindow; + mpViewForwarder = rInfo.mpViewForwarder; + } + return *this; +} + +AccessibleShapeTreeInfo::~AccessibleShapeTreeInfo() +{ + SolarMutexGuard g; + mpWindow.reset(); +} + +void AccessibleShapeTreeInfo::SetDocumentWindow ( + const Reference<XAccessibleComponent>& rxDocumentWindow) +{ + if (mxDocumentWindow != rxDocumentWindow) + mxDocumentWindow = rxDocumentWindow; +} + +void AccessibleShapeTreeInfo::SetModelBroadcaster ( + const Reference<document::XShapeEventBroadcaster>& rxModelBroadcaster) +{ + mxModelBroadcaster = rxModelBroadcaster; +} + +void AccessibleShapeTreeInfo::SetSdrView (SdrView* pView) +{ + mpView = pView; +} + +void AccessibleShapeTreeInfo::SetController ( + const Reference<frame::XController>& rxController) +{ + mxController = rxController; +} + +void AccessibleShapeTreeInfo::SetWindow(vcl::Window* pDevice) +{ + mpWindow = pDevice; +} + +void AccessibleShapeTreeInfo::SetViewForwarder (const IAccessibleViewForwarder* pViewForwarder) +{ + mpViewForwarder = pViewForwarder; +} + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleTextEventQueue.cxx b/svx/source/accessibility/AccessibleTextEventQueue.cxx new file mode 100644 index 000000000..a39123c45 --- /dev/null +++ b/svx/source/accessibility/AccessibleTextEventQueue.cxx @@ -0,0 +1,92 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <memory> +#include "AccessibleTextEventQueue.hxx" + +#include <editeng/unoedhlp.hxx> +#include <svx/svdmodel.hxx> +#include <svx/svdpntv.hxx> + +namespace accessibility +{ + + + // EventQueue implementation + + + AccessibleTextEventQueue::AccessibleTextEventQueue() + { + } + + AccessibleTextEventQueue::~AccessibleTextEventQueue() + { + Clear(); + } + + void AccessibleTextEventQueue::Append( const SdrHint& rHint ) + { + // only enqueue the events we actually care about in + // AccessibleTextHelper_Impl::ProcessQueue(), because + // the cost of some events adds up. + auto eKind = rHint.GetKind(); + if (eKind == SdrHintKind::BeginEdit + || eKind == SdrHintKind::EndEdit) + maEventQueue.push_back( new SdrHint( rHint ) ); + } + + void AccessibleTextEventQueue::Append( const TextHint& rHint ) + { + maEventQueue.push_back( new TextHint( rHint ) ); + } + + void AccessibleTextEventQueue::Append( const SvxViewChangedHint& rHint ) + { + maEventQueue.push_back( new SvxViewChangedHint( rHint ) ); + } + + void AccessibleTextEventQueue::Append( const SvxEditSourceHint& rHint ) + { + maEventQueue.push_back( new SvxEditSourceHint( rHint ) ); + } + + ::std::unique_ptr< SfxHint > AccessibleTextEventQueue::PopFront() + { + ::std::unique_ptr< SfxHint > aRes( *(maEventQueue.begin()) ); + maEventQueue.pop_front(); + return aRes; + } + + bool AccessibleTextEventQueue::IsEmpty() const + { + return maEventQueue.empty(); + } + + void AccessibleTextEventQueue::Clear() + { + // clear queue + for( auto p : maEventQueue) + delete p; + maEventQueue.clear(); + } + +} // end of namespace accessibility + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleTextEventQueue.hxx b/svx/source/accessibility/AccessibleTextEventQueue.hxx new file mode 100644 index 000000000..23dbf9faa --- /dev/null +++ b/svx/source/accessibility/AccessibleTextEventQueue.hxx @@ -0,0 +1,90 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_ACCESSIBILITY_ACCESSIBLETEXTEVENTQUEUE_HXX +#define INCLUDED_SVX_SOURCE_ACCESSIBILITY_ACCESSIBLETEXTEVENTQUEUE_HXX + +#include <memory> +#include <deque> +#include <algorithm> + +class SfxHint; +class SdrHint; +class TextHint; +class SvxViewChangedHint; +class SvxEditSourceHint; + +namespace accessibility +{ + /** This class handles the notification events for the + AccessibleTextHelper class. + + For various reasons, we cannot process EditEngine events as + they arrive, but have to queue and handle them in a batch. + */ + class AccessibleTextEventQueue + { + public: + typedef ::std::deque< SfxHint* > EventQueue; + + AccessibleTextEventQueue(); + ~AccessibleTextEventQueue(); + + /// Append event to end of queue + void Append( const SdrHint& rHint ); + /// Append event to end of queue + void Append( const TextHint& rHint ); + /// Append event to end of queue + void Append( const SvxViewChangedHint& rHint ); + /// Append event to end of queue + void Append( const SvxEditSourceHint& rHint ); + + /** Pop first queue element + + return first queue element, ownership transfers to caller + */ + ::std::unique_ptr< SfxHint > PopFront(); + + /** Apply functor to every queue member + + @param rFunctor + Functor to apply. Functor receives queue element as + parameter: void func( const SfxHint* ); + */ + template < typename Functor > void ForEach( Functor& rFunctor ) const + { + // #109864# Make sure results are put back into rFunctor + rFunctor = ::std::for_each( maEventQueue.begin(), maEventQueue.end(), rFunctor ); + } + + /// Query whether queue is empty + bool IsEmpty() const; + + /// Clear event queue + void Clear(); + + private: + EventQueue maEventQueue; + }; + +} // end of namespace accessibility + +#endif // INCLUDED_SVX_SOURCE_ACCESSIBILITY_ACCESSIBLETEXTEVENTQUEUE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/AccessibleTextHelper.cxx b/svx/source/accessibility/AccessibleTextHelper.cxx new file mode 100644 index 000000000..809bd25d3 --- /dev/null +++ b/svx/source/accessibility/AccessibleTextHelper.cxx @@ -0,0 +1,1779 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <sal/config.h> + +#include <cstdlib> +#include <memory> +#include <mutex> +#include <utility> +#include <algorithm> +#include <sal/log.hxx> +#include <com/sun/star/uno/Any.hxx> +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/awt/Point.hpp> +#include <com/sun/star/awt/Rectangle.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include <com/sun/star/accessibility/XAccessibleComponent.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <comphelper/accessibleeventnotifier.hxx> +#include <vcl/svapp.hxx> +#include <vcl/textdata.hxx> +#include <vcl/unohelp.hxx> + + +// Project-local header + + +#include "AccessibleTextEventQueue.hxx" +#include <svx/AccessibleTextHelper.hxx> + +#include <editeng/unoedhlp.hxx> +#include <editeng/unoedprx.hxx> +#include <editeng/AccessibleParaManager.hxx> +#include <editeng/AccessibleEditableTextPara.hxx> +#include <svx/svdmodel.hxx> +#include <svx/svdpntv.hxx> +#include <cell.hxx> +#include "../table/accessiblecell.hxx" +#include <editeng/editdata.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; + +namespace accessibility +{ + +// AccessibleTextHelper_Impl declaration + + template < typename first_type, typename second_type > + static ::std::pair< first_type, second_type > makeSortedPair( first_type first, + second_type second ) + { + if( first > second ) + return ::std::make_pair( second, first ); + else + return ::std::make_pair( first, second ); + } + + class AccessibleTextHelper_Impl : public SfxListener + { + public: + typedef ::std::vector< sal_Int16 > VectorOfStates; + + // receive pointer to our frontend class and view window + AccessibleTextHelper_Impl(); + virtual ~AccessibleTextHelper_Impl() override; + + // XAccessibleContext child handling methods + sal_Int32 getAccessibleChildCount() const; + uno::Reference< XAccessible > getAccessibleChild( sal_Int32 i ); + + // XAccessibleEventBroadcaster child related methods + void addAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener ); + void removeAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener ); + + // XAccessibleComponent child related methods + uno::Reference< XAccessible > getAccessibleAtPoint( const awt::Point& aPoint ); + + SvxEditSourceAdapter& GetEditSource() const; + + void SetEditSource( ::std::unique_ptr< SvxEditSource > && pEditSource ); + + void SetEventSource( const uno::Reference< XAccessible >& rInterface ) + { + mxFrontEnd = rInterface; + } + + void SetOffset( const Point& ); + Point GetOffset() const + { + std::scoped_lock aGuard( maMutex ); Point aPoint( maOffset ); + return aPoint; + } + + void SetStartIndex( sal_Int32 nOffset ); + sal_Int32 GetStartIndex() const + { + // Strictly correct only with locked solar mutex, // but + // here we rely on the fact that sal_Int32 access is + // atomic + return mnStartIndex; + } + + void SetAdditionalChildStates( VectorOfStates&& rChildStates ); + + void Dispose(); + + // do NOT hold object mutex when calling this! Danger of deadlock + void FireEvent( const sal_Int16 nEventId, const uno::Any& rNewValue = uno::Any(), const uno::Any& rOldValue = uno::Any() ) const; + void FireEvent( const AccessibleEventObject& rEvent ) const; + + void SetFocus( bool bHaveFocus ); + bool HaveFocus() const + { + // No locking of solar mutex here, since we rely on the fact + // that sal_Bool access is atomic + return mbThisHasFocus; + } + void SetChildFocus( sal_Int32 nChild, bool bHaveFocus ); + void SetShapeFocus( bool bHaveFocus ); + void ChangeChildFocus( sal_Int32 nNewChild ); + +#ifdef DBG_UTIL + void CheckInvariants() const; +#endif + + // checks all children for visibility, throws away invisible ones + void UpdateVisibleChildren( bool bBroadcastEvents=true ); + + // check all children for changes in position and size + void UpdateBoundRect(); + + // calls SetSelection on the forwarder and updates maLastSelection + // cache. + void UpdateSelection(); + + private: + + // Process event queue + void ProcessQueue(); + + // syntactic sugar for FireEvent + void GotPropertyEvent( const uno::Any& rNewValue, const sal_Int16 nEventId ) const { FireEvent( nEventId, rNewValue ); } + + // shutdown usage of current edit source on myself and the children. + void ShutdownEditSource(); + + void ParagraphsMoved( sal_Int32 nFirst, sal_Int32 nMiddle, sal_Int32 nLast ); + + virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; + + comphelper::AccessibleEventNotifier::TClientId getNotifierClientId() const { return mnNotifierClientId; } + + // lock solar mutex before + SvxTextForwarder& GetTextForwarder() const; + // lock solar mutex before + SvxViewForwarder& GetViewForwarder() const; + // lock solar mutex before + SvxEditViewForwarder& GetEditViewForwarder() const; + + // are we in edit mode? + bool IsActive() const; + + // our frontend class (the one implementing the actual + // interface). That's not necessarily the one containing the impl + // pointer! + uno::Reference< XAccessible > mxFrontEnd; + + // a wrapper for the text forwarders (guarded by solar mutex) + mutable SvxEditSourceAdapter maEditSource; + + // store last selection (to correctly report selection changes, guarded by solar mutex) + ESelection maLastSelection; + + // cache range of visible children (guarded by solar mutex) + sal_Int32 mnFirstVisibleChild; + sal_Int32 mnLastVisibleChild; + + // offset to add to all our children (unguarded, relying on + // the fact that sal_Int32 access is atomic) + sal_Int32 mnStartIndex; + + // the object handling our children (guarded by solar mutex) + ::accessibility::AccessibleParaManager maParaManager; + + // Queued events from Notify() (guarded by solar mutex) + AccessibleTextEventQueue maEventQueue; + + // spin lock to prevent notify in notify (guarded by solar mutex) + bool mbInNotify; + + // whether the object or its children has the focus set (guarded by solar mutex) + bool mbGroupHasFocus; + + // whether we (this object) has the focus set (guarded by solar mutex) + bool mbThisHasFocus; + + mutable std::mutex maMutex; + + /// our current offset to the containing shape/cell (guarded by maMutex) + Point maOffset; + + /// client Id from AccessibleEventNotifier + comphelper::AccessibleEventNotifier::TClientId mnNotifierClientId; + static constexpr comphelper::AccessibleEventNotifier::TClientId snNotifierClientRevoked + = std::numeric_limits<comphelper::AccessibleEventNotifier::TClientId>::max(); + }; + + AccessibleTextHelper_Impl::AccessibleTextHelper_Impl() : + maLastSelection( EE_PARA_NOT_FOUND,EE_INDEX_NOT_FOUND,EE_PARA_NOT_FOUND,EE_INDEX_NOT_FOUND ), + mnFirstVisibleChild( -1 ), + mnLastVisibleChild( -2 ), + mnStartIndex( 0 ), + mbInNotify( false ), + mbGroupHasFocus( false ), + mbThisHasFocus( false ), + maOffset(0,0), + // well, that's strictly exception safe, though not really + // robust. We rely on the fact that this member is constructed + // last, and that the constructor body is empty, thus no + // chance for exceptions once the Id is fetched. Nevertheless, + // normally should employ RAII here... + mnNotifierClientId(::comphelper::AccessibleEventNotifier::registerClient()) + { + SAL_INFO("svx", "received ID: " << mnNotifierClientId ); + } + + AccessibleTextHelper_Impl::~AccessibleTextHelper_Impl() + { + SolarMutexGuard aGuard; + + try + { + // call Dispose here, too, since we've some resources not + // automatically freed otherwise + Dispose(); + } + catch( const uno::Exception& ) {} + } + + SvxTextForwarder& AccessibleTextHelper_Impl::GetTextForwarder() const + { + if( !maEditSource.IsValid() ) + throw uno::RuntimeException("Unknown edit source", mxFrontEnd); + + SvxTextForwarder* pTextForwarder = maEditSource.GetTextForwarder(); + + if( !pTextForwarder ) + throw uno::RuntimeException("Unable to fetch text forwarder, model might be dead", mxFrontEnd); + + if( !pTextForwarder->IsValid() ) + throw uno::RuntimeException("Text forwarder is invalid, model might be dead", mxFrontEnd); + + return *pTextForwarder; + } + + SvxViewForwarder& AccessibleTextHelper_Impl::GetViewForwarder() const + { + if( !maEditSource.IsValid() ) + throw uno::RuntimeException("Unknown edit source", mxFrontEnd); + + SvxViewForwarder* pViewForwarder = maEditSource.GetViewForwarder(); + + if( !pViewForwarder ) + throw uno::RuntimeException("Unable to fetch view forwarder, model might be dead", mxFrontEnd); + + if( !pViewForwarder->IsValid() ) + throw uno::RuntimeException("View forwarder is invalid, model might be dead", mxFrontEnd); + + return *pViewForwarder; + } + + SvxEditViewForwarder& AccessibleTextHelper_Impl::GetEditViewForwarder() const + { + if( !maEditSource.IsValid() ) + throw uno::RuntimeException("Unknown edit source", mxFrontEnd); + + SvxEditViewForwarder* pViewForwarder = maEditSource.GetEditViewForwarder(); + + if( !pViewForwarder ) + { + throw uno::RuntimeException("No edit view forwarder, object not in edit mode", mxFrontEnd); + } + + if( !pViewForwarder->IsValid() ) + { + throw uno::RuntimeException("View forwarder is invalid, object not in edit mode", mxFrontEnd); + } + + return *pViewForwarder; + } + + SvxEditSourceAdapter& AccessibleTextHelper_Impl::GetEditSource() const + { + if( !maEditSource.IsValid() ) + throw uno::RuntimeException("AccessibleTextHelper_Impl::GetEditSource: no edit source", mxFrontEnd ); + return maEditSource; + } + + namespace { + + // functor for sending child events (no stand-alone function, they are maybe not inlined) + class AccessibleTextHelper_OffsetChildIndex + { + public: + explicit AccessibleTextHelper_OffsetChildIndex( sal_Int32 nDifference ) : mnDifference(nDifference) {} + void operator()( ::accessibility::AccessibleEditableTextPara& rPara ) + { + rPara.SetIndexInParent( rPara.GetIndexInParent() + mnDifference ); + } + + private: + const sal_Int32 mnDifference; + }; + + } + + void AccessibleTextHelper_Impl::SetStartIndex( sal_Int32 nOffset ) + { + sal_Int32 nOldOffset( mnStartIndex ); + + mnStartIndex = nOffset; + + if( nOldOffset != nOffset ) + { + // update children + AccessibleTextHelper_OffsetChildIndex aFunctor( nOffset - nOldOffset ); + + ::std::for_each( maParaManager.begin(), maParaManager.end(), + AccessibleParaManager::WeakChildAdapter< AccessibleTextHelper_OffsetChildIndex > (aFunctor) ); + } + } + + void AccessibleTextHelper_Impl::SetAdditionalChildStates( VectorOfStates&& rChildStates ) + { + maParaManager.SetAdditionalChildStates( std::move(rChildStates) ); + } + + void AccessibleTextHelper_Impl::SetChildFocus( sal_Int32 nChild, bool bHaveFocus ) + { + if( bHaveFocus ) + { + if( mbThisHasFocus ) + SetShapeFocus( false ); + + maParaManager.SetFocus( nChild ); + + // we just received the focus, also send caret event then + UpdateSelection(); + + SAL_INFO("svx", "Paragraph " << nChild << " received focus"); + } + else + { + maParaManager.SetFocus( -1 ); + + SAL_INFO("svx", "Paragraph " << nChild << " lost focus"); + + if( mbGroupHasFocus ) + SetShapeFocus( true ); + } + } + + void AccessibleTextHelper_Impl::ChangeChildFocus( sal_Int32 nNewChild ) + { + if( mbThisHasFocus ) + SetShapeFocus( false ); + + mbGroupHasFocus = true; + maParaManager.SetFocus( nNewChild ); + + SAL_INFO("svx", "Paragraph " << nNewChild << " received focus"); + } + + void AccessibleTextHelper_Impl::SetShapeFocus( bool bHaveFocus ) + { + bool bOldFocus( mbThisHasFocus ); + + mbThisHasFocus = bHaveFocus; + + if( bOldFocus == bHaveFocus ) + return; + + if( bHaveFocus ) + { + if( mxFrontEnd.is() ) + { + AccessibleCell* pAccessibleCell = dynamic_cast< AccessibleCell* > ( mxFrontEnd.get() ); + if ( !pAccessibleCell ) + GotPropertyEvent( uno::Any(AccessibleStateType::FOCUSED), AccessibleEventId::STATE_CHANGED ); + else // the focus event on cell should be fired on table directly + { + AccessibleTableShape* pAccTable = pAccessibleCell->GetParentTable(); + if (pAccTable) + pAccTable->SetStateDirectly(AccessibleStateType::FOCUSED); + } + } + SAL_INFO("svx", "Parent object received focus" ); + } + else + { + // The focus state should be reset directly on table. + //LostPropertyEvent( uno::makeAny(AccessibleStateType::FOCUSED), AccessibleEventId::STATE_CHANGED ); + if( mxFrontEnd.is() ) + { + AccessibleCell* pAccessibleCell = dynamic_cast< AccessibleCell* > ( mxFrontEnd.get() ); + if ( !pAccessibleCell ) + FireEvent( AccessibleEventId::STATE_CHANGED, uno::Any(), uno::Any(AccessibleStateType::FOCUSED) ); + else + { + AccessibleTableShape* pAccTable = pAccessibleCell->GetParentTable(); + if (pAccTable) + pAccTable->ResetStateDirectly(AccessibleStateType::FOCUSED); + } + } + SAL_INFO("svx", "Parent object lost focus" ); + } + } + + void AccessibleTextHelper_Impl::SetFocus( bool bHaveFocus ) + { + bool bOldFocus( mbGroupHasFocus ); + + mbGroupHasFocus = bHaveFocus; + + if( IsActive() ) + { + try + { + // find the one with the cursor and get/set focus accordingly + ESelection aSelection; + if( GetEditViewForwarder().GetSelection( aSelection ) ) + SetChildFocus( aSelection.nEndPara, bHaveFocus ); + } + catch( const uno::Exception& ) {} + } + else if( bOldFocus != bHaveFocus ) + { + SetShapeFocus( bHaveFocus ); + } + + SAL_INFO("svx", "focus changed, Object " << this << ", state: " << (bHaveFocus ? "focused" : "not focused") ); + } + + bool AccessibleTextHelper_Impl::IsActive() const + { + try + { + SvxEditSource& rEditSource = GetEditSource(); + SvxEditViewForwarder* pViewForwarder = rEditSource.GetEditViewForwarder(); + + if( !pViewForwarder ) + return false; + + if( mxFrontEnd.is() ) + { + AccessibleCell* pAccessibleCell = dynamic_cast< AccessibleCell* > ( mxFrontEnd.get() ); + if ( pAccessibleCell ) + { + sdr::table::CellRef xCell = pAccessibleCell->getCellRef(); + if ( xCell.is() ) + return xCell->IsActiveCell(); + } + } + return pViewForwarder->IsValid(); + } + catch( const uno::RuntimeException& ) + { + return false; + } + } + + void AccessibleTextHelper_Impl::UpdateSelection() + { + try + { + ESelection aSelection; + if( GetEditViewForwarder().GetSelection( aSelection ) ) + { + if( maLastSelection != aSelection && + aSelection.nEndPara < maParaManager.GetNum() ) + { + // #103998# Not that important, changed from assertion to trace + if( mbThisHasFocus ) + { + SAL_INFO("svx", "Parent has focus!"); + } + + sal_Int32 nMaxValidParaIndex( GetTextForwarder().GetParagraphCount() - 1 ); + + // notify all affected paragraphs (TODO: may be suboptimal, + // since some paragraphs might stay selected) + if( maLastSelection.nStartPara != EE_PARA_NOT_FOUND ) + { + // Did the caret move from one paragraph to another? + // #100530# no caret events if not focused. + if( mbGroupHasFocus && + maLastSelection.nEndPara != aSelection.nEndPara ) + { + if( maLastSelection.nEndPara < maParaManager.GetNum() ) + { + maParaManager.FireEvent( ::std::min( maLastSelection.nEndPara, nMaxValidParaIndex ), + ::std::min( maLastSelection.nEndPara, nMaxValidParaIndex )+1, + AccessibleEventId::CARET_CHANGED, + uno::Any(static_cast<sal_Int32>(-1)), + uno::Any(maLastSelection.nEndPos) ); + } + + ChangeChildFocus( aSelection.nEndPara ); + + SAL_INFO( + "svx", + "focus changed, Object: " << this + << ", Paragraph: " << aSelection.nEndPara + << ", Last paragraph: " + << maLastSelection.nEndPara); + } + } + + // #100530# no caret events if not focused. + if( mbGroupHasFocus ) + { + uno::Any aOldCursor; + + // #i13705# The old cursor can only contain valid + // values if it's the same paragraph! + if( maLastSelection.nStartPara != EE_PARA_NOT_FOUND && + maLastSelection.nEndPara == aSelection.nEndPara ) + { + aOldCursor <<= maLastSelection.nEndPos; + } + else + { + aOldCursor <<= static_cast<sal_Int32>(-1); + } + + maParaManager.FireEvent( aSelection.nEndPara, + aSelection.nEndPara+1, + AccessibleEventId::CARET_CHANGED, + uno::Any(aSelection.nEndPos), + aOldCursor ); + } + + SAL_INFO( + "svx", + "caret changed, Object: " << this << ", New pos: " + << aSelection.nEndPos << ", Old pos: " + << maLastSelection.nEndPos << ", New para: " + << aSelection.nEndPara << ", Old para: " + << maLastSelection.nEndPara); + + // #108947# Sort new range before calling FireEvent + ::std::pair<sal_Int32, sal_Int32> sortedSelection( + makeSortedPair(::std::min( aSelection.nStartPara, nMaxValidParaIndex ), + ::std::min( aSelection.nEndPara, nMaxValidParaIndex ) ) ); + + // #108947# Sort last range before calling FireEvent + ::std::pair<sal_Int32, sal_Int32> sortedLastSelection( + makeSortedPair(::std::min( maLastSelection.nStartPara, nMaxValidParaIndex ), + ::std::min( maLastSelection.nEndPara, nMaxValidParaIndex ) ) ); + + // event TEXT_SELECTION_CHANGED has to be submitted. (#i27299#) + const sal_Int16 nTextSelChgEventId = + AccessibleEventId::TEXT_SELECTION_CHANGED; + // #107037# notify selection change + if( maLastSelection.nStartPara == EE_PARA_NOT_FOUND ) + { + // last selection is undefined + // use method <ESelection::HasRange()> (#i27299#) + if ( aSelection.HasRange() ) + { + // selection was undefined, now is on + maParaManager.FireEvent( sortedSelection.first, + sortedSelection.second+1, + nTextSelChgEventId ); + } + } + else + { + // last selection is valid + // use method <ESelection::HasRange()> (#i27299#) + if ( maLastSelection.HasRange() && + !aSelection.HasRange() ) + { + // selection was on, now is empty + maParaManager.FireEvent( sortedLastSelection.first, + sortedLastSelection.second+1, + nTextSelChgEventId ); + } + // use method <ESelection::HasRange()> (#i27299#) + else if( !maLastSelection.HasRange() && + aSelection.HasRange() ) + { + // selection was empty, now is on + maParaManager.FireEvent( sortedSelection.first, + sortedSelection.second+1, + nTextSelChgEventId ); + } + // no event TEXT_SELECTION_CHANGED event, if new and + // last selection are empty. (#i27299#) + else if ( maLastSelection.HasRange() && + aSelection.HasRange() ) + { + // use sorted last and new selection + ESelection aTmpLastSel( maLastSelection ); + aTmpLastSel.Adjust(); + ESelection aTmpSel( aSelection ); + aTmpSel.Adjust(); + // first submit event for new and changed selection + sal_Int32 nPara = aTmpSel.nStartPara; + for ( ; nPara <= aTmpSel.nEndPara; ++nPara ) + { + if ( nPara < aTmpLastSel.nStartPara || + nPara > aTmpLastSel.nEndPara ) + { + // new selection on paragraph <nPara> + maParaManager.FireEvent( nPara, + nTextSelChgEventId ); + } + else + { + // check for changed selection on paragraph <nPara> + const sal_Int32 nParaStartPos = + nPara == aTmpSel.nStartPara + ? aTmpSel.nStartPos : 0; + const sal_Int32 nParaEndPos = + nPara == aTmpSel.nEndPara + ? aTmpSel.nEndPos : -1; + const sal_Int32 nLastParaStartPos = + nPara == aTmpLastSel.nStartPara + ? aTmpLastSel.nStartPos : 0; + const sal_Int32 nLastParaEndPos = + nPara == aTmpLastSel.nEndPara + ? aTmpLastSel.nEndPos : -1; + if ( nParaStartPos != nLastParaStartPos || + nParaEndPos != nLastParaEndPos ) + { + maParaManager.FireEvent( + nPara, nTextSelChgEventId ); + } + } + } + // second submit event for 'old' selections + nPara = aTmpLastSel.nStartPara; + for ( ; nPara <= aTmpLastSel.nEndPara; ++nPara ) + { + if ( nPara < aTmpSel.nStartPara || + nPara > aTmpSel.nEndPara ) + { + maParaManager.FireEvent( nPara, + nTextSelChgEventId ); + } + } + } + } + + maLastSelection = aSelection; + } + } + } + // no selection? no update actions + catch( const uno::RuntimeException& ) {} + } + + void AccessibleTextHelper_Impl::ShutdownEditSource() + { + // This should only be called with solar mutex locked, i.e. from the main office thread + + // This here is somewhat clumsy: As soon as our children have + // a NULL EditSource (maParaManager.SetEditSource()), they + // enter the disposed state and cannot be reanimated. Thus, it + // is unavoidable and a hard requirement to let go and create + // from scratch each and every child. + + // invalidate children + maParaManager.Dispose(); + maParaManager.SetNum(0); + + // lost all children + if( mxFrontEnd.is() ) + FireEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN); + + // quit listen on stale edit source + if( maEditSource.IsValid() ) + EndListening( maEditSource.GetBroadcaster() ); + + maEditSource.SetEditSource( ::std::unique_ptr< SvxEditSource >() ); + } + + void AccessibleTextHelper_Impl::SetEditSource( ::std::unique_ptr< SvxEditSource > && pEditSource ) + { + // This should only be called with solar mutex locked, i.e. from the main office thread + + // shutdown old edit source + ShutdownEditSource(); + + // set new edit source + maEditSource.SetEditSource( std::move(pEditSource) ); + + // init child vector to the current child count + if( maEditSource.IsValid() ) + { + maParaManager.SetNum( GetTextForwarder().GetParagraphCount() ); + + // listen on new edit source + StartListening( maEditSource.GetBroadcaster() ); + + UpdateVisibleChildren(); + } + } + + void AccessibleTextHelper_Impl::SetOffset( const Point& rPoint ) + { + // guard against non-atomic access to maOffset data structure + { + std::scoped_lock aGuard( maMutex ); + maOffset = rPoint; + } + + maParaManager.SetEEOffset( rPoint ); + + // in all cases, check visibility afterwards. + UpdateVisibleChildren(); + UpdateBoundRect(); + } + + void AccessibleTextHelper_Impl::UpdateVisibleChildren( bool bBroadcastEvents ) + { + try + { + SvxTextForwarder& rCacheTF = GetTextForwarder(); + sal_Int32 nParas=rCacheTF.GetParagraphCount(); + + // GetTextForwarder might have replaced everything, update + // paragraph count in case it's outdated + maParaManager.SetNum( nParas ); + + mnFirstVisibleChild = -1; + mnLastVisibleChild = -2; + + for( sal_Int32 nCurrPara=0; nCurrPara<nParas; ++nCurrPara ) + { + if (nCurrPara == 0) + mnFirstVisibleChild = nCurrPara; + mnLastVisibleChild = nCurrPara; + if (mxFrontEnd.is() && bBroadcastEvents) + { + // child not yet created? + if (!maParaManager.HasCreatedChild(nCurrPara)) + { + GotPropertyEvent( uno::Any( maParaManager.CreateChild( nCurrPara - mnFirstVisibleChild, + mxFrontEnd, GetEditSource(), nCurrPara ).first ), + AccessibleEventId::CHILD ); + } + } + } + } + catch( const uno::Exception& ) + { + OSL_FAIL("AccessibleTextHelper_Impl::UpdateVisibleChildren error while determining visible children"); + + // something failed - currently no children + mnFirstVisibleChild = -1; + mnLastVisibleChild = -2; + maParaManager.SetNum(0); + + // lost all children + if( bBroadcastEvents ) + FireEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN); + } + } + + void AccessibleTextHelper_Impl::UpdateBoundRect() + { + // send BOUNDRECT_CHANGED to affected children + for(auto it = maParaManager.begin(); it != maParaManager.end(); ++it) + { + ::accessibility::AccessibleParaManager::WeakChild& rChild = *it; + // retrieve hard reference from weak one + auto aHardRef( rChild.first.get() ); + + if( aHardRef.is() ) + { + awt::Rectangle aNewRect = aHardRef->getBounds(); + const awt::Rectangle& aOldRect = rChild.second; + + if( aNewRect.X != aOldRect.X || + aNewRect.Y != aOldRect.Y || + aNewRect.Width != aOldRect.Width || + aNewRect.Height != aOldRect.Height ) + { + // visible data changed + aHardRef->FireEvent( AccessibleEventId::BOUNDRECT_CHANGED ); + + // update internal bounds + rChild = ::accessibility::AccessibleParaManager::WeakChild( rChild.first, aNewRect ); + } + } + } + } + +#ifdef DBG_UTIL + void AccessibleTextHelper_Impl::CheckInvariants() const + { + if( mnFirstVisibleChild >= 0 && + mnFirstVisibleChild > mnLastVisibleChild ) + { + OSL_FAIL( "AccessibleTextHelper: range invalid" ); + } + } +#endif + + namespace { + + // functor for sending child events (no stand-alone function, they are maybe not inlined) + class AccessibleTextHelper_LostChildEvent + { + public: + explicit AccessibleTextHelper_LostChildEvent( AccessibleTextHelper_Impl& rImpl ) : mrImpl(rImpl) {} + void operator()( const ::accessibility::AccessibleParaManager::WeakChild& rPara ) + { + // retrieve hard reference from weak one + auto aHardRef( rPara.first.get() ); + + if( aHardRef.is() ) + mrImpl.FireEvent(AccessibleEventId::CHILD, uno::Any(), uno::Any(css::uno::Reference<css::accessibility::XAccessible>(aHardRef)) ); + } + + private: + AccessibleTextHelper_Impl& mrImpl; + }; + + } + + void AccessibleTextHelper_Impl::ParagraphsMoved( sal_Int32 nFirst, sal_Int32 nMiddle, sal_Int32 nLast ) + { + const sal_Int32 nParas = GetTextForwarder().GetParagraphCount(); + + /* rotate paragraphs + * ================= + * + * Three cases: + * + * 1. + * ... nParagraph ... nParam1 ... nParam2 ... + * |______________[xxxxxxxxxxx] + * becomes + * [xxxxxxxxxxx]|______________ + * + * tail is 0 + * + * 2. + * ... nParam1 ... nParagraph ... nParam2 ... + * [xxxxxxxxxxx|xxxxxxxxxxxxxx]____________ + * becomes + * ____________[xxxxxxxxxxx|xxxxxxxxxxxxxx] + * + * tail is nParagraph - nParam1 + * + * 3. + * ... nParam1 ... nParam2 ... nParagraph ... + * [xxxxxxxxxxx]___________|____________ + * becomes + * ___________|____________[xxxxxxxxxxx] + * + * tail is nParam2 - nParam1 + */ + + // sort nParagraph, nParam1 and nParam2 in ascending order, calc range + if( nMiddle < nFirst ) + { + ::std::swap(nFirst, nMiddle); + } + else if( nMiddle < nLast ) + { + nLast = nLast + nMiddle - nFirst; + } + else + { + ::std::swap(nMiddle, nLast); + nLast = nLast + nMiddle - nFirst; + } + + if( !(nFirst < nParas && nMiddle < nParas && nLast < nParas) ) + return; + + // since we have no "paragraph index + // changed" event on UAA, remove + // [first,last] and insert again later (in + // UpdateVisibleChildren) + + // maParaManager.Rotate( nFirst, nMiddle, nLast ); + + // send CHILD_EVENT to affected children + ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin(); + ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin; + + ::std::advance( begin, nFirst ); + ::std::advance( end, nLast+1 ); + + // TODO: maybe optimize here in the following way. If the + // number of removed children exceeds a certain threshold, + // use InvalidateFlags::Children + AccessibleTextHelper_LostChildEvent aFunctor( *this ); + + ::std::for_each( begin, end, aFunctor ); + + maParaManager.Release(nFirst, nLast+1); + // should be no need for UpdateBoundRect, since all affected children are cleared. + } + + namespace { + + // functor for sending child events (no stand-alone function, they are maybe not inlined) + class AccessibleTextHelper_ChildrenTextChanged + { + public: + void operator()( ::accessibility::AccessibleEditableTextPara& rPara ) + { + rPara.TextChanged(); + } + }; + + /** functor processing queue events + + Reacts on SfxHintId::TextParaInserted/REMOVED events and stores + their content + */ + class AccessibleTextHelper_QueueFunctor + { + public: + AccessibleTextHelper_QueueFunctor() : + mnParasChanged( 0 ), + mnParaIndex(-1), + mnHintId(SfxHintId::NONE) + {} + void operator()( const SfxHint* pEvent ) + { + if( !pEvent || mnParasChanged == -1 ) + return; + + // determine hint type + const TextHint* pTextHint = dynamic_cast<const TextHint*>( pEvent ); + const SvxEditSourceHint* pEditSourceHint = dynamic_cast<const SvxEditSourceHint*>( pEvent ); + + if( !(!pEditSourceHint && pTextHint && + (pTextHint->GetId() == SfxHintId::TextParaInserted || + pTextHint->GetId() == SfxHintId::TextParaRemoved )) ) + return; + + if( pTextHint->GetValue() == EE_PARA_ALL ) + { + mnParasChanged = -1; + } + else + { + mnHintId = pTextHint->GetId(); + mnParaIndex = pTextHint->GetValue(); + ++mnParasChanged; + } + } + + /** Query number of paragraphs changed during queue processing. + + @return number of changed paragraphs, -1 for + "every paragraph changed" + */ + sal_Int32 GetNumberOfParasChanged() const { return mnParasChanged; } + /** Query index of last added/removed paragraph + + @return index of lastly added paragraphs, -1 for none + added so far. + */ + sal_Int32 GetParaIndex() const { return mnParaIndex; } + /** Query hint id of last interesting event + + @return hint id of last interesting event (REMOVED/INSERTED). + */ + SfxHintId GetHintId() const { return mnHintId; } + + private: + /** number of paragraphs changed during queue processing. -1 for + "every paragraph changed" + */ + sal_Int32 mnParasChanged; + /// index of paragraph added/removed last + sal_Int32 mnParaIndex; + /// TextHint ID (removed/inserted) of last interesting event + SfxHintId mnHintId; + }; + + } + + void AccessibleTextHelper_Impl::ProcessQueue() + { + // inspect queue for paragraph insert/remove events. If there + // is exactly _one_ of those in the queue, and the number of + // paragraphs has changed by exactly one, use that event to + // determine a priori which paragraph was added/removed. This + // is necessary, since I must sync right here with the + // EditEngine state (number of paragraphs etc.), since I'm + // potentially sending listener events right away. + AccessibleTextHelper_QueueFunctor aFunctor; + maEventQueue.ForEach( aFunctor ); + + const sal_Int32 nNewParas( GetTextForwarder().GetParagraphCount() ); + const sal_Int32 nCurrParas( maParaManager.GetNum() ); + + // whether every paragraph already is updated (no need to + // repeat that later on, e.g. for PARA_MOVED events) + bool bEverythingUpdated( false ); + + if( std::abs( nNewParas - nCurrParas ) == 1 && + aFunctor.GetNumberOfParasChanged() == 1 ) + { + // #103483# Exactly one paragraph added/removed. This is + // the normal case, optimize event handling here. + + if( aFunctor.GetHintId() == SfxHintId::TextParaInserted ) + { + // update num of paras + maParaManager.SetNum( nNewParas ); + + // release everything from the insertion position until the end + maParaManager.Release(aFunctor.GetParaIndex(), nCurrParas); + + // TODO: Clarify whether this behaviour _really_ saves + // anybody anything! + // update children, _don't_ broadcast + UpdateVisibleChildren( false ); + UpdateBoundRect(); + + // send insert event + // #109864# Enforce creation of this paragraph + try + { + GotPropertyEvent( uno::Any( getAccessibleChild( aFunctor.GetParaIndex() - + mnFirstVisibleChild + GetStartIndex() ) ), + AccessibleEventId::CHILD ); + } + catch( const uno::Exception& ) + { + OSL_FAIL("AccessibleTextHelper_Impl::ProcessQueue: could not create new paragraph"); + } + } + else if( aFunctor.GetHintId() == SfxHintId::TextParaRemoved ) + { + ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator begin = maParaManager.begin(); + ::std::advance( begin, aFunctor.GetParaIndex() ); + ::accessibility::AccessibleParaManager::VectorOfChildren::const_iterator end = begin; + ::std::advance( end, 1 ); + + // #i61812# remember para to be removed for later notification + // AFTER the new state is applied (that after the para got removed) + ::uno::Reference< XAccessible > xPara(begin->first.get()); + + // release everything from the remove position until the end + maParaManager.Release(aFunctor.GetParaIndex(), nCurrParas); + + // update num of paras + maParaManager.SetNum( nNewParas ); + + // TODO: Clarify whether this behaviour _really_ saves + // anybody anything! + // update children, _don't_ broadcast + UpdateVisibleChildren( false ); + UpdateBoundRect(); + + // #i61812# notification for removed para + if (xPara.is()) + FireEvent(AccessibleEventId::CHILD, uno::Any(), uno::Any( xPara) ); + } +#ifdef DBG_UTIL + else + OSL_FAIL("AccessibleTextHelper_Impl::ProcessQueue() invalid hint id"); +#endif + } + else if( nNewParas != nCurrParas ) + { + // release all paras + maParaManager.Release(0, nCurrParas); + + // update num of paras + maParaManager.SetNum( nNewParas ); + + // #109864# create from scratch, don't broadcast + UpdateVisibleChildren( false ); + UpdateBoundRect(); + + // number of paragraphs somehow changed - but we have no + // chance determining how. Thus, throw away everything and + // create from scratch. + // (child events should be broadcast after the changes are done...) + FireEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN); + + // no need for further updates later on + bEverythingUpdated = true; + } + + bool bUpdatedBoundRectAndVisibleChildren(false); + + while( !maEventQueue.IsEmpty() ) + { + ::std::unique_ptr< SfxHint > pHint( maEventQueue.PopFront() ); + if (pHint) + { + const SfxHint& rHint = *pHint; + + // Note, if you add events here, you need to update the AccessibleTextEventQueue::Append + // code, because only the events we process here, are actually queued there. + + try + { + + if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint) + { + const SdrHint* pSdrHint = static_cast< const SdrHint* >( &rHint ); + + switch( pSdrHint->GetKind() ) + { + case SdrHintKind::BeginEdit: + { + if(!IsActive()) + { + break; + } + // change children state + maParaManager.SetActive(); + + // per definition, edit mode text has the focus + SetFocus( true ); + break; + } + + case SdrHintKind::EndEdit: + { + // focused child now loses focus + ESelection aSelection; + if( GetEditViewForwarder().GetSelection( aSelection ) ) + SetChildFocus( aSelection.nEndPara, false ); + + // change children state + maParaManager.SetActive( false ); + + maLastSelection = ESelection( EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, + EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND); + break; + } + default: + break; + } + } + else if( const SvxEditSourceHint* pEditSourceHint = dynamic_cast<const SvxEditSourceHint*>( &rHint ) ) + { + switch( pEditSourceHint->GetId() ) + { + case SfxHintId::EditSourceParasMoved: + { + DBG_ASSERT( pEditSourceHint->GetStartValue() < GetTextForwarder().GetParagraphCount() && + pEditSourceHint->GetEndValue() < GetTextForwarder().GetParagraphCount(), + "AccessibleTextHelper_Impl::NotifyHdl: Invalid notification"); + + if( !bEverythingUpdated ) + { + ParagraphsMoved(pEditSourceHint->GetStartValue(), + pEditSourceHint->GetValue(), + pEditSourceHint->GetEndValue()); + + // in all cases, check visibility afterwards. + UpdateVisibleChildren(); + } + break; + } + + case SfxHintId::EditSourceSelectionChanged: + // notify listeners + try + { + UpdateSelection(); + } + // maybe we're not in edit mode (this is not an error) + catch( const uno::Exception& ) {} + break; + default: break; + } + } + else if( const TextHint* pTextHint = dynamic_cast<const TextHint*>( &rHint ) ) + { + const sal_Int32 nParas = GetTextForwarder().GetParagraphCount(); + + switch( pTextHint->GetId() ) + { + case SfxHintId::TextModified: + { + // notify listeners + sal_Int32 nPara( pTextHint->GetValue() ); + + // #108900# Delegate change event to children + AccessibleTextHelper_ChildrenTextChanged aNotifyChildrenFunctor; + + if( nPara == EE_PARA_ALL ) + { + // #108900# Call every child + ::std::for_each( maParaManager.begin(), maParaManager.end(), + AccessibleParaManager::WeakChildAdapter< AccessibleTextHelper_ChildrenTextChanged > (aNotifyChildrenFunctor) ); + } + else + if( nPara < nParas ) + { + // #108900# Call child at index nPara + ::std::for_each( maParaManager.begin()+nPara, maParaManager.begin()+nPara+1, + AccessibleParaManager::WeakChildAdapter< AccessibleTextHelper_ChildrenTextChanged > (aNotifyChildrenFunctor) ); + } + break; + } + + case SfxHintId::TextParaInserted: + // already happened above + break; + + case SfxHintId::TextParaRemoved: + // already happened above + break; + + case SfxHintId::TextHeightChanged: + // visibility changed, done below + break; + + case SfxHintId::TextViewScrolled: + // visibility changed, done below + break; + default: break; + } + + // in all cases, check visibility afterwards. + if (!bUpdatedBoundRectAndVisibleChildren) + { + UpdateVisibleChildren(); + UpdateBoundRect(); + bUpdatedBoundRectAndVisibleChildren = true; + } + } + else if ( dynamic_cast<const SvxViewChangedHint*>( &rHint ) ) + { + // just check visibility + if (!bUpdatedBoundRectAndVisibleChildren) + { + UpdateVisibleChildren(); + UpdateBoundRect(); + bUpdatedBoundRectAndVisibleChildren = true; + } + } + // it's VITAL to keep the SfxSimpleHint last! It's the base of some classes above! + else if( rHint.GetId() == SfxHintId::Dying) + { + // edit source is dying under us, become defunc then + try + { + // make edit source inaccessible + // Note: cannot destroy it here, since we're called from there! + ShutdownEditSource(); + } + catch( const uno::Exception& ) {} + } + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + } + } + } + } + + void AccessibleTextHelper_Impl::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) + { + // precondition: solar mutex locked + DBG_TESTSOLARMUTEX(); + + // precondition: not in a recursion + if( mbInNotify ) + return; + + mbInNotify = true; + + try + { + // Process notification event, arranged in order of likelihood of + // occurrence to avoid unnecessary dynamic_cast. Note that + // SvxEditSourceHint is derived from TextHint, so has to be checked + // before that. + if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint) + { + const SdrHint* pSdrHint = static_cast< const SdrHint* >( &rHint ); + // process drawing layer events right away, if not + // within an open EE notification frame. Otherwise, + // event processing would be delayed until next EE + // notification sequence. + maEventQueue.Append( *pSdrHint ); + } + else if( const SvxViewChangedHint* pViewHint = dynamic_cast<const SvxViewChangedHint*>( &rHint ) ) + { + // process visibility right away, if not within an + // open EE notification frame. Otherwise, event + // processing would be delayed until next EE + // notification sequence. + maEventQueue.Append( *pViewHint ); + } + else if( const SvxEditSourceHint* pEditSourceHint = dynamic_cast<const SvxEditSourceHint*>( &rHint ) ) + { + // EditEngine should emit TEXT_SELECTION_CHANGED events (#i27299#) + maEventQueue.Append( *pEditSourceHint ); + } + else if( const TextHint* pTextHint = dynamic_cast<const TextHint*>( &rHint ) ) + { + // EditEngine should emit TEXT_SELECTION_CHANGED events (#i27299#) + if(pTextHint->GetId() == SfxHintId::TextProcessNotifications) + ProcessQueue(); + else + maEventQueue.Append( *pTextHint ); + } + // it's VITAL to keep the SfxHint last! It's the base of the classes above! + else if( rHint.GetId() == SfxHintId::Dying ) + { + // handle this event _at once_, because after that, objects are invalid + // edit source is dying under us, become defunc then + maEventQueue.Clear(); + try + { + // make edit source inaccessible + // Note: cannot destroy it here, since we're called from there! + ShutdownEditSource(); + } + catch( const uno::Exception& ) {} + } + } + catch( const uno::Exception& ) + { + DBG_UNHANDLED_EXCEPTION("svx"); + mbInNotify = false; + } + + mbInNotify = false; + } + + void AccessibleTextHelper_Impl::Dispose() + { + if( getNotifierClientId() != snNotifierClientRevoked) + { + try + { + // #106234# Unregister from EventNotifier + ::comphelper::AccessibleEventNotifier::revokeClient( getNotifierClientId() ); + SAL_INFO("svx", "disposed ID: " << mnNotifierClientId ); + } + catch( const uno::Exception& ) {} + + mnNotifierClientId = snNotifierClientRevoked; + } + + try + { + // dispose children + maParaManager.Dispose(); + } + catch( const uno::Exception& ) {} + + // quit listen on stale edit source + if( maEditSource.IsValid() ) + EndListening( maEditSource.GetBroadcaster() ); + + // clear references + maEditSource.SetEditSource( ::std::unique_ptr< SvxEditSource >() ); + mxFrontEnd = nullptr; + } + + void AccessibleTextHelper_Impl::FireEvent( const sal_Int16 nEventId, const uno::Any& rNewValue, const uno::Any& rOldValue ) const + { + // -- object locked -- + AccessibleEventObject aEvent; + { + std::scoped_lock aGuard(maMutex); + + DBG_ASSERT(mxFrontEnd.is(), "AccessibleTextHelper::FireEvent: no event source set"); + + if (mxFrontEnd.is()) + aEvent = AccessibleEventObject(mxFrontEnd->getAccessibleContext(), nEventId, + rNewValue, rOldValue); + else + aEvent = AccessibleEventObject(uno::Reference<uno::XInterface>(), nEventId, + rNewValue, rOldValue); + + // no locking necessary, FireEvent internally copies listeners + // if someone removes/adds in between Further locking, + // actually, might lead to deadlocks, since we're calling out + // of this object + } + // -- until here -- + + FireEvent(aEvent); + } + + void AccessibleTextHelper_Impl::FireEvent( const AccessibleEventObject& rEvent ) const + { + // #106234# Delegate to EventNotifier + if (getNotifierClientId() != snNotifierClientRevoked) + ::comphelper::AccessibleEventNotifier::addEvent( getNotifierClientId(), rEvent ); + } + + // XAccessibleContext + sal_Int32 AccessibleTextHelper_Impl::getAccessibleChildCount() const + { + return mnLastVisibleChild - mnFirstVisibleChild + 1; + } + + uno::Reference< XAccessible > AccessibleTextHelper_Impl::getAccessibleChild( sal_Int32 i ) + { + i -= GetStartIndex(); + + if( 0 > i || i >= getAccessibleChildCount() || + GetTextForwarder().GetParagraphCount() <= i ) + { + throw lang::IndexOutOfBoundsException("Invalid child index", mxFrontEnd); + } + + DBG_ASSERT(mxFrontEnd.is(), "AccessibleTextHelper_Impl::UpdateVisibleChildren: no frontend set"); + + if( mxFrontEnd.is() ) + return maParaManager.CreateChild( i, mxFrontEnd, GetEditSource(), mnFirstVisibleChild + i ).first; + else + return nullptr; + } + + void AccessibleTextHelper_Impl::addAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) + { + if( getNotifierClientId() != snNotifierClientRevoked ) + ::comphelper::AccessibleEventNotifier::addEventListener( getNotifierClientId(), xListener ); + } + + void AccessibleTextHelper_Impl::removeAccessibleEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) + { + if( getNotifierClientId() == snNotifierClientRevoked ) + return; + + const sal_Int32 nListenerCount = ::comphelper::AccessibleEventNotifier::removeEventListener( getNotifierClientId(), xListener ); + if ( !nListenerCount ) + { + // 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( getNotifierClientId() ); + mnNotifierClientId = snNotifierClientRevoked; + ::comphelper::AccessibleEventNotifier::revokeClient( nId ); + } + } + + uno::Reference< XAccessible > AccessibleTextHelper_Impl::getAccessibleAtPoint( const awt::Point& _aPoint ) + { + // make given position relative + if( !mxFrontEnd.is() ) + throw uno::RuntimeException("AccessibleTextHelper_Impl::getAccessibleAt: frontend invalid", mxFrontEnd ); + + uno::Reference< XAccessibleContext > xFrontEndContext = mxFrontEnd->getAccessibleContext(); + + if( !xFrontEndContext.is() ) + throw uno::RuntimeException("AccessibleTextHelper_Impl::getAccessibleAt: frontend invalid", mxFrontEnd ); + + uno::Reference< XAccessibleComponent > xFrontEndComponent( xFrontEndContext, uno::UNO_QUERY_THROW ); + + // #103862# No longer need to make given position relative + Point aPoint( _aPoint.X, _aPoint.Y ); + + // respect EditEngine offset to surrounding shape/cell + aPoint -= GetOffset(); + + // convert to EditEngine coordinate system + SvxTextForwarder& rCacheTF = GetTextForwarder(); + Point aLogPoint( GetViewForwarder().PixelToLogic( aPoint, rCacheTF.GetMapMode() ) ); + + // iterate over all visible children (including those not yet created) + sal_Int32 nChild; + for( nChild=mnFirstVisibleChild; nChild <= mnLastVisibleChild; ++nChild ) + { + DBG_ASSERT(nChild >= 0, + "AccessibleTextHelper_Impl::getAccessibleAt: index value overflow"); + + tools::Rectangle aParaBounds( rCacheTF.GetParaBounds( nChild ) ); + + if( aParaBounds.Contains( aLogPoint ) ) + return getAccessibleChild( nChild - mnFirstVisibleChild + GetStartIndex() ); + } + + // found none + return nullptr; + } + + + // AccessibleTextHelper implementation (simply forwards to impl) + + AccessibleTextHelper::AccessibleTextHelper( ::std::unique_ptr< SvxEditSource > && pEditSource ) : + mpImpl( new AccessibleTextHelper_Impl() ) + { + SolarMutexGuard aGuard; + + SetEditSource( std::move(pEditSource) ); + } + + AccessibleTextHelper::~AccessibleTextHelper() + { + } + + const SvxEditSource& AccessibleTextHelper::GetEditSource() const + { +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + const SvxEditSource& aEditSource = mpImpl->GetEditSource(); + + mpImpl->CheckInvariants(); + + return aEditSource; +#else + return mpImpl->GetEditSource(); +#endif + } + + void AccessibleTextHelper::SetEditSource( ::std::unique_ptr< SvxEditSource > && pEditSource ) + { +#ifdef DBG_UTIL + // precondition: solar mutex locked + DBG_TESTSOLARMUTEX(); + + mpImpl->CheckInvariants(); +#endif + + mpImpl->SetEditSource( std::move(pEditSource) ); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + void AccessibleTextHelper::SetEventSource( const uno::Reference< XAccessible >& rInterface ) + { +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + + mpImpl->SetEventSource( rInterface ); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + void AccessibleTextHelper::SetFocus( bool bHaveFocus ) + { +#ifdef DBG_UTIL + // precondition: solar mutex locked + DBG_TESTSOLARMUTEX(); + + mpImpl->CheckInvariants(); +#endif + + mpImpl->SetFocus( bHaveFocus ); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + bool AccessibleTextHelper::HaveFocus() + { +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + bool bRet( mpImpl->HaveFocus() ); + + mpImpl->CheckInvariants(); + + return bRet; +#else + return mpImpl->HaveFocus(); +#endif + } + + void AccessibleTextHelper::SetOffset( const Point& rPoint ) + { +#ifdef DBG_UTIL + // precondition: solar mutex locked + DBG_TESTSOLARMUTEX(); + + mpImpl->CheckInvariants(); +#endif + + mpImpl->SetOffset( rPoint ); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + void AccessibleTextHelper::SetStartIndex( sal_Int32 nOffset ) + { +#ifdef DBG_UTIL + // precondition: solar mutex locked + DBG_TESTSOLARMUTEX(); + + mpImpl->CheckInvariants(); +#endif + + mpImpl->SetStartIndex( nOffset ); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + sal_Int32 AccessibleTextHelper::GetStartIndex() const + { +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + sal_Int32 nOffset = mpImpl->GetStartIndex(); + + mpImpl->CheckInvariants(); + + return nOffset; +#else + return mpImpl->GetStartIndex(); +#endif + } + + void AccessibleTextHelper::SetAdditionalChildStates( VectorOfStates&& rChildStates ) + { + mpImpl->SetAdditionalChildStates( std::move(rChildStates) ); + } + + void AccessibleTextHelper::UpdateChildren() + { +#ifdef DBG_UTIL + // precondition: solar mutex locked + DBG_TESTSOLARMUTEX(); + + mpImpl->CheckInvariants(); +#endif + + mpImpl->UpdateVisibleChildren(); + mpImpl->UpdateBoundRect(); + + mpImpl->UpdateSelection(); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + void AccessibleTextHelper::Dispose() + { + // As Dispose calls ShutdownEditSource, which in turn + // deregisters as listener on the edit source, have to lock + // here + SolarMutexGuard aGuard; + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + + mpImpl->Dispose(); + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); +#endif + } + + // XAccessibleContext + sal_Int32 AccessibleTextHelper::GetChildCount() const + { + SolarMutexGuard aGuard; + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + sal_Int32 nRet = mpImpl->getAccessibleChildCount(); + + mpImpl->CheckInvariants(); + + return nRet; +#else + return mpImpl->getAccessibleChildCount(); +#endif + } + + uno::Reference< XAccessible > AccessibleTextHelper::GetChild( sal_Int32 i ) + { + SolarMutexGuard aGuard; + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + uno::Reference< XAccessible > xRet = mpImpl->getAccessibleChild( i ); + + mpImpl->CheckInvariants(); + + return xRet; +#else + return mpImpl->getAccessibleChild( i ); +#endif + } + + void AccessibleTextHelper::AddEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) + { +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + mpImpl->addAccessibleEventListener( xListener ); + + mpImpl->CheckInvariants(); +#else + mpImpl->addAccessibleEventListener( xListener ); +#endif + } + + void AccessibleTextHelper::RemoveEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) + { +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + mpImpl->removeAccessibleEventListener( xListener ); + + mpImpl->CheckInvariants(); +#else + mpImpl->removeAccessibleEventListener( xListener ); +#endif + } + + // XAccessibleComponent + uno::Reference< XAccessible > AccessibleTextHelper::GetAt( const awt::Point& aPoint ) + { + SolarMutexGuard aGuard; + +#ifdef DBG_UTIL + mpImpl->CheckInvariants(); + + uno::Reference< XAccessible > xChild = mpImpl->getAccessibleAtPoint( aPoint ); + + mpImpl->CheckInvariants(); + + return xChild; +#else + return mpImpl->getAccessibleAtPoint( aPoint ); +#endif + } + +} // end of namespace accessibility + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/ChildrenManager.cxx b/svx/source/accessibility/ChildrenManager.cxx new file mode 100644 index 000000000..71983f46e --- /dev/null +++ b/svx/source/accessibility/ChildrenManager.cxx @@ -0,0 +1,115 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svx/ChildrenManager.hxx> +#include "ChildrenManagerImpl.hxx" +#include <sal/log.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; +using ::com::sun::star::uno::Reference; + +namespace accessibility { + +// AccessibleChildrenManager +ChildrenManager::ChildrenManager ( + const css::uno::Reference<XAccessible>& rxParent, + const css::uno::Reference<drawing::XShapes>& rxShapeList, + const AccessibleShapeTreeInfo& rShapeTreeInfo, + AccessibleContextBase& rContext) + : mpImpl( + new ChildrenManagerImpl( + rxParent, rxShapeList, rShapeTreeInfo, rContext)) +{ + mpImpl->Init (); +} + + +ChildrenManager::~ChildrenManager() +{ + mpImpl->dispose(); + + // empty + SAL_INFO("svx", "~ChildrenManager"); +} + +tools::Long ChildrenManager::GetChildCount() const noexcept +{ + return mpImpl->GetChildCount(); +} + +css::uno::Reference<XAccessible> ChildrenManager::GetChild (tools::Long nIndex) +{ + return mpImpl->GetChild (nIndex); +} + +css::uno::Reference<css::drawing::XShape> ChildrenManager::GetChildShape(tools::Long nIndex) +{ + return mpImpl->GetChildShape(nIndex); +} + +void ChildrenManager::Update (bool bCreateNewObjectsOnDemand) +{ + mpImpl->Update (bCreateNewObjectsOnDemand); +} + +void ChildrenManager::SetShapeList (const css::uno::Reference<css::drawing::XShapes>& xShapeList) +{ + mpImpl->SetShapeList (xShapeList); +} + +void ChildrenManager::AddAccessibleShape (css::uno::Reference<css::accessibility::XAccessible> const & shape) +{ + mpImpl->AddAccessibleShape (shape); +} + +void ChildrenManager::ClearAccessibleShapeList() +{ + mpImpl->ClearAccessibleShapeList (); +} + +void ChildrenManager::SetInfo (AccessibleShapeTreeInfo const & rShapeTreeInfo) +{ + mpImpl->SetInfo (rShapeTreeInfo); +} + +void ChildrenManager::UpdateSelection() +{ + mpImpl->UpdateSelection (); +} + +bool ChildrenManager::HasFocus() const +{ + return mpImpl->HasFocus (); +} + +void ChildrenManager::RemoveFocus() +{ + mpImpl->RemoveFocus (); +} + +// IAccessibleViewForwarderListener +void ChildrenManager::ViewForwarderChanged() +{ + mpImpl->ViewForwarderChanged(); +} + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/ChildrenManagerImpl.cxx b/svx/source/accessibility/ChildrenManagerImpl.cxx new file mode 100644 index 000000000..b557e00a9 --- /dev/null +++ b/svx/source/accessibility/ChildrenManagerImpl.cxx @@ -0,0 +1,1051 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <sal/config.h> + +#include <cassert> + +#include "ChildrenManagerImpl.hxx" +#include <svx/ShapeTypeHandler.hxx> +#include <svx/AccessibleControlShape.hxx> +#include <svx/AccessibleShapeInfo.hxx> +#include <svx/IAccessibleViewForwarder.hxx> +#include <vcl/svapp.hxx> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/document/XShapeEventBroadcaster.hpp> +#include <com/sun/star/frame/XController.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <com/sun/star/view/XSelectionSupplier.hpp> +#include <com/sun/star/container/XChild.hpp> +#include <comphelper/types.hxx> +#include <o3tl/safeint.hxx> +#include <o3tl/sorted_vector.hxx> +#include <rtl/ustring.hxx> +#include <tools/debug.hxx> +#include <svx/SvxShapeTypes.hxx> +#include <vcl/window.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; +using ::com::sun::star::uno::Reference; + +namespace accessibility { + +namespace +{ +void adjustIndexInParentOfShapes(ChildDescriptorListType& _rList) +{ + sal_Int32 i=0; + for (auto& rItem : _rList) + { + rItem.setIndexAtAccessibleShape(i); + ++i; + } +} +} + +// AccessibleChildrenManager +ChildrenManagerImpl::ChildrenManagerImpl ( + const uno::Reference<XAccessible>& rxParent, + const uno::Reference<drawing::XShapes>& rxShapeList, + const AccessibleShapeTreeInfo& rShapeTreeInfo, + AccessibleContextBase& rContext) + : mxShapeList (rxShapeList), + mxParent (rxParent), + maShapeTreeInfo (rShapeTreeInfo), + mrContext (rContext), + mpFocusedShape(nullptr) +{ +} + + +ChildrenManagerImpl::~ChildrenManagerImpl() +{ + DBG_ASSERT (m_bDisposed, "~AccessibleDrawDocumentView: object has not been disposed"); +} + + +void ChildrenManagerImpl::Init() +{ + // Register as view::XSelectionChangeListener. + Reference<frame::XController> xController(maShapeTreeInfo.GetController()); + Reference<view::XSelectionSupplier> xSelectionSupplier ( + xController, uno::UNO_QUERY); + if (xSelectionSupplier.is()) + { + xController->addEventListener( + static_cast<document::XEventListener*>(this)); + + xSelectionSupplier->addSelectionChangeListener ( + static_cast<view::XSelectionChangeListener*>(this)); + } + + // Register at model as document::XEventListener. + if (maShapeTreeInfo.GetModelBroadcaster().is()) + maShapeTreeInfo.GetModelBroadcaster()->addEventListener ( + static_cast<document::XEventListener*>(this)); +} + + +tools::Long ChildrenManagerImpl::GetChildCount() const noexcept +{ + return maVisibleChildren.size(); +} + + +css::uno::Reference<css::drawing::XShape> ChildrenManagerImpl::GetChildShape(tools::Long nIndex) +{ + uno::Reference<XAccessible> xAcc = GetChild(nIndex); + auto I = std::find_if(maVisibleChildren.begin(), maVisibleChildren.end(), + [&xAcc](const ChildDescriptor& rChild) { return rChild.mxAccessibleShape == xAcc; }); + if (I != maVisibleChildren.end()) + return I->mxShape; + return uno::Reference< drawing::XShape > (); +} + +/** Return the requested accessible child object. Create it if it is not + yet in the cache. +*/ +uno::Reference<XAccessible> + ChildrenManagerImpl::GetChild (tools::Long nIndex) +{ + // Check whether the given index is valid. + if (nIndex < 0 || o3tl::make_unsigned(nIndex) >= maVisibleChildren.size()) + throw lang::IndexOutOfBoundsException ( + "no accessible child with index " + OUString::number(nIndex), + mxParent); + + return GetChild (maVisibleChildren[nIndex],nIndex); +} + + +/** Return the requested accessible child object. Create it if it is not + yet in the cache. +*/ +uno::Reference<XAccessible> + ChildrenManagerImpl::GetChild (ChildDescriptor& rChildDescriptor,sal_Int32 _nIndex) +{ + if ( ! rChildDescriptor.mxAccessibleShape.is()) + { + SolarMutexGuard g; + // Make sure that the requested accessible object has not been + // created while locking the global mutex. + if ( ! rChildDescriptor.mxAccessibleShape.is()) + { + AccessibleShapeInfo aShapeInfo( + rChildDescriptor.mxShape, + mxParent, + this); + // Create accessible object that corresponds to the descriptor's + // shape. + rtl::Reference<AccessibleShape> pShape( + ShapeTypeHandler::Instance().CreateAccessibleObject ( + aShapeInfo, + maShapeTreeInfo)); + rChildDescriptor.mxAccessibleShape = pShape; + if ( pShape.is() ) + { + pShape->Init(); + pShape->setIndexInParent(_nIndex); + } + } + } + + return rChildDescriptor.mxAccessibleShape; +} + + +/** Find all shapes among the specified shapes that lie fully or partially + inside the visible area. Put those shapes into the cleared cache. The + corresponding accessible objects will be created on demand. + + At the moment, first all accessible objects are removed from the cache + and the appropriate listeners are informed of this. Next, the list is + created again. This should be optimized in the future to not remove and + create objects that will be in the list before and after the update + method. +*/ +void ChildrenManagerImpl::Update (bool bCreateNewObjectsOnDemand) +{ + if (maShapeTreeInfo.GetViewForwarder() == nullptr) + return; + tools::Rectangle aVisibleArea = maShapeTreeInfo.GetViewForwarder()->GetVisibleArea(); + + // 1. Create a local list of visible shapes. + ChildDescriptorListType aChildList; + CreateListOfVisibleShapes (aChildList); + + // 2. Merge the information that is already known about the visible + // shapes from the current list into the new list. + MergeAccessibilityInformation (aChildList); + + // 3. Replace the current list of visible shapes with the new one. Do + // the same with the visible area. + { + SolarMutexGuard g; + adjustIndexInParentOfShapes(aChildList); + + // Use swap to copy the contents of the new list in constant time. + maVisibleChildren.swap (aChildList); + + // aChildList now contains all the old children, while maVisibleChildren + // contains all the current children + + // 4. Find all shapes in the old list that are not in the current list, + // send appropriate events and remove the accessible shape. + + // Do this *after* we have set our new list of children, because + // removing a child may cause + + // ChildDescriptor::disposeAccessibleObject --> + // AccessibleContextBase::CommitChange --> + // AtkListener::notifyEvent -> + // AtkListener::handleChildRemoved -> + // AtkListener::updateChildList + // AccessibleDrawDocumentView::getAccessibleChildCount -> + // ChildrenManagerImpl::GetChildCount -> + // maVisibleChildren.size() + + // to be fired, and so the operations will take place on + // the list we are trying to replace + + RemoveNonVisibleChildren (maVisibleChildren, aChildList); + + aChildList.clear(); + + maVisibleArea = aVisibleArea; + } + + // 5. If the visible area has changed then send events that signal a + // change of their bounding boxes for all shapes that are members of + // both the current and the new list of visible shapes. + if (maVisibleArea != aVisibleArea) + SendVisibleAreaEvents (maVisibleChildren); + + // 6. If children have to be created immediately and not on demand then + // create the missing accessible objects now. + if (bCreateNewObjectsOnDemand) + return; + + //operate on a copy of the list and restore it afterwards to guard + //against the pathological case where maVisibleChildren gets modified + //by other calls to this object while CreateAccessibilityObjects + //executes which can happen when java is disabled and the "enable-java" + //dialog appears during the instantiation of the linguistic components + //triggered by the creation of shapes belonging to the a11y objects + // + //i.e. launch start-center, launch impress with java disabled and + //a java-using linguistic component installed + maVisibleChildren.swap(aChildList); + CreateAccessibilityObjects(aChildList); + maVisibleChildren.swap(aChildList); +} + +void ChildrenManagerImpl::CreateListOfVisibleShapes ( + ChildDescriptorListType& raDescriptorList) +{ + SolarMutexGuard g; + + OSL_ASSERT (maShapeTreeInfo.GetViewForwarder() != nullptr); + + tools::Rectangle aVisibleArea = maShapeTreeInfo.GetViewForwarder()->GetVisibleArea(); + + // Add the visible shapes for which the accessible objects already exist. + for (const auto& rpShape : maAccessibleShapes) + { + if (rpShape.is()) + { + uno::Reference<XAccessibleComponent> xComponent ( + rpShape->getAccessibleContext(), uno::UNO_QUERY); + if (xComponent.is()) + { + // The bounding box of the object already is clipped to the + // visible area. The object is therefore visible if the + // bounding box has non-zero extensions. + awt::Rectangle aPixelBBox (xComponent->getBounds()); + if ((aPixelBBox.Width > 0) && (aPixelBBox.Height > 0)) + raDescriptorList.emplace_back(rpShape); + } + } + } + + // Add the visible shapes for which only the XShapes exist. + if (!mxShapeList.is() || !mxShapeList->hasElements()) + return; + + sal_Int32 nShapeCount = mxShapeList->getCount(); + raDescriptorList.reserve( nShapeCount ); + awt::Point aPos; + awt::Size aSize; + tools::Rectangle aBoundingBox; + uno::Reference<drawing::XShape> xShape; + for (sal_Int32 i=0; i<nShapeCount; ++i) + { + mxShapeList->getByIndex(i) >>= xShape; + aPos = xShape->getPosition(); + aSize = xShape->getSize(); + + aBoundingBox.SetLeft( aPos.X ); + aBoundingBox.SetTop( aPos.Y ); + aBoundingBox.SetRight( aPos.X + aSize.Width ); + aBoundingBox.SetBottom( aPos.Y + aSize.Height ); + + // Insert shape if it is visible, i.e. its bounding box overlaps + // the visible area. + if ( aBoundingBox.Overlaps(aVisibleArea) ) + raDescriptorList.emplace_back(xShape); + } +} + +void ChildrenManagerImpl::RemoveNonVisibleChildren ( + const ChildDescriptorListType& rNewChildList, + ChildDescriptorListType& rOldChildList) +{ + // Iterate over list of formerly visible children and remove those that + // are not visible anymore, i.e. member of the new list of visible + // children. + for (auto& rChild : rOldChildList) + { + if (::std::find(rNewChildList.begin(), rNewChildList.end(), rChild) == rNewChildList.end()) + { + // The child is disposed when there is a UNO shape from which + // the accessible shape can be created when the shape becomes + // visible again. When there is no such UNO shape then simply + // reset the descriptor but keep the accessibility object. + if (rChild.mxShape.is()) + { + UnregisterAsDisposeListener (rChild.mxShape); + rChild.disposeAccessibleObject (mrContext); + } + else + { + AccessibleShape* pAccessibleShape = rChild.GetAccessibleShape(); + pAccessibleShape->ResetState (AccessibleStateType::VISIBLE); + rChild.mxAccessibleShape = nullptr; + } + } + } +} + +void ChildrenManagerImpl::MergeAccessibilityInformation ( + ChildDescriptorListType& raNewChildList) +{ + ChildDescriptorListType::const_iterator aStartVisibleChildren = maVisibleChildren.begin(); + ChildDescriptorListType::const_iterator aEndVisibleChildren = maVisibleChildren.end(); + + for (auto& rChild : raNewChildList) + { + ChildDescriptorListType::const_iterator aOldChildDescriptor = + std::find(aStartVisibleChildren, aEndVisibleChildren, rChild); + + // Copy accessible shape if that exists in the old descriptor. + if (aOldChildDescriptor != aEndVisibleChildren && + aOldChildDescriptor->mxAccessibleShape.is()) + { + rChild.mxAccessibleShape = aOldChildDescriptor->mxAccessibleShape; + rChild.mbCreateEventPending = false; + } + else + RegisterAsDisposeListener (rChild.mxShape); + } +} + +void ChildrenManagerImpl::SendVisibleAreaEvents ( + ChildDescriptorListType& raNewChildList) +{ + for (const auto& rChild : raNewChildList) + { + // Tell shape of changed visible area. To do this, fake a + // change of the view forwarder. (Actually we usually get here + // as a result of a change of the view forwarder). + AccessibleShape* pShape = rChild.GetAccessibleShape (); + if (pShape != nullptr) + pShape->ViewForwarderChanged(); + } +} + + +void ChildrenManagerImpl::CreateAccessibilityObjects ( + ChildDescriptorListType& raNewChildList) +{ + sal_Int32 nPos = 0; + for ( auto& rChild : raNewChildList) + { + // Create the associated accessible object when the flag says so and + // it does not yet exist. + if ( ! rChild.mxAccessibleShape.is() ) + GetChild (rChild, nPos); + if (rChild.mxAccessibleShape.is() && rChild.mbCreateEventPending) + { + rChild.mbCreateEventPending = false; + mrContext.CommitChange ( + AccessibleEventId::CHILD, + uno::Any(rChild.mxAccessibleShape), + uno::Any()); + } + ++nPos; + } +} + + +void ChildrenManagerImpl::AddShape (const Reference<drawing::XShape>& rxShape) +{ + if (!rxShape.is()) + return; + + SolarMutexClearableGuard aGuard; + + // Test visibility of the shape. + tools::Rectangle aVisibleArea = maShapeTreeInfo.GetViewForwarder()->GetVisibleArea(); + awt::Point aPos = rxShape->getPosition(); + awt::Size aSize = rxShape->getSize(); + + tools::Rectangle aBoundingBox ( + aPos.X, + aPos.Y, + aPos.X + aSize.Width, + aPos.Y + aSize.Height); + + // Add the shape only when it belongs to the list of shapes stored + // in mxShapeList (which is either a page or a group shape). + Reference<container::XChild> xChild (rxShape, uno::UNO_QUERY); + if (!xChild.is()) + return; + + Reference<drawing::XShapes> xParent (xChild->getParent(), uno::UNO_QUERY); + if (xParent != mxShapeList) + return; + + if (!aBoundingBox.Overlaps(aVisibleArea)) + return; + + // Add shape to list of visible shapes. + maVisibleChildren.emplace_back(rxShape); + + // Create accessibility object. + ChildDescriptor& rDescriptor = maVisibleChildren.back(); + GetChild (rDescriptor, maVisibleChildren.size()-1); + + // Inform listeners about new child. + uno::Any aNewShape; + aNewShape <<= rDescriptor.mxAccessibleShape; + aGuard.clear(); + mrContext.CommitChange ( + AccessibleEventId::CHILD, + aNewShape, + uno::Any()); + RegisterAsDisposeListener(rxShape); +} + + +void ChildrenManagerImpl::RemoveShape (const Reference<drawing::XShape>& rxShape) +{ + if (!rxShape.is()) + return; + + SolarMutexGuard g; + + // Search shape in list of visible children. + ChildDescriptorListType::iterator I ( + ::std::find (maVisibleChildren.begin(), maVisibleChildren.end(), + ChildDescriptor (rxShape))); + if (I == maVisibleChildren.end()) + return; + + // Remove descriptor from that list. + Reference<XAccessible> xHoldAlive(I->mxAccessibleShape); + + UnregisterAsDisposeListener (I->mxShape); + // Dispose the accessible object. + I->disposeAccessibleObject (mrContext); + + // Now we can safely remove the child descriptor and thus + // invalidate the iterator. + maVisibleChildren.erase (I); + + adjustIndexInParentOfShapes(maVisibleChildren); +} + + +void ChildrenManagerImpl::SetShapeList (const css::uno::Reference<css::drawing::XShapes>& xShapeList) +{ + mxShapeList = xShapeList; +} + + +void ChildrenManagerImpl::AddAccessibleShape (css::uno::Reference<css::accessibility::XAccessible> const & shape) +{ + assert(shape.is()); + maAccessibleShapes.push_back (shape); +} + + +void ChildrenManagerImpl::ClearAccessibleShapeList() +{ + // Copy the list of (visible) shapes to local lists and clear the + // originals. + ChildDescriptorListType aLocalVisibleChildren; + aLocalVisibleChildren.swap(maVisibleChildren); + AccessibleShapeList aLocalAccessibleShapes; + aLocalAccessibleShapes.swap(maAccessibleShapes); + + // Tell the listeners that all children are gone. + mrContext.CommitChange ( + AccessibleEventId::INVALIDATE_ALL_CHILDREN, + uno::Any(), + uno::Any()); + + // Now the objects in the local lists can be safely disposed without + // having problems with callers that want to update their child lists. + + // Clear the list of visible accessible objects. Objects not created on + // demand for XShapes are treated below. + for (auto& rChild : aLocalVisibleChildren) + if ( rChild.mxAccessibleShape.is() && rChild.mxShape.is() ) + { + ::comphelper::disposeComponent(rChild.mxAccessibleShape); + rChild.mxAccessibleShape = nullptr; + } + + // Dispose all objects in the accessible shape list. + for (auto& rpShape : aLocalAccessibleShapes) + if (rpShape.is()) + { + // Dispose the object. + ::comphelper::disposeComponent(rpShape); + rpShape = nullptr; + } +} + + +/** If the broadcasters change at which this object is registered then + unregister at old and register at new broadcasters. +*/ +void ChildrenManagerImpl::SetInfo (const AccessibleShapeTreeInfo& rShapeTreeInfo) +{ + // Remember the current broadcasters and exchange the shape tree info. + Reference<document::XEventBroadcaster> xCurrentBroadcaster; + Reference<frame::XController> xCurrentController; + Reference<view::XSelectionSupplier> xCurrentSelectionSupplier; + { + SolarMutexGuard g; + xCurrentBroadcaster = maShapeTreeInfo.GetModelBroadcaster(); + xCurrentController = maShapeTreeInfo.GetController(); + xCurrentSelectionSupplier.set( xCurrentController, uno::UNO_QUERY); + maShapeTreeInfo = rShapeTreeInfo; + } + + // Move registration to new model. + if (maShapeTreeInfo.GetModelBroadcaster() != xCurrentBroadcaster) + { + // Register at new broadcaster. + if (maShapeTreeInfo.GetModelBroadcaster().is()) + maShapeTreeInfo.GetModelBroadcaster()->addEventListener ( + static_cast<document::XEventListener*>(this)); + + // Unregister at old broadcaster. + if (xCurrentBroadcaster.is()) + xCurrentBroadcaster->removeEventListener ( + static_cast<document::XEventListener*>(this)); + } + + // Move registration to new selection supplier. + Reference<frame::XController> xNewController(maShapeTreeInfo.GetController()); + Reference<view::XSelectionSupplier> xNewSelectionSupplier ( + xNewController, uno::UNO_QUERY); + if (xNewSelectionSupplier == xCurrentSelectionSupplier) + return; + + // Register at new broadcaster. + if (xNewSelectionSupplier.is()) + { + xNewController->addEventListener( + static_cast<document::XEventListener*>(this)); + + xNewSelectionSupplier->addSelectionChangeListener ( + static_cast<view::XSelectionChangeListener*>(this)); + } + + // Unregister at old broadcaster. + if (xCurrentSelectionSupplier.is()) + { + xCurrentSelectionSupplier->removeSelectionChangeListener ( + static_cast<view::XSelectionChangeListener*>(this)); + + xCurrentController->removeEventListener( + static_cast<document::XEventListener*>(this)); + } +} + +// lang::XEventListener +void SAL_CALL + ChildrenManagerImpl::disposing (const lang::EventObject& rEventObject) +{ + if (rEventObject.Source == maShapeTreeInfo.GetModelBroadcaster() + || rEventObject.Source == maShapeTreeInfo.GetController()) + { + impl_dispose(); + } + + // Handle disposing UNO shapes. + else + { + Reference<drawing::XShape> xShape (rEventObject.Source, uno::UNO_QUERY); + + // Find the descriptor for the given shape. + ChildDescriptorListType::iterator I ( + ::std::find (maVisibleChildren.begin(), maVisibleChildren.end(), + ChildDescriptor (xShape))); + if (I != maVisibleChildren.end()) + { + // Clear the descriptor. + I->disposeAccessibleObject (mrContext); + I->mxShape = nullptr; + } + } +} + +// document::XEventListener +/** Listen for new and removed shapes. +*/ +void SAL_CALL + ChildrenManagerImpl::notifyEvent ( + const document::EventObject& rEventObject) +{ + if (rEventObject.EventName == "ShapeInserted") + AddShape (Reference<drawing::XShape>(rEventObject.Source, uno::UNO_QUERY)); + else if (rEventObject.EventName == "ShapeRemoved") + RemoveShape (Reference<drawing::XShape>(rEventObject.Source, uno::UNO_QUERY)); + // else ignore unknown event. +} + +// view::XSelectionChangeListener +void SAL_CALL + ChildrenManagerImpl::selectionChanged (const lang::EventObject& /*rEvent*/) +{ + UpdateSelection (); +} + + +void ChildrenManagerImpl::impl_dispose() +{ + Reference<frame::XController> xController(maShapeTreeInfo.GetController()); + // Remove from broadcasters. + try + { + Reference<view::XSelectionSupplier> xSelectionSupplier ( + xController, uno::UNO_QUERY); + if (xSelectionSupplier.is()) + { + xSelectionSupplier->removeSelectionChangeListener ( + static_cast<view::XSelectionChangeListener*>(this)); + } + } + catch( uno::RuntimeException&) + {} + + try + { + if (xController.is()) + xController->removeEventListener( + static_cast<document::XEventListener*>(this)); + } + catch( uno::RuntimeException&) + {} + + maShapeTreeInfo.SetController (nullptr); + + try + { + // Remove from broadcaster. + if (maShapeTreeInfo.GetModelBroadcaster().is()) + maShapeTreeInfo.GetModelBroadcaster()->removeEventListener ( + static_cast<document::XEventListener*>(this)); + maShapeTreeInfo.SetModelBroadcaster (nullptr); + } + catch( uno::RuntimeException& ) + {} + + ClearAccessibleShapeList (); + SetShapeList (nullptr); +} + + +void ChildrenManagerImpl::disposing(std::unique_lock<std::mutex>&) +{ + impl_dispose(); +} + +// IAccessibleViewForwarderListener +void ChildrenManagerImpl::ViewForwarderChanged() +{ + Update(false); +} + +// IAccessibleParent +bool ChildrenManagerImpl::ReplaceChild ( + AccessibleShape* pCurrentChild, + const css::uno::Reference< css::drawing::XShape >& _rxShape, + const tools::Long /*_nIndex*/, + const AccessibleShapeTreeInfo& _rShapeTreeInfo) +{ + // Iterate over the visible children. If one of them has an already + // created accessible object that matches pCurrentChild then replace + // it. Otherwise the child to replace is either not in the list or has + // not ye been created (and is therefore not in the list, too) and a + // replacement is not necessary. + auto I = std::find_if(maVisibleChildren.begin(), maVisibleChildren.end(), + [&pCurrentChild](const ChildDescriptor& rChild) { return rChild.GetAccessibleShape() == pCurrentChild; }); + + if (I != maVisibleChildren.end()) + { + // Dispose the current child and send an event about its deletion. + pCurrentChild->dispose(); + mrContext.CommitChange ( + AccessibleEventId::CHILD, + uno::Any(), + uno::Any (I->mxAccessibleShape)); + + // Replace with replacement and send an event about existence + // of the new child. + AccessibleShapeInfo aShapeInfo( _rxShape, pCurrentChild->getAccessibleParent(), this ); + // create the new child + rtl::Reference<AccessibleShape> pNewChild(ShapeTypeHandler::Instance().CreateAccessibleObject ( + aShapeInfo, + _rShapeTreeInfo + )); + if ( pNewChild.is() ) + pNewChild->Init(); + + I->mxAccessibleShape = pNewChild.get(); + mrContext.CommitChange ( + AccessibleEventId::CHILD, + uno::Any (I->mxAccessibleShape), + uno::Any()); + + return true; + } + + // When not found among the visible children we have to search the list + // of accessible shapes. This is not yet implemented. + return false; +} + +// Add the impl method for IAccessibleParent interface +AccessibleControlShape * ChildrenManagerImpl::GetAccControlShapeFromModel(css::beans::XPropertySet* pSet) +{ + sal_Int32 count = GetChildCount(); + for (sal_Int32 index=0;index<count;index++) + { + AccessibleShape* pAccShape = maVisibleChildren[index].GetAccessibleShape(); + if (pAccShape && ::accessibility::ShapeTypeHandler::Instance().GetTypeId(pAccShape->GetXShape()) == DRAWING_CONTROL) + { + auto* pCtlAccShape = static_cast<::accessibility::AccessibleControlShape*>(pAccShape); + if (pCtlAccShape->GetControlModel() == pSet) + return pCtlAccShape; + } + } + return nullptr; +} +uno::Reference<XAccessible> + ChildrenManagerImpl::GetAccessibleCaption (const uno::Reference<drawing::XShape>& xShape) +{ + auto I = std::find_if(maVisibleChildren.begin(), maVisibleChildren.end(), + [&xShape](const ChildDescriptor& rChild) { return rChild.mxShape.get() == xShape.get(); }); + if (I != maVisibleChildren.end()) + return I->mxAccessibleShape; + return uno::Reference<XAccessible> (); +} + +/** Update the <const>SELECTED</const> and the <const>FOCUSED</const> state + of all visible children. Maybe this should be changed to all children. + + Iterate over all descriptors of visible accessible shapes and look them + up in the selection. + + If there is no valid controller then all shapes are deselected and + unfocused. If the controller's frame is not active then all shapes are + unfocused. +*/ +void ChildrenManagerImpl::UpdateSelection() +{ + // Remember the current and new focused shape. + AccessibleShape* pCurrentlyFocusedShape = nullptr; + AccessibleShape* pNewFocusedShape = nullptr; + typedef std::pair< AccessibleShape* , sal_Bool > PAIR_SHAPE;//sal_Bool Selected,UnSelected. + typedef std::vector< PAIR_SHAPE > VEC_SHAPE; + VEC_SHAPE vecSelect; + int nAddSelect=0; + bool bHasSelectedShape=false; + if (!maVisibleChildren.empty()) + { + Reference<frame::XController> xController(maShapeTreeInfo.GetController()); + Reference<view::XSelectionSupplier> xSelectionSupplier ( + xController, uno::UNO_QUERY); + + // Try to cast the selection both to a multi selection and to a single + // selection. + Reference<container::XIndexAccess> xSelectedShapeAccess; + Reference<drawing::XShape> xSelectedShape; + if (xSelectionSupplier.is()) + { + xSelectedShapeAccess.set( xSelectionSupplier->getSelection(), uno::UNO_QUERY); + xSelectedShape.set( xSelectionSupplier->getSelection(), uno::UNO_QUERY); + } + + // tdf#139220 to quickly find if a given drawing::XShape is selected + o3tl::sorted_vector<css::uno::Reference<css::drawing::XShape>> aSortedSelectedShapes; + if (!xSelectedShape.is() && xSelectedShapeAccess.is()) + { + sal_Int32 nCount = xSelectedShapeAccess->getCount(); + aSortedSelectedShapes.reserve(nCount); + for (sal_Int32 i = 0; i < nCount; ++i) + { + css::uno::Reference<css::drawing::XShape> xShape(xSelectedShapeAccess->getByIndex(i), uno::UNO_QUERY); + aSortedSelectedShapes.insert(xShape); + } + } + + for (const auto& rChild : maVisibleChildren) + { + AccessibleShape* pAccessibleShape = rChild.GetAccessibleShape(); + if (rChild.mxAccessibleShape.is() && rChild.mxShape.is() && pAccessibleShape!=nullptr) + { + short nRole = pAccessibleShape->getAccessibleRole(); + bool bDrawShape = ( + nRole == AccessibleRole::GRAPHIC || + nRole == AccessibleRole::EMBEDDED_OBJECT || + nRole == AccessibleRole::SHAPE || + nRole == AccessibleRole::IMAGE_MAP || + nRole == AccessibleRole::TABLE_CELL || + nRole == AccessibleRole::TABLE ); + bool bShapeIsSelected = false; + + // Look up the shape in the (single or multi-) selection. + if (xSelectedShape.is()) + { + if (rChild.mxShape == xSelectedShape) + { + bShapeIsSelected = true; + pNewFocusedShape = pAccessibleShape; + } + } + else if (!aSortedSelectedShapes.empty()) + { + if (aSortedSelectedShapes.find(rChild.mxShape) != aSortedSelectedShapes.end()) + { + bShapeIsSelected = true; + // In a multi-selection no shape has the focus. + if (aSortedSelectedShapes.size() == 1) + pNewFocusedShape = pAccessibleShape; + } + } + + // Set or reset the SELECTED state. + if (bShapeIsSelected) + { + if (pAccessibleShape->SetState (AccessibleStateType::SELECTED)) + { + if (bDrawShape) + { + vecSelect.emplace_back(pAccessibleShape,true); + ++nAddSelect; + } + } + else + {//Selected not change,has selected shape before + bHasSelectedShape=true; + } + } + else + //pAccessibleShape->ResetState (AccessibleStateType::SELECTED); + { + if(pAccessibleShape->ResetState (AccessibleStateType::SELECTED)) + { + if(bDrawShape) + { + vecSelect.emplace_back(pAccessibleShape,false); + } + } + } + // Does the shape have the current selection? + if (pAccessibleShape->GetState (AccessibleStateType::FOCUSED)) + pCurrentlyFocusedShape = pAccessibleShape; + } + } + } + + vcl::Window *pParentWindow = maShapeTreeInfo.GetWindow(); + bool bShapeActive= false; + // For table cell, the table's parent must be checked to make sure it has focus. + if (pParentWindow) + { + vcl::Window *pPWindow = pParentWindow->GetParent(); + if (pParentWindow->HasFocus() || (pPWindow && pPWindow->HasFocus())) + bShapeActive =true; + } + // Move focus from current to newly focused shape. + if (pCurrentlyFocusedShape != pNewFocusedShape) + { + if (pCurrentlyFocusedShape != nullptr) + pCurrentlyFocusedShape->ResetState (AccessibleStateType::FOCUSED); + if (pNewFocusedShape != nullptr && bShapeActive) + pNewFocusedShape->SetState (AccessibleStateType::FOCUSED); + } + + if (nAddSelect >= 10 )//fire selection within + { + mrContext.CommitChange(AccessibleEventId::SELECTION_CHANGED_WITHIN,uno::Any(),uno::Any()); + nAddSelect =0 ;//not fire selection event + } + for (VEC_SHAPE::reverse_iterator vi = vecSelect.rbegin(), aEndVecSelect = vecSelect.rend(); vi != aEndVecSelect ;++vi) + { + PAIR_SHAPE &pairShape= *vi; + Reference< XAccessible > xShape(pairShape.first); + uno::Any anyShape; + anyShape <<= xShape; + + if (pairShape.second)//Selection add + { + if (bHasSelectedShape) + { + if ( nAddSelect > 0 ) + { + mrContext.CommitChange(AccessibleEventId::SELECTION_CHANGED_ADD,anyShape,uno::Any()); + } + } + else + { + //if has not selected shape ,first selected shape is fire selection event; + if (nAddSelect > 0 ) + { + mrContext.CommitChange(AccessibleEventId::SELECTION_CHANGED,anyShape,uno::Any()); + } + if (nAddSelect > 1 )//check other selected shape fire selection add event + { + bHasSelectedShape=true; + } + } + } + else //selection remove + { + mrContext.CommitChange(AccessibleEventId::SELECTION_CHANGED_REMOVE,anyShape,uno::Any()); + } + } + + // Remember whether there is a shape that now has the focus. + mpFocusedShape = pNewFocusedShape; +} + + +bool ChildrenManagerImpl::HasFocus() const +{ + return mpFocusedShape != nullptr; +} + + +void ChildrenManagerImpl::RemoveFocus() +{ + if (mpFocusedShape != nullptr) + { + mpFocusedShape->ResetState (AccessibleStateType::FOCUSED); + mpFocusedShape = nullptr; + } +} + + +void ChildrenManagerImpl::RegisterAsDisposeListener ( + const Reference<drawing::XShape>& xShape) +{ + Reference<lang::XComponent> xComponent (xShape, uno::UNO_QUERY); + if (xComponent.is()) + xComponent->addEventListener ( + static_cast<document::XEventListener*>(this)); +} + + +void ChildrenManagerImpl::UnregisterAsDisposeListener ( + const Reference<drawing::XShape>& xShape) +{ + Reference<lang::XComponent> xComponent (xShape, uno::UNO_QUERY); + if (xComponent.is()) + xComponent->removeEventListener ( + static_cast<document::XEventListener*>(this)); +} + +// AccessibleChildDescriptor +ChildDescriptor::ChildDescriptor (const Reference<drawing::XShape>& xShape) + : mxShape (xShape), + mbCreateEventPending (true) +{ + // Empty. +} + + +ChildDescriptor::ChildDescriptor (const Reference<XAccessible>& rxAccessibleShape) + : mxAccessibleShape (rxAccessibleShape), + mbCreateEventPending (true) +{ + // Make sure that the accessible object has the <const>VISIBLE</const> + // state set. + AccessibleShape* pAccessibleShape = GetAccessibleShape(); + pAccessibleShape->SetState (AccessibleStateType::VISIBLE); +} + +AccessibleShape* ChildDescriptor::GetAccessibleShape() const +{ + return static_cast<AccessibleShape*> (mxAccessibleShape.get()); +} + +void ChildDescriptor::setIndexAtAccessibleShape(sal_Int32 _nIndex) +{ + AccessibleShape* pShape = GetAccessibleShape(); + if ( pShape ) + pShape->setIndexInParent(_nIndex); +} + + +void ChildDescriptor::disposeAccessibleObject (AccessibleContextBase& rParent) +{ + if (!mxAccessibleShape.is()) + return; + + // Send event that the shape has been removed. + uno::Any aOldValue; + aOldValue <<= mxAccessibleShape; + rParent.CommitChange ( + AccessibleEventId::CHILD, + uno::Any(), + aOldValue); + + // Dispose and remove the object. + Reference<lang::XComponent> xComponent (mxAccessibleShape, uno::UNO_QUERY); + if (xComponent.is()) + xComponent->dispose (); + + mxAccessibleShape = nullptr; +} + + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/ChildrenManagerImpl.hxx b/svx/source/accessibility/ChildrenManagerImpl.hxx new file mode 100644 index 000000000..f4105c878 --- /dev/null +++ b/svx/source/accessibility/ChildrenManagerImpl.hxx @@ -0,0 +1,494 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_ACCESSIBILITY_CHILDRENMANAGERIMPL_HXX +#define INCLUDED_SVX_SOURCE_ACCESSIBILITY_CHILDRENMANAGERIMPL_HXX + +#include <svx/IAccessibleViewForwarderListener.hxx> +#include <svx/IAccessibleParent.hxx> +#include <svx/AccessibleShapeTreeInfo.hxx> +#include <editeng/AccessibleContextBase.hxx> +#include <comphelper/compbase.hxx> +#include <tools/gen.hxx> +#include <vector> +#include <com/sun/star/drawing/XShape.hpp> +#include <com/sun/star/drawing/XShapes.hpp> +#include <com/sun/star/document/XEventListener.hpp> +#include <com/sun/star/view/XSelectionChangeListener.hpp> +#include <com/sun/star/accessibility/XAccessible.hpp> + +namespace accessibility { + +class AccessibleShape; + +class ChildDescriptor; // See below for declaration. +typedef ::std::vector<ChildDescriptor> ChildDescriptorListType; + +// Re-using MutexOwner class defined in AccessibleContextBase.hxx + +/** This class contains the actual implementation of the children manager. + + <p>It maintains a set of visible accessible shapes in + <member>maVisibleChildren</member>. The objects in this list stem from + two sources. The first is a list of UNO shapes like the list of shapes + in a draw page. A reference to this list is held in + <member>maShapeList</member>. Accessible objects for these shapes are + created on demand. The list can be replaced by calls to the + <member>SetShapeList</member> method. The second source is a list of + already accessible objects. It can be modified by calls to the + <member>AddAccessibleShape</member> and + <member>ClearAccessibleShapeList</member> methods.</p> + + <p>Each call of the <member>Update</member> method leads to a + re-calculation of the visible shapes which then can be queried with the + <member>GetChildCount</member> and <member>GetChild</member> methods. + Events are sent informing all listeners about the removed shapes which are + not visible anymore and about the added shapes.</p> + + <p> The visible area which is used to determine the visibility of the + shapes is taken from the view forwarder. Thus, to signal a change of + the visible area call <member>ViewForwarderChanged</member>.</p> + + <p>The children manager adds itself as disposing() listener at every UNO + shape it creates an accessible object for so that when the UNO shape + passes away it can dispose() the associated accessible object.</p> + + @see ChildrenManager +*/ +class ChildrenManagerImpl final + : public comphelper::WeakComponentImplHelper< + css::document::XEventListener, + css::view::XSelectionChangeListener>, + public IAccessibleViewForwarderListener, + public IAccessibleParent +{ +public: + /** Create a children manager, which manages the children of the given + parent. The parent is used for creating accessible objects. The + list of shapes for which to create those objects is not derived from + the parent and has to be provided separately by calling one of the + update methods. + @param rxParent + The parent of the accessible objects which will be created + on demand at some point of time in the future. + @param rxShapeList + List of UNO shapes to manage. + @param rShapeTreeInfo + Bundle of information passed down the shape tree. + @param rContext + An accessible context object that is called for firing events + for new and deleted children, i.e. that holds a list of + listeners to be informed. + */ + ChildrenManagerImpl (const css::uno::Reference<css::accessibility::XAccessible>& rxParent, + const css::uno::Reference<css::drawing::XShapes>& rxShapeList, + const AccessibleShapeTreeInfo& rShapeTreeInfo, + AccessibleContextBase& rContext); + + /** If there still are managed children these are disposed and + released. + */ + virtual ~ChildrenManagerImpl() override; + + /** Do that part of the initialization that you can not or should not do + in the constructor like registering at broadcasters. + */ + void Init(); + + /** Return the number of currently visible accessible children. + @return + If there are no children a 0 is returned. + */ + tools::Long GetChildCount() const noexcept; + + /// @throws css::uno::RuntimeException + /// @throws css::lang::IndexOutOfBoundsException + css::uno::Reference<css::drawing::XShape> GetChildShape(tools::Long nIndex); + /** Return the requested accessible child or throw and + IndexOutOfBoundsException if the given index is invalid. + @param nIndex + Index of the requested child. Call getChildCount for obtaining + the number of children. + @return + In case of a valid index this method returns a reference to the + requested accessible child. This reference is empty if it has + not been possible to create the accessible object of the + corresponding shape. + @throws + Throws an IndexOutOfBoundsException if the index is not valid. + */ + css::uno::Reference<css::accessibility::XAccessible> + GetChild (tools::Long nIndex); + + /** Return the requested accessible child. + @param aChildDescriptor + This object contains references to the original shape and its + associated accessible object. + @param _nIndex + The index which will be used in getAccessibleIndexInParent of the accessible shape. + @return + Returns a reference to the requested accessible child. This + reference is empty if it has not been possible to create the + accessible object of the corresponding shape. + @throws css::uno::RuntimeException + */ + css::uno::Reference<css::accessibility::XAccessible> + GetChild (ChildDescriptor& aChildDescriptor,sal_Int32 _nIndex); + + /** Update the child manager. Take care of a modified set of children + and modified visible area. This method can optimize the update + process with respect separate updates of a modified children list + and visible area. + @param bCreateNewObjectsOnDemand + If </true> then accessible objects associated with the visible + shapes are created only when asked for. No event is sent on + creation. If </false> then the accessible objects are created + before this method returns and events are sent to inform the + listeners of the new object. + */ + void Update (bool bCreateNewObjectsOnDemand); + + /** Set the list of UNO shapes to the given list. This removes the old + list and does not add to it. The list of accessible shapes that is + build up by calls to <member>AddAccessibleShape</member> is not + modified. Neither is the list of visible children. Accessible + objects are created on demand. + @param xShapeList + The list of UNO shapes that replaces the old list. + */ + void SetShapeList (const css::uno::Reference<css::drawing::XShapes>& xShapeList); + + /** Add an accessible shape. This does not modify the list of UNO shapes + or the list of visible shapes. Accessible shapes are, at the + moment, not tested against the visible area but are always appended + to the list of visible children. + @param shape + The new shape that is added to the list of accessible shapes; must + be non-null. + */ + void AddAccessibleShape (css::uno::Reference<css::accessibility::XAccessible> const & shape); + + /** Clear the lists of accessible shapes and that of visible accessible + shapes. The list of UNO shapes is not modified. + */ + void ClearAccessibleShapeList(); + + /** Set a new event shape tree info. Call this method to inform the + children manager of a change of the info bundle. + @param rShapeTreeInfo + The new info that replaces the current one. + */ + void SetInfo (const AccessibleShapeTreeInfo& rShapeTreeInfo); + + /** Update the SELECTED and FOCUSED states of all visible children + according to the given selection. This includes setting + <em>and</em> resetting the states. + */ + void UpdateSelection(); + + /** Return whether one of the shapes managed by this object has + currently the focus. + @return + Returns <true/> when there is a shape that has the focus and + <false/> when there is no such shape. + */ + bool HasFocus() const; + + /** When there is a shape that currently has the focus, + i.e. <member>HasFocus()</member> returns <true/> then remove the + focus from that shape. Otherwise nothing changes. + */ + void RemoveFocus(); + + // lang::XEventListener + virtual void SAL_CALL + disposing (const css::lang::EventObject& rEventObject) override; + + // document::XEventListener + virtual void SAL_CALL + notifyEvent (const css::document::EventObject& rEventObject) override; + + // view::XSelectionChangeListener + virtual void SAL_CALL + selectionChanged (const css::lang::EventObject& rEvent) override; + + // IAccessibleViewForwarderListener + /** Informs this children manager and its children about a change of one + (or more) aspect of the view forwarder. + @param aChangeType + A change type of <const>VISIBLE_AREA</const> leads to a call to + the <member>Update</member> which creates accessible objects of + new shapes immediately. Other change types are passed to the + visible accessible children without calling + <member>Update</member>. + @param pViewForwarder + The modified view forwarder. Use this one from now on. + */ + virtual void ViewForwarderChanged() override; + + // IAccessibleParent + /** Replace the specified child with a replacement. + @param pCurrentChild + This child is to be replaced. + @param pReplacement + The replacement for the current child. + @return + The returned value indicates whether the replacement has been + finished successfully. + */ + virtual bool ReplaceChild ( + AccessibleShape* pCurrentChild, + const css::uno::Reference< css::drawing::XShape >& _rxShape, + const tools::Long _nIndex, + const AccessibleShapeTreeInfo& _rShapeTreeInfo + ) override; + + // Add the impl method for IAccessibleParent interface + virtual AccessibleControlShape* GetAccControlShapeFromModel + (css::beans::XPropertySet* pSet) override; + virtual css::uno::Reference<css::accessibility::XAccessible> + GetAccessibleCaption (const css::uno::Reference<css::drawing::XShape>& xShape) override; + +private: + /** This list holds the descriptors of all currently visible shapes and + associated accessible object. + + <p>With the descriptors it maintains a mapping of shapes to + accessible objects. It acts as a cache in that accessible objects + are only created on demand and released with every update (where the + latter may be optimized by the update methods).<p> + + <p>The list is realized as a vector because it remains unchanged + between updates (i.e. complete rebuilds of the list) and allows a + fast (constant time) access to its elements for given indices.</p> + */ + ChildDescriptorListType maVisibleChildren; + + /** The original list of UNO shapes. The visible shapes are inserted + into the list of visible children + <member>maVisibleChildren</member>. + */ + css::uno::Reference<css::drawing::XShapes> mxShapeList; + + /** This list of additional accessible shapes that can or shall not be + created by the shape factory. + */ + typedef std::vector< css::uno::Reference< css::accessibility::XAccessible> > AccessibleShapeList; + AccessibleShapeList maAccessibleShapes; + + /** Rectangle that describes the visible area in which a shape has to lie + at least partly, to be accessible through this class. Used to + detect changes of the visible area after changes of the view forwarder. + */ + tools::Rectangle maVisibleArea; + + /** The parent of the shapes. It is used for creating accessible + objects for given shapes. + */ + css::uno::Reference<css::accessibility::XAccessible> mxParent; + + /** Bundle of information passed down the shape tree. + */ + AccessibleShapeTreeInfo maShapeTreeInfo; + + /** Reference to an accessible context object that is used to inform its + listeners of new and removed children. + */ + AccessibleContextBase& mrContext; + + /** This method is called from the component helper base class while + disposing. + */ + virtual void disposing(std::unique_lock<std::mutex>&) override; + + void impl_dispose(); + + ChildrenManagerImpl (const ChildrenManagerImpl&) = delete; + ChildrenManagerImpl& operator= (const ChildrenManagerImpl&) = delete; + + /** This member points to the currently focused shape. It is NULL when + there is no focused shape. + */ + AccessibleShape* mpFocusedShape; + + /** Three helper functions for the <member>Update</member> method. + */ + + /** Create a list of visible shapes from the list of UNO shapes + <member>maShapeList</member> and the list of accessible objects. + @param raChildList + For every visible shape from the two sources mentioned above one + descriptor is added to this list. + */ + void CreateListOfVisibleShapes (ChildDescriptorListType& raChildList); + + /** From the old list of (former) visible shapes remove those that + are not member of the new list. Send appropriate events for every + such shape. + @param raNewChildList + The new list of visible children against which the old one + is compared. + @param raOldChildList + The old list of visible children against which the new one + is compared. + */ + void RemoveNonVisibleChildren ( + const ChildDescriptorListType& raNewChildList, + ChildDescriptorListType& raOldChildList); + + /** Merge the information that is already known about the visible shapes + from the current list into the new list. + @param raChildList + Information is merged from the current list of visible children + to this list. + */ + void MergeAccessibilityInformation (ChildDescriptorListType& raChildList); + + /** If the visible area has changed then send events that signal a + change of their bounding boxes for all shapes that are members of + both the current and the new list of visible shapes. + @param raChildList + Events are sent to all entries of this list that already contain + an accessible object. + */ + static void SendVisibleAreaEvents (ChildDescriptorListType& raChildList); + + /** If children have to be created immediately and not on demand the + create the missing accessible objects now. + @param raDescriptorList + Create an accessible object for every member of this list where + that object does not already exist. + */ + void CreateAccessibilityObjects (ChildDescriptorListType& raChildList); + + /** Add a single shape. Update all relevant data structures + accordingly. Use this method instead of <member>Update()</member> + when only a single shape has been added. + */ + void AddShape (const css::uno::Reference<css::drawing::XShape>& xShape); + + /** Remove a single shape. Update all relevant data structures + accordingly. Use this method instead of <member>Update()</member> + when only a single shape has been removed. + */ + void RemoveShape (const css::uno::Reference<css::drawing::XShape>& xShape); + + /** Add the children manager as dispose listener at the given shape so + that the associated accessible object can be disposed when the shape + is disposed. + @param xShape + Register at this shape as dispose listener. + */ + void RegisterAsDisposeListener (const css::uno::Reference<css::drawing::XShape>& xShape); + + /** Remove the children manager as dispose listener at the given shape + @param xShape + Unregister at this shape as dispose listener. + */ + void UnregisterAsDisposeListener (const css::uno::Reference<css::drawing::XShape>& xShape); +}; + + +/** A child descriptor holds a reference to a UNO shape and the + corresponding accessible object. There are two use cases: + <ol><li>The accessible object is only created on demand and is then + initially empty.</li> + <li>There is no UNO shape. The accessible object is given as argument + to the constructor.</li> + </ol> + In both cases the child descriptor assumes ownership over the accessible + object. +*/ +class ChildDescriptor +{ +public: + /** Reference to a (partially) visible shape. + */ + css::uno::Reference<css::drawing::XShape> mxShape; + + /** The corresponding accessible object. This reference is initially + empty and only replaced by a reference to a new object when that is + requested from the outside. + */ + css::uno::Reference<css::accessibility::XAccessible> mxAccessibleShape; + + /** Return a pointer to the implementation object of the accessible + shape of this descriptor. + @return + The result is NULL if either the UNO reference to the accessible + shape is empty or it can not be transformed into a pointer to + the desired class. + */ + AccessibleShape* GetAccessibleShape() const; + + /** set the index _nIndex at the accessible shape + @param _nIndex + The new index in parent. + */ + void setIndexAtAccessibleShape(sal_Int32 _nIndex); + + /** This flag is set during the visibility calculation and indicates + that at one time in this process an event is sent that informs the + listeners of the creation of a new accessible object. This flags is + not reset afterwards. Don't use it unless you know exactly what you + are doing. + */ + bool mbCreateEventPending; + + /** Create a new descriptor for the specified shape with empty reference + to accessible object. + */ + explicit ChildDescriptor (const css::uno::Reference<css::drawing::XShape>& xShape); + + /** Create a new descriptor for the specified shape with empty reference + to the original shape. + */ + explicit ChildDescriptor (const css::uno::Reference<css::accessibility::XAccessible>& rxAccessibleShape); + + /** Dispose the accessible object of this descriptor. If that object + does not exist then do nothing. + @param rParent + The parent of the accessible object to dispose. A child event + is sent in its name. + */ + void disposeAccessibleObject (AccessibleContextBase& rParent); + + /** Compare two child descriptors. Take into account that a child + descriptor may be based on a UNO shape or, already, on an accessible + shape. + */ + bool operator == (const ChildDescriptor& aDescriptor) const + { + return ( + this == &aDescriptor || + ( + (mxShape.get() == aDescriptor.mxShape.get() ) && + (mxShape.is() || mxAccessibleShape.get() == aDescriptor.mxAccessibleShape.get()) + ) + ); + } + +}; + + +} // end of namespace accessibility + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/DescriptionGenerator.cxx b/svx/source/accessibility/DescriptionGenerator.cxx new file mode 100644 index 000000000..fe4109149 --- /dev/null +++ b/svx/source/accessibility/DescriptionGenerator.cxx @@ -0,0 +1,187 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <DescriptionGenerator.hxx> +#include <com/sun/star/beans/PropertyState.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertyState.hpp> +#include <com/sun/star/container/XNamed.hpp> +#include <com/sun/star/drawing/XShape.hpp> +#include <vcl/svapp.hxx> + +// Includes for string resources. +#include <svx/strings.hrc> +#include <svx/dialmgr.hxx> + +#include "lookupcolorname.hxx" + +using namespace ::com::sun::star; + +namespace accessibility +{ +DescriptionGenerator::DescriptionGenerator(const uno::Reference<drawing::XShape>& xShape) + : mxShape(xShape) + , mxSet(mxShape, uno::UNO_QUERY) + , mbIsFirstProperty(true) +{ +} + +DescriptionGenerator::~DescriptionGenerator() {} + +void DescriptionGenerator::Initialize(TranslateId pResourceId) +{ + // Get the string from the resource for the specified id. + OUString sPrefix; + { + SolarMutexGuard aGuard; + sPrefix = SvxResId(pResourceId); + } + + // Forward the call with the resulting string. + Initialize(sPrefix); +} + +void DescriptionGenerator::Initialize(std::u16string_view sPrefix) +{ + msDescription = sPrefix; + if (!mxSet.is()) + return; + + { + SolarMutexGuard aGuard; + + msDescription.append(' '); + msDescription.append(SvxResId(RID_SVXSTR_A11Y_WITH)); + msDescription.append(' '); + + msDescription.append(SvxResId(RID_SVXSTR_A11Y_STYLE)); + msDescription.append('='); + } + + try + { + if (mxSet.is()) + { + uno::Any aValue = mxSet->getPropertyValue("Style"); + uno::Reference<container::XNamed> xStyle(aValue, uno::UNO_QUERY); + if (xStyle.is()) + msDescription.append(xStyle->getName()); + } + else + msDescription.append("<no style>"); + } + catch (const css::beans::UnknownPropertyException&) + { + msDescription.append("<unknown>"); + } +} + +OUString DescriptionGenerator::operator()() +{ + msDescription.append('.'); + return msDescription.makeStringAndClear(); +} + +void DescriptionGenerator::AddProperty(const OUString& sPropertyName, PropertyType aType) +{ + uno::Reference<beans::XPropertyState> xState(mxShape, uno::UNO_QUERY); + if (!xState.is() + || xState->getPropertyState(sPropertyName) == beans::PropertyState_DEFAULT_VALUE) + return; + + if (!mxSet.is()) + return; + + // Append a separator from previous Properties. + if (!mbIsFirstProperty) + msDescription.append(','); + else + { + SolarMutexGuard aGuard; + + msDescription.append(' '); + msDescription.append(SvxResId(RID_SVXSTR_A11Y_AND)); + msDescription.append(' '); + mbIsFirstProperty = false; + } + + // Delegate to type specific property handling. + switch (aType) + { + case PropertyType::Color: + AddColor(sPropertyName); + break; + case PropertyType::Integer: + AddInteger(sPropertyName); + break; + } +} + +void DescriptionGenerator::AppendString(std::u16string_view sString) +{ + msDescription.append(sString); +} + +/** Search for the given color in the global color table. If found append + its name to the description. Otherwise append its RGB tuple. +*/ +void DescriptionGenerator::AddColor(const OUString& sPropertyName) +{ + msDescription.append('='); + + try + { + tools::Long nValue(0); + if (mxSet.is()) + { + uno::Any aValue = mxSet->getPropertyValue(sPropertyName); + aValue >>= nValue; + } + + msDescription.append(lookUpColorName(nValue)); + } + catch (const css::beans::UnknownPropertyException&) + { + msDescription.append("<unknown>"); + } +} + +void DescriptionGenerator::AddInteger(const OUString& sPropertyName) +{ + msDescription.append('='); + + try + { + if (mxSet.is()) + { + uno::Any aValue = mxSet->getPropertyValue(sPropertyName); + tools::Long nValue = 0; + aValue >>= nValue; + msDescription.append(nValue); + } + } + catch (const css::beans::UnknownPropertyException&) + { + msDescription.append("<unknown>"); + } +} + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/GraphCtlAccessibleContext.cxx b/svx/source/accessibility/GraphCtlAccessibleContext.cxx new file mode 100644 index 000000000..531b75eb6 --- /dev/null +++ b/svx/source/accessibility/GraphCtlAccessibleContext.cxx @@ -0,0 +1,772 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/IllegalAccessibleComponentStateException.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <o3tl/safeint.hxx> +#include <osl/mutex.hxx> +#include <tools/gen.hxx> +#include <svtools/colorcfg.hxx> +#include <comphelper/accessibleeventnotifier.hxx> +#include <svx/sdrpaintwindow.hxx> + +#include <svx/ShapeTypeHandler.hxx> +#include <svx/AccessibleShapeInfo.hxx> +#include <GraphCtlAccessibleContext.hxx> +#include <svx/graphctl.hxx> +#include <svx/strings.hrc> +#include <svx/svdpage.hxx> +#include <svx/dialmgr.hxx> +#include <svx/sdrhittesthelper.hxx> + +// namespaces +using namespace ::cppu; +using namespace ::osl; +using namespace ::accessibility; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::drawing; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::accessibility; + +// internal +/** initialize this component and set default values */ +SvxGraphCtrlAccessibleContext::SvxGraphCtrlAccessibleContext( + GraphCtrl& rRepr ) : + + SvxGraphCtrlAccessibleContext_Base( m_aMutex ), + mpControl( &rRepr ), + mpModel (nullptr), + mpPage (nullptr), + mpView (nullptr), + mnClientId( 0 ), + mbDisposed( false ) +{ + if (mpControl != nullptr) + { + mpModel = mpControl->GetSdrModel(); + if (mpModel != nullptr) + mpPage = mpModel->GetPage( 0 ); + mpView = mpControl->GetSdrView(); + + if( mpModel == nullptr || mpPage == nullptr || mpView == nullptr ) + { + mbDisposed = true; + // Set all the pointers to NULL just in case they are used as + // a disposed flag. + mpModel = nullptr; + mpPage = nullptr; + mpView = nullptr; + } + } + + { + ::SolarMutexGuard aSolarGuard; + msName = SvxResId( RID_SVXSTR_GRAPHCTRL_ACC_NAME ); + msDescription = SvxResId( RID_SVXSTR_GRAPHCTRL_ACC_DESCRIPTION ); + } + + maTreeInfo.SetSdrView( mpView ); + maTreeInfo.SetWindow(mpControl->GetDrawingArea()->get_ref_device().GetOwnerWindow()); + maTreeInfo.SetViewForwarder( this ); +} + + +/** on destruction, this component is disposed and all dispose listeners + are called, except if this component was already disposed */ +SvxGraphCtrlAccessibleContext::~SvxGraphCtrlAccessibleContext() +{ + disposing(); +} + + +/** returns the XAccessible interface for a given SdrObject. + Multiple calls for the same SdrObject return the same XAccessible. +*/ +Reference< XAccessible > SvxGraphCtrlAccessibleContext::getAccessible( const SdrObject* pObj ) +{ + Reference<XAccessible> xAccessibleShape; + + if( pObj ) + { + // see if we already created an XAccessible for the given SdrObject + ShapesMapType::const_iterator iter = mxShapes.find( pObj ); + + if( iter != mxShapes.end() ) + { + // if we already have one, return it + xAccessibleShape = (*iter).second.get(); + } + else + { + // create a new one and remember in our internal map + Reference< XShape > xShape( Reference< XShape >::query( const_cast<SdrObject*>(pObj)->getUnoShape() ) ); + + css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent()); + AccessibleShapeInfo aShapeInfo (xShape,xParent); + // Create accessible object that corresponds to the descriptor's shape. + rtl::Reference<AccessibleShape> pAcc(ShapeTypeHandler::Instance().CreateAccessibleObject( + aShapeInfo, maTreeInfo)); + xAccessibleShape = pAcc.get(); + if (pAcc.is()) + { + pAcc->Init (); + } + mxShapes[pObj] = pAcc; + + // Create event and inform listeners of the object creation. + CommitChange( AccessibleEventId::CHILD, Any( xAccessibleShape ), Any( Reference<XAccessible>() ) ); + } + } + + return xAccessibleShape; +} + +// XAccessible +Reference< XAccessibleContext > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleContext() +{ + return this; +} + +// XAccessibleComponent +sal_Bool SAL_CALL SvxGraphCtrlAccessibleContext::containsPoint( const awt::Point& rPoint ) +{ + // no guard -> done in getSize() + awt::Size aSize (getSize()); + return (rPoint.X >= 0) + && (rPoint.X < aSize.Width) + && (rPoint.Y >= 0) + && (rPoint.Y < aSize.Height); +} + + +Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleAtPoint( const awt::Point& rPoint ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + Reference< XAccessible > xAccessible; + + if( !mpControl ) + { + throw DisposedException(); + } + + Point aPnt( rPoint.X, rPoint.Y ); + aPnt = mpControl->GetDrawingArea()->get_ref_device().PixelToLogic(aPnt); + + SdrObject* pObj = nullptr; + + if(mpView && mpView->GetSdrPageView()) + { + pObj = SdrObjListPrimitiveHit(*mpPage, aPnt, 1, *mpView->GetSdrPageView(), nullptr, false); + } + + if( pObj ) + xAccessible = getAccessible( pObj ); + + return xAccessible; +} + +awt::Rectangle SAL_CALL SvxGraphCtrlAccessibleContext::getBounds() +{ + const SolarMutexGuard aSolarGuard; + + if (nullptr == mpControl) + throw DisposedException(); + + const Point aOutPos; + const Size aOutSize( mpControl->GetOutputSizePixel() ); + awt::Rectangle aRet; + + aRet.X = aOutPos.X(); + aRet.Y = aOutPos.Y(); + aRet.Width = aOutSize.Width(); + aRet.Height = aOutSize.Height(); + + return aRet; +} + +awt::Point SAL_CALL SvxGraphCtrlAccessibleContext::getLocation() +{ + const SolarMutexGuard aSolarGuard; + + if (nullptr == mpControl) + throw DisposedException(); + + const awt::Rectangle aRect( getBounds() ); + awt::Point aRet; + + aRet.X = aRect.X; + aRet.Y = aRect.Y; + + return aRet; +} + +awt::Point SAL_CALL SvxGraphCtrlAccessibleContext::getLocationOnScreen() +{ + const SolarMutexGuard aSolarGuard; + + if (nullptr == mpControl) + throw DisposedException(); + + awt::Point aScreenLoc(0, 0); + + auto xParent(getAccessibleParent()); + if (xParent) + { + css::uno::Reference<css::accessibility::XAccessibleContext> xParentContext(xParent->getAccessibleContext()); + css::uno::Reference<css::accessibility::XAccessibleComponent> xParentComponent(xParentContext, css::uno::UNO_QUERY); + OSL_ENSURE( xParentComponent.is(), "ValueSetAcc::getLocationOnScreen: no parent component!" ); + if ( xParentComponent.is() ) + { + awt::Point aParentScreenLoc( xParentComponent->getLocationOnScreen() ); + awt::Point aOwnRelativeLoc( getLocation() ); + aScreenLoc.X = aParentScreenLoc.X + aOwnRelativeLoc.X; + aScreenLoc.Y = aParentScreenLoc.Y + aOwnRelativeLoc.Y; + } + } + + return aScreenLoc; +} + +awt::Size SAL_CALL SvxGraphCtrlAccessibleContext::getSize() +{ + const SolarMutexGuard aSolarGuard; + + if (nullptr == mpControl) + throw DisposedException(); + + const awt::Rectangle aRect( getBounds() ); + awt::Size aRet; + + aRet.Width = aRect.Width; + aRet.Height = aRect.Height; + + return aRet; +} + +// XAccessibleContext +sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleChildCount() +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpPage ) + throw DisposedException(); + + return mpPage->GetObjCount(); +} + + +/** returns the SdrObject at index nIndex from the model of this graph */ +SdrObject* SvxGraphCtrlAccessibleContext::getSdrObject( sal_Int32 nIndex ) +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpPage ) + throw DisposedException(); + + if( (nIndex < 0) || ( o3tl::make_unsigned(nIndex) >= mpPage->GetObjCount() ) ) + throw lang::IndexOutOfBoundsException(); + + return mpPage->GetObj( nIndex ); +} + + +/** sends an AccessibleEventObject to all added XAccessibleEventListeners */ +void SvxGraphCtrlAccessibleContext::CommitChange ( + sal_Int16 nEventId, + const uno::Any& rNewValue, + const uno::Any& rOldValue) +{ + AccessibleEventObject aEvent ( + static_cast<uno::XWeak*>(this), + nEventId, + rNewValue, + rOldValue); + + if (mnClientId) + comphelper::AccessibleEventNotifier::addEvent( mnClientId, aEvent ); +} + +Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleChild( sal_Int32 nIndex ) +{ + ::SolarMutexGuard aGuard; + + return getAccessible( getSdrObject( nIndex ) ); +} + +Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleParent() +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpControl ) + throw DisposedException(); + + return mpControl->GetDrawingArea()->get_accessible_parent(); +} + +sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleIndexInParent() +{ + ::SolarMutexGuard aGuard; + // Use a simple but slow solution for now. Optimize later. + + // Iterate over all the parent's children and search for this object. + css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent()); + if (xParent.is()) + { + Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() ); + if( xParentContext.is() ) + { + sal_Int32 nChildCount = xParentContext->getAccessibleChildCount(); + for( sal_Int32 i = 0 ; i < nChildCount ; ++i ) + { + Reference< XAccessible > xChild( xParentContext->getAccessibleChild( i ) ); + if( xChild.is() ) + { + Reference< XAccessibleContext > xChildContext = xChild->getAccessibleContext(); + if( xChildContext == static_cast<XAccessibleContext*>(this) ) + return i; + } + } + } + } + + // Return -1 to indicate that this object's parent does not know about the + // object. + return -1; +} + + +sal_Int16 SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleRole() +{ + return AccessibleRole::PANEL; +} + + +OUString SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleDescription() +{ + ::SolarMutexGuard aGuard; + return msDescription; +} + + +OUString SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleName() +{ + ::SolarMutexGuard aGuard; + return msName; +} + + +/** Return empty reference to indicate that the relation set is not + supported. +*/ +Reference< XAccessibleRelationSet > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleRelationSet() +{ + return Reference< XAccessibleRelationSet >(); +} + + +Reference< XAccessibleStateSet > SAL_CALL SvxGraphCtrlAccessibleContext::getAccessibleStateSet() +{ + ::SolarMutexGuard aGuard; + + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if ( rBHelper.bDisposed || mbDisposed ) + { + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + } + else + { + pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE ); + if( mpControl->HasFocus() ) + pStateSetHelper->AddState( AccessibleStateType::FOCUSED ); + pStateSetHelper->AddState( AccessibleStateType::OPAQUE ); + pStateSetHelper->AddState( AccessibleStateType::SHOWING ); + pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); + } + + return pStateSetHelper; +} + + +lang::Locale SAL_CALL SvxGraphCtrlAccessibleContext::getLocale() +{ + ::SolarMutexGuard aGuard; + + css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent()); + if (xParent.is()) + { + Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() ); + if( xParentContext.is() ) + return xParentContext->getLocale(); + } + + // No parent. Therefore throw exception to indicate this cluelessness. + throw IllegalAccessibleComponentStateException(); +} + +// XAccessibleEventListener +void SAL_CALL SvxGraphCtrlAccessibleContext::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) +{ + if (xListener.is()) + { + ::SolarMutexGuard aGuard; + if (!mnClientId) + mnClientId = comphelper::AccessibleEventNotifier::registerClient( ); + comphelper::AccessibleEventNotifier::addEventListener( mnClientId, xListener ); + } +} + + +void SAL_CALL SvxGraphCtrlAccessibleContext::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) +{ + if (!xListener.is()) + return; + + ::SolarMutexGuard aGuard; + + sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, xListener ); + if ( !nListenerCount ) + { + // 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::revokeClient( mnClientId ); + mnClientId = 0; + } +} + +void SAL_CALL SvxGraphCtrlAccessibleContext::grabFocus() +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpControl ) + throw DisposedException(); + + mpControl->GrabFocus(); +} + +sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getForeground() +{ + svtools::ColorConfig aColorConfig; + Color nColor = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor; + return static_cast<sal_Int32>(nColor); +} + +sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getBackground() +{ + Color nColor = Application::GetSettings().GetStyleSettings().GetWindowColor(); + return static_cast<sal_Int32>(nColor); +} + +// XServiceInfo +OUString SAL_CALL SvxGraphCtrlAccessibleContext::getImplementationName() +{ + return "com.sun.star.comp.ui.SvxGraphCtrlAccessibleContext"; +} + +sal_Bool SAL_CALL SvxGraphCtrlAccessibleContext::supportsService( const OUString& sServiceName ) +{ + return cppu::supportsService(this, sServiceName); +} + +Sequence< OUString > SAL_CALL SvxGraphCtrlAccessibleContext::getSupportedServiceNames() +{ + return { "com.sun.star.accessibility.Accessible", + "com.sun.star.accessibility.AccessibleContext", + "com.sun.star.drawing.AccessibleGraphControl" }; +} + +// XTypeProvider +Sequence<sal_Int8> SAL_CALL SvxGraphCtrlAccessibleContext::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +// XServiceName +OUString SvxGraphCtrlAccessibleContext::getServiceName() +{ + return "com.sun.star.accessibility.AccessibleContext"; +} + +// XAccessibleSelection +void SAL_CALL SvxGraphCtrlAccessibleContext::selectAccessibleChild( sal_Int32 nIndex ) +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpView ) + throw DisposedException(); + + SdrObject* pObj = getSdrObject( nIndex ); + + if( pObj ) + mpView->MarkObj( pObj, mpView->GetSdrPageView()); +} + + +sal_Bool SAL_CALL SvxGraphCtrlAccessibleContext::isAccessibleChildSelected( sal_Int32 nIndex ) +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpView ) + throw DisposedException(); + + return mpView->IsObjMarked( getSdrObject( nIndex ) ); +} + + +void SAL_CALL SvxGraphCtrlAccessibleContext::clearAccessibleSelection() +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpView ) + throw DisposedException(); + + mpView->UnmarkAllObj(); +} + + +void SAL_CALL SvxGraphCtrlAccessibleContext::selectAllAccessibleChildren() +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpView ) + throw DisposedException(); + + mpView->MarkAllObj(); +} + + +sal_Int32 SAL_CALL SvxGraphCtrlAccessibleContext::getSelectedAccessibleChildCount() +{ + ::SolarMutexGuard aGuard; + + if( nullptr == mpView ) + throw DisposedException(); + + const SdrMarkList& rList = mpView->GetMarkedObjectList(); + return static_cast<sal_Int32>(rList.GetMarkCount()); +} + + +Reference< XAccessible > SAL_CALL SvxGraphCtrlAccessibleContext::getSelectedAccessibleChild( sal_Int32 nIndex ) +{ + ::SolarMutexGuard aGuard; + + checkChildIndexOnSelection( nIndex ); + + Reference< XAccessible > xAccessible; + + const SdrMarkList& rList = mpView->GetMarkedObjectList(); + SdrObject* pObj = rList.GetMark(static_cast<size_t>(nIndex))->GetMarkedSdrObj(); + if( pObj ) + xAccessible = getAccessible( pObj ); + + return xAccessible; +} + + +void SAL_CALL SvxGraphCtrlAccessibleContext::deselectAccessibleChild( sal_Int32 nIndex ) +{ + ::SolarMutexGuard aGuard; + + checkChildIndexOnSelection( nIndex ); + + if( !mpView ) + return; + + const SdrMarkList& rList = mpView->GetMarkedObjectList(); + + SdrObject* pObj = getSdrObject( nIndex ); + if( !pObj ) + return; + + SdrMarkList aRefList( rList ); + + SdrPageView* pPV = mpView->GetSdrPageView(); + mpView->UnmarkAllObj( pPV ); + + const size_t nCount = aRefList.GetMarkCount(); + for( size_t nMark = 0; nMark < nCount; ++nMark ) + { + if( aRefList.GetMark(nMark)->GetMarkedSdrObj() != pObj ) + mpView->MarkObj( aRefList.GetMark(nMark)->GetMarkedSdrObj(), pPV ); + } +} + +// internals +void SvxGraphCtrlAccessibleContext::checkChildIndexOnSelection( tools::Long nIndex ) +{ + if( nIndex < 0 || nIndex >= getSelectedAccessibleChildCount() ) + throw lang::IndexOutOfBoundsException(); +} + + +/** Replace the model, page, and view pointers by the ones provided + (explicitly and implicitly). +*/ +void SvxGraphCtrlAccessibleContext::setModelAndView ( + SdrModel* pModel, + SdrView* pView) +{ + ::SolarMutexGuard aGuard; + + mpModel = pModel; + if (mpModel != nullptr) + mpPage = mpModel->GetPage( 0 ); + mpView = pView; + + if (mpModel == nullptr || mpPage == nullptr || mpView == nullptr) + { + mbDisposed = true; + + // Set all the pointers to NULL just in case they are used as + // a disposed flag. + mpModel = nullptr; + mpPage = nullptr; + mpView = nullptr; + } + + maTreeInfo.SetSdrView (mpView); +} + + +void SAL_CALL SvxGraphCtrlAccessibleContext::disposing() +{ + ::SolarMutexGuard aGuard; + + if( mbDisposed ) + return; + + mbDisposed = true; + + mpControl = nullptr; // object dies with representation + mpView = nullptr; + mpPage = nullptr; + + { + for (const auto& rEntry : mxShapes) + { + rtl::Reference<XAccessible> pAcc(rEntry.second); + Reference< XComponent > xComp( pAcc.get(), UNO_QUERY ); + if( xComp.is() ) + xComp->dispose(); + } + + mxShapes.clear(); + } + + // Send a disposing to all listeners. + if ( mnClientId ) + { + comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this ); + mnClientId = 0; + } +} + +void SvxGraphCtrlAccessibleContext::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint ) +{ + if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint) + { + const SdrHint* pSdrHint = static_cast<const SdrHint*>( &rHint ); + switch( pSdrHint->GetKind() ) + { + case SdrHintKind::ObjectChange: + { + ShapesMapType::iterator iter = mxShapes.find( pSdrHint->GetObject() ); + + if( iter != mxShapes.end() ) + { + // if we already have one, return it + rtl::Reference<AccessibleShape> pShape((*iter).second); + + if( pShape.is() ) + pShape->CommitChange( AccessibleEventId::VISIBLE_DATA_CHANGED, uno::Any(), uno::Any() ); + } + } + break; + + case SdrHintKind::ObjectInserted: + CommitChange( AccessibleEventId::CHILD, Any( getAccessible( pSdrHint->GetObject() ) ) , uno::Any()); + break; + case SdrHintKind::ObjectRemoved: + CommitChange( AccessibleEventId::CHILD, uno::Any(), Any( getAccessible( pSdrHint->GetObject() ) ) ); + break; + case SdrHintKind::ModelCleared: + dispose(); + break; + default: + break; + } + } + else + { + // Has our SdDrawDocument just died? + if(rHint.GetId() == SfxHintId::Dying) + { + dispose(); + } + } +} + +// IAccessibleViewforwarder +tools::Rectangle SvxGraphCtrlAccessibleContext::GetVisibleArea() const +{ + tools::Rectangle aVisArea; + + if( mpView && mpView->PaintWindowCount()) + { + SdrPaintWindow* pPaintWindow = mpView->GetPaintWindow(0); + aVisArea = pPaintWindow->GetVisibleArea(); + } + + return aVisArea; +} + +Point SvxGraphCtrlAccessibleContext::LogicToPixel (const Point& rPoint) const +{ + if( mpControl ) + { + return mpControl->GetDrawingArea()->get_ref_device().LogicToPixel (rPoint) + mpControl->GetPositionInDialog(); + } + else + { + return rPoint; + } +} + +Size SvxGraphCtrlAccessibleContext::LogicToPixel (const Size& rSize) const +{ + if( mpControl ) + return mpControl->GetDrawingArea()->get_ref_device().LogicToPixel(rSize); + else + return rSize; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/ShapeTypeHandler.cxx b/svx/source/accessibility/ShapeTypeHandler.cxx new file mode 100644 index 000000000..1b169c761 --- /dev/null +++ b/svx/source/accessibility/ShapeTypeHandler.cxx @@ -0,0 +1,306 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include <svx/ShapeTypeHandler.hxx> +#include <svx/SvxShapeTypes.hxx> +#include <svx/AccessibleShapeInfo.hxx> +#include <vcl/svapp.hxx> +#include <svx/AccessibleShape.hxx> +#include <svx/dialmgr.hxx> + +#include <svx/svdoashp.hxx> + +#include <svx/strings.hrc> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::accessibility; + +namespace accessibility { + +// Pointer to the shape type handler singleton. +ShapeTypeHandler* ShapeTypeHandler::instance = nullptr; + + +// Create an empty reference to an accessible object. +static rtl::Reference<AccessibleShape> + CreateEmptyShapeReference ( + const AccessibleShapeInfo& /*rShapeInfo*/, + const AccessibleShapeTreeInfo& /*rShapeTreeInfo*/, + ShapeTypeId /*nId*/) +{ + return nullptr; +} + + +ShapeTypeHandler& ShapeTypeHandler::Instance() +{ + // Using double check pattern to make sure that exactly one instance of + // the shape type handler is instantiated. + if (instance == nullptr) + { + SolarMutexGuard aGuard; + if (instance == nullptr) + { + // Create the single instance of the shape type handler. + instance = new ShapeTypeHandler; + + // Register the basic SVX shape types. + RegisterDrawShapeTypes (); + } + } + + return *instance; +} + + +/** The given service name is first transformed into a slot id that + identifies the place of the type descriptor. From that descriptor the + shape type id is returned. +*/ +ShapeTypeId ShapeTypeHandler::GetTypeId (const OUString& aServiceName) const +{ + tServiceNameToSlotId::const_iterator I (maServiceNameToSlotId.find (aServiceName)); + if (I != maServiceNameToSlotId.end()) + { + return maShapeTypeDescriptorList[I->second].mnShapeTypeId; + } + else + return -1; +} + + +/** Extract the specified shape's service name and forward the request to + the appropriate method. +*/ +ShapeTypeId ShapeTypeHandler::GetTypeId (const uno::Reference<drawing::XShape>& rxShape) const +{ + if (rxShape.is()) + return GetTypeId (rxShape->getShapeType()); + else + return -1; +} + + +/** This factory method determines the type descriptor for the type of the + given shape, then calls the descriptor's create function, and finally + initializes the new object. +*/ +rtl::Reference<AccessibleShape> + ShapeTypeHandler::CreateAccessibleObject ( + const AccessibleShapeInfo& rShapeInfo, + const AccessibleShapeTreeInfo& rShapeTreeInfo) const +{ + ShapeTypeId nSlotId (GetSlotId (rShapeInfo.mxShape)); + rtl::Reference<AccessibleShape> pShape( + maShapeTypeDescriptorList[nSlotId].maCreateFunction ( + rShapeInfo, + rShapeTreeInfo, + maShapeTypeDescriptorList[nSlotId].mnShapeTypeId)); + return pShape; +} + + +/** Create the single instance of this class and initialize its list of + type descriptors with an entry of an unknown type. +*/ +ShapeTypeHandler::ShapeTypeHandler() + : maShapeTypeDescriptorList (1) +{ + // Make sure that at least the UNKNOWN entry is present. + // Resize the list, if necessary, so that the new type can be inserted. + maShapeTypeDescriptorList[0].mnShapeTypeId = UNKNOWN_SHAPE_TYPE; + maShapeTypeDescriptorList[0].msServiceName = "UNKNOWN_SHAPE_TYPE"; + maShapeTypeDescriptorList[0].maCreateFunction = CreateEmptyShapeReference; + maServiceNameToSlotId[maShapeTypeDescriptorList[0].msServiceName] = 0; +} + + +ShapeTypeHandler::~ShapeTypeHandler() +{ + // Because this class is a singleton and the only instance, whose + // destructor has just been called, is pointed to from instance, + // we reset the static variable instance, so that further calls to + // getInstance do not return an undefined object but create a new + // singleton. + instance = nullptr; +} + + +void ShapeTypeHandler::AddShapeTypeList (int nDescriptorCount, + ShapeTypeDescriptor const aDescriptorList[]) +{ + SolarMutexGuard aGuard; + + // Determine first id of new type descriptor(s). + int nFirstId = maShapeTypeDescriptorList.size(); + + // Resize the list, if necessary, so that the types can be inserted. + maShapeTypeDescriptorList.resize (nFirstId + nDescriptorCount); + + for (int i=0; i<nDescriptorCount; i++) + { + // Fill Type descriptor. + maShapeTypeDescriptorList[nFirstId+i].mnShapeTypeId = aDescriptorList[i].mnShapeTypeId; + maShapeTypeDescriptorList[nFirstId+i].msServiceName = aDescriptorList[i].msServiceName; + maShapeTypeDescriptorList[nFirstId+i].maCreateFunction = aDescriptorList[i].maCreateFunction; + + // Update inverse mapping from service name to the descriptor's position. + maServiceNameToSlotId[aDescriptorList[i].msServiceName] = nFirstId+i; + } +} + + +tools::Long ShapeTypeHandler::GetSlotId (const OUString& aServiceName) const +{ + tServiceNameToSlotId::const_iterator I (maServiceNameToSlotId.find (aServiceName)); + if (I != maServiceNameToSlotId.end()) + return I->second; + else + return 0; +} + + +// Extract the given shape's service name and forward request to appropriate +// method. +tools::Long ShapeTypeHandler::GetSlotId (const uno::Reference<drawing::XShape>& rxShape) const +{ + if (rxShape.is()) + return GetSlotId (rxShape->getShapeType()); + else + return 0; +} + +/// get the accessible base name for an object +OUString ShapeTypeHandler::CreateAccessibleBaseName (const uno::Reference<drawing::XShape>& rxShape) +{ + TranslateId pResourceId; + OUString sName; + + switch (ShapeTypeHandler::Instance().GetTypeId (rxShape)) + { + // case DRAWING_3D_POLYGON: was removed in original code in + // AccessibleShape::CreateAccessibleBaseName. See issue 11190 for details. + // Id can be removed from SvxShapeTypes.hxx as well. + case DRAWING_3D_CUBE: + pResourceId = STR_ObjNameSingulCube3d; + break; + case DRAWING_3D_EXTRUDE: + pResourceId = STR_ObjNameSingulExtrude3d; + break; + case DRAWING_3D_LATHE: + pResourceId = STR_ObjNameSingulLathe3d; + break; + case DRAWING_3D_SCENE: + pResourceId = STR_ObjNameSingulScene3d; + break; + case DRAWING_3D_SPHERE: + pResourceId = STR_ObjNameSingulSphere3d; + break; + case DRAWING_CAPTION: + pResourceId = STR_ObjNameSingulCAPTION; + break; + case DRAWING_CLOSED_BEZIER: + pResourceId = STR_ObjNameSingulPATHFILL; + break; + case DRAWING_CLOSED_FREEHAND: + pResourceId = STR_ObjNameSingulFREEFILL; + break; + case DRAWING_CONNECTOR: + pResourceId = STR_ObjNameSingulEDGE; + break; + case DRAWING_CONTROL: + pResourceId = STR_ObjNameSingulUno; + break; + case DRAWING_ELLIPSE: + pResourceId = STR_ObjNameSingulCIRCE; + break; + case DRAWING_GROUP: + pResourceId = STR_ObjNameSingulGRUP; + break; + case DRAWING_LINE: + pResourceId = STR_ObjNameSingulLINE; + break; + case DRAWING_MEASURE: + pResourceId = STR_ObjNameSingulMEASURE; + break; + case DRAWING_OPEN_BEZIER: + pResourceId = STR_ObjNameSingulPATHLINE; + break; + case DRAWING_OPEN_FREEHAND: + pResourceId = STR_ObjNameSingulFREELINE; + break; + case DRAWING_PAGE: + pResourceId = STR_ObjNameSingulPAGE; + break; + case DRAWING_POLY_LINE: + pResourceId = STR_ObjNameSingulPLIN; + break; + case DRAWING_POLY_LINE_PATH: + pResourceId = STR_ObjNameSingulPLIN; + break; + case DRAWING_POLY_POLYGON: + pResourceId = STR_ObjNameSingulPOLY; + break; + case DRAWING_POLY_POLYGON_PATH: + pResourceId = STR_ObjNameSingulPOLY; + break; + case DRAWING_RECTANGLE: + pResourceId = STR_ObjNameSingulRECT; + break; + case DRAWING_CUSTOM: + pResourceId = STR_ObjNameSingulCUSTOMSHAPE; + + if (SdrObject* pSdrObject = SdrObject::getSdrObjectFromXShape(rxShape)) + { + if (auto pCustomShape = dynamic_cast<SdrObjCustomShape*>(pSdrObject)) + { + if (pCustomShape->IsTextPath()) + pResourceId = STR_ObjNameSingulFONTWORK; + else + { + pResourceId = {}; + sName = pCustomShape->GetCustomShapeName(); + } + } + } + break; + case DRAWING_TEXT: + pResourceId = STR_ObjNameSingulTEXT; + break; + default: + pResourceId = {}; + sName = "UnknownAccessibleShape"; + if (rxShape.is()) + sName += ": " + rxShape->getShapeType(); + break; + } + + if (pResourceId) + { + SolarMutexGuard aGuard; + sName = SvxResId(pResourceId); + } + + return sName; +} + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/SvxShapeTypes.cxx b/svx/source/accessibility/SvxShapeTypes.cxx new file mode 100644 index 000000000..b02a153a4 --- /dev/null +++ b/svx/source/accessibility/SvxShapeTypes.cxx @@ -0,0 +1,165 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include <svx/SvxShapeTypes.hxx> +#include <svx/AccessibleShape.hxx> +#include <svx/AccessibleGraphicShape.hxx> +#include <svx/AccessibleOLEShape.hxx> +#include <svx/AccessibleControlShape.hxx> +#include <svx/ShapeTypeHandler.hxx> +#include <AccessibleTableShape.hxx> + +namespace accessibility { + +static rtl::Reference<AccessibleShape> CreateSvxAccessibleShape ( + const AccessibleShapeInfo& rShapeInfo, + const AccessibleShapeTreeInfo& rShapeTreeInfo, + ShapeTypeId nId) +{ + switch (nId) + { + case DRAWING_3D_CUBE: + case DRAWING_3D_EXTRUDE: + case DRAWING_3D_LATHE: + case DRAWING_3D_SCENE: + case DRAWING_3D_SPHERE: + case DRAWING_CAPTION: + case DRAWING_CLOSED_BEZIER: + case DRAWING_CLOSED_FREEHAND: + case DRAWING_CONNECTOR: + case DRAWING_ELLIPSE: + case DRAWING_GROUP: + case DRAWING_LINE: + case DRAWING_MEASURE: + case DRAWING_OPEN_BEZIER: + case DRAWING_OPEN_FREEHAND: + case DRAWING_PAGE: + case DRAWING_POLY_POLYGON: + case DRAWING_POLY_LINE: + case DRAWING_POLY_POLYGON_PATH: + case DRAWING_POLY_LINE_PATH: + case DRAWING_RECTANGLE: + case DRAWING_TEXT: + // Default accessibility shape for + // css::drawing::CustomShape (#i37790#) + case DRAWING_CUSTOM: + // Default accessibility shape for + // css::drawing::MediaShape (#i85429#) + case DRAWING_MEDIA: + return new AccessibleShape (rShapeInfo, rShapeTreeInfo); + + case DRAWING_CONTROL: + return new AccessibleControlShape (rShapeInfo, rShapeTreeInfo); + + case DRAWING_GRAPHIC_OBJECT: + return new AccessibleGraphicShape (rShapeInfo, rShapeTreeInfo); + + case DRAWING_APPLET: + case DRAWING_FRAME: + case DRAWING_OLE: + case DRAWING_PLUGIN: + return new AccessibleOLEShape (rShapeInfo, rShapeTreeInfo); + + case DRAWING_TABLE: + return new AccessibleTableShape( rShapeInfo, rShapeTreeInfo ); + + default: + return nullptr; + } +} + +void RegisterDrawShapeTypes() +{ + /** List of shape type descriptors corresponding to the + <type>SvxShapeTypes</type> enum. + */ + static ShapeTypeDescriptor const aSvxShapeTypeList[] = { + ShapeTypeDescriptor ( DRAWING_TEXT, "com.sun.star.drawing.TextShape", + CreateSvxAccessibleShape), + ShapeTypeDescriptor (DRAWING_RECTANGLE, "com.sun.star.drawing.RectangleShape", + CreateSvxAccessibleShape), + ShapeTypeDescriptor ( DRAWING_ELLIPSE, "com.sun.star.drawing.EllipseShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_CONTROL, "com.sun.star.drawing.ControlShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_CONNECTOR, "com.sun.star.drawing.ConnectorShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_MEASURE, "com.sun.star.drawing.MeasureShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_LINE, "com.sun.star.drawing.LineShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_POLY_POLYGON, "com.sun.star.drawing.PolyPolygonShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_POLY_LINE, "com.sun.star.drawing.PolyLineShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_OPEN_BEZIER, "com.sun.star.drawing.OpenBezierShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_CLOSED_BEZIER, "com.sun.star.drawing.ClosedBezierShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_OPEN_FREEHAND, "com.sun.star.drawing.OpenFreeHandShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_CLOSED_FREEHAND, "com.sun.star.drawing.ClosedFreeHandShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_POLY_POLYGON_PATH, "com.sun.star.drawing.PolyPolygonPathShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_POLY_LINE_PATH, "com.sun.star.drawing.PolyLinePathShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_GRAPHIC_OBJECT, "com.sun.star.drawing.GraphicObjectShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_GROUP, "com.sun.star.drawing.GroupShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_OLE, "com.sun.star.drawing.OLE2Shape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_PAGE, "com.sun.star.drawing.PageShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_CAPTION, "com.sun.star.drawing.CaptionShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_FRAME, "com.sun.star.drawing.FrameShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_PLUGIN, "com.sun.star.drawing.PluginShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_APPLET, "com.sun.star.drawing.AppletShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_3D_SCENE, "com.sun.star.drawing.Shape3DSceneObject", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_3D_CUBE, "com.sun.star.drawing.Shape3DCubeObject", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_3D_SPHERE, "com.sun.star.drawing.Shape3DSphereObject", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_3D_LATHE, "com.sun.star.drawing.Shape3DLatheObject", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_3D_EXTRUDE, "com.sun.star.drawing.Shape3DExtrudeObject", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_CUSTOM, "com.sun.star.drawing.CustomShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_TABLE, "com.sun.star.drawing.TableShape", + CreateSvxAccessibleShape ), + ShapeTypeDescriptor ( DRAWING_MEDIA, "com.sun.star.drawing.MediaShape", + CreateSvxAccessibleShape ), + + }; + + // Crash while inserting callout with activated accessibility (#i37790#) + ShapeTypeHandler::Instance().AddShapeTypeList ( DRAWING_END, aSvxShapeTypeList); +} + +} // end of namespace accessibility + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/charmapacc.cxx b/svx/source/accessibility/charmapacc.cxx new file mode 100644 index 000000000..0de91ccee --- /dev/null +++ b/svx/source/accessibility/charmapacc.cxx @@ -0,0 +1,584 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <unotools/accessiblestatesethelper.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <stdio.h> +#include <svx/charmap.hxx> +#include <charmapacc.hxx> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <o3tl/temporary.hxx> +#include <osl/interlck.h> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <comphelper/types.hxx> + +namespace svx +{ + using namespace comphelper; + using namespace ::com::sun::star; + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::accessibility; + +SvxShowCharSetItem::SvxShowCharSetItem( SvxShowCharSet& rParent,SvxShowCharSetAcc* _pParent,sal_uInt16 _nPos ) : + mrParent( rParent ) + ,mnId( _nPos ) + ,m_pParent(_pParent) +{ +} + +SvxShowCharSetItem::~SvxShowCharSetItem() +{ + if ( m_xItem.is() ) + { + m_xItem->ParentDestroyed(); + m_xItem.clear(); + } +} + +uno::Reference< css::accessibility::XAccessible > SvxShowCharSetItem::GetAccessible() +{ + if( !m_xItem.is() ) + { + m_xItem = new SvxShowCharSetItemAcc( this ); + } + + return m_xItem; +} + +SvxShowCharSetAcc::SvxShowCharSetAcc(SvxShowCharSet* pParent) + : m_pParent(pParent) +{ + osl_atomic_increment(&m_refCount); + { + lateInit(this); + } + osl_atomic_decrement(&m_refCount); +} + +SvxShowCharSetAcc::~SvxShowCharSetAcc() +{ + ensureDisposed(); +} + +void SAL_CALL SvxShowCharSetAcc::disposing() +{ + OAccessibleSelectionHelper::disposing(); + for (auto& rChild : m_aChildren) + ::comphelper::disposeComponent(rChild); + + m_aChildren.clear(); + m_pParent = nullptr; +} + + +IMPLEMENT_FORWARD_XINTERFACE2( SvxShowCharSetAcc, OAccessibleSelectionHelper, OAccessibleHelper_Base ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvxShowCharSetAcc, OAccessibleSelectionHelper, OAccessibleHelper_Base ) + +bool SvxShowCharSetAcc::implIsSelected( sal_Int32 nAccessibleChildIndex ) +{ + return m_pParent && m_pParent->IsSelected( + sal::static_int_cast<sal_uInt16>(nAccessibleChildIndex)); +} + + // select the specified child => watch for special ChildIndexes (ACCESSIBLE_SELECTION_CHILD_xxx) +void SvxShowCharSetAcc::implSelect(sal_Int32 nAccessibleChildIndex, bool bSelect) +{ + if ( m_pParent ) + { + if ( bSelect ) + m_pParent->SelectIndex(nAccessibleChildIndex, true); + else + m_pParent->DeSelect(); + } +} + +css::awt::Rectangle SvxShowCharSetAcc::implGetBounds() +{ + awt::Rectangle aRet; + + if (m_pParent) + { + const Point aOutPos;//( m_pParent->GetPosPixel() ); + Size aOutSize( m_pParent->GetOutputSizePixel()); + + aRet.X = aOutPos.X(); + aRet.Y = aOutPos.Y(); + aRet.Width = aOutSize.Width(); + aRet.Height = aOutSize.Height(); + } + + return aRet; +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleChildCount() +{ + OExternalLockGuard aGuard( this ); + + return m_pParent->getMaxCharCount(); +} + +uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleChild( sal_Int32 i ) +{ + OExternalLockGuard aGuard( this ); + + uno::Reference< css::accessibility::XAccessible > xRet; + SvxShowCharSetItem* pItem = m_pParent->ImplGetItem( static_cast< sal_uInt16 >( i ) ); + + if( !pItem ) + throw lang::IndexOutOfBoundsException(); + + pItem->m_pParent = this; + xRet = pItem->GetAccessible(); + m_aChildren.push_back(xRet); + + return xRet; +} + +uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleParent() +{ + OExternalLockGuard aGuard( this ); + + if (m_pParent) + return m_pParent->getAccessibleParent(); + return uno::Reference<css::accessibility::XAccessible>(); +} + +sal_Int16 SAL_CALL SvxShowCharSetAcc::getAccessibleRole() +{ + return css::accessibility::AccessibleRole::TABLE; +} + +OUString SAL_CALL SvxShowCharSetAcc::getAccessibleDescription() +{ + OExternalLockGuard aGuard( this ); + return SvxResId( RID_SVXSTR_CHARACTER_SELECTION ); +} + + +OUString SAL_CALL SvxShowCharSetAcc::getAccessibleName() +{ + OExternalLockGuard aGuard( this ); + + return SvxResId( RID_SVXSTR_CHAR_SEL_DESC ); +} + + +uno::Reference< css::accessibility::XAccessibleRelationSet > SAL_CALL SvxShowCharSetAcc::getAccessibleRelationSet() +{ + return uno::Reference< css::accessibility::XAccessibleRelationSet >(); +} + + +uno::Reference< css::accessibility::XAccessibleStateSet > SAL_CALL SvxShowCharSetAcc::getAccessibleStateSet() +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<::utl::AccessibleStateSetHelper> pStateSet = new ::utl::AccessibleStateSetHelper; + + if (m_pParent) + { + // SELECTABLE + pStateSet->AddState( AccessibleStateType::FOCUSABLE ); + if (m_pParent->HasFocus()) + { + pStateSet->AddState( AccessibleStateType::FOCUSED ); + pStateSet->AddState( AccessibleStateType::ACTIVE ); + } + if (m_pParent->IsEnabled()) + { + pStateSet->AddState( AccessibleStateType::ENABLED ); + pStateSet->AddState( AccessibleStateType::SENSITIVE ); + } + if (m_pParent->IsVisible()) + pStateSet->AddState( AccessibleStateType::VISIBLE ); + + pStateSet->AddState( AccessibleStateType::MANAGES_DESCENDANTS ); + } + + return pStateSet; +} + + +uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleAtPoint( const awt::Point& aPoint ) +{ + OExternalLockGuard aGuard( this ); + + uno::Reference< css::accessibility::XAccessible > xRet; + const sal_uInt16 nItemId = sal::static_int_cast<sal_uInt16>( + m_pParent->PixelToMapIndex( Point( aPoint.X, aPoint.Y ) )); + + if( sal_uInt16(-1) != nItemId ) + { + SvxShowCharSetItem* pItem = m_pParent->ImplGetItem( nItemId ); + xRet = pItem->GetAccessible(); + } + return xRet; +} + +void SAL_CALL SvxShowCharSetAcc::grabFocus() +{ + OExternalLockGuard aGuard( this ); + + m_pParent->GrabFocus(); +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleRowCount( ) +{ + return ((getAccessibleChildCount()-1) / COLUMN_COUNT) + 1; +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleColumnCount( ) +{ + return COLUMN_COUNT; +} + +OUString SAL_CALL SvxShowCharSetAcc::getAccessibleRowDescription( sal_Int32 /*nRow*/ ) +{ + return OUString(); +} + +OUString SAL_CALL SvxShowCharSetAcc::getAccessibleColumnDescription( sal_Int32 /*nColumn*/ ) +{ + return OUString(); +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleRowExtentAt( sal_Int32 /*nRow*/, sal_Int32 /*nColumn*/ ) +{ + return 1; +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleColumnExtentAt( sal_Int32 /*nRow*/, sal_Int32 /*nColumn*/ ) +{ + return 1; +} + +Reference< XAccessibleTable > SAL_CALL SvxShowCharSetAcc::getAccessibleRowHeaders( ) +{ + return Reference< XAccessibleTable >(); +} + +Reference< XAccessibleTable > SAL_CALL SvxShowCharSetAcc::getAccessibleColumnHeaders( ) +{ + return Reference< XAccessibleTable >(); +} + +Sequence< sal_Int32 > SAL_CALL SvxShowCharSetAcc::getSelectedAccessibleRows( ) +{ + OExternalLockGuard aGuard( this ); + + return { SvxShowCharSet::GetRowPos(m_pParent->GetSelectIndexId()) }; +} + +Sequence< sal_Int32 > SAL_CALL SvxShowCharSetAcc::getSelectedAccessibleColumns( ) +{ + OExternalLockGuard aGuard( this ); + + return { SvxShowCharSet::GetColumnPos(m_pParent->GetSelectIndexId()) }; +} + +sal_Bool SAL_CALL SvxShowCharSetAcc::isAccessibleRowSelected( sal_Int32 nRow ) +{ + OExternalLockGuard aGuard( this ); + + return SvxShowCharSet::GetRowPos(m_pParent->GetSelectIndexId()) == nRow; +} + +sal_Bool SAL_CALL SvxShowCharSetAcc::isAccessibleColumnSelected( sal_Int32 nColumn ) +{ + OExternalLockGuard aGuard( this ); + ensureAlive(); + return SvxShowCharSet::GetColumnPos(m_pParent->GetSelectIndexId()) == nColumn; +} + +Reference< XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) +{ + OExternalLockGuard aGuard( this ); + + svx::SvxShowCharSetItem* pItem = m_pParent->ImplGetItem( + sal::static_int_cast<sal_uInt16>(getAccessibleIndex(nRow,nColumn) )); + if ( !pItem ) + throw IndexOutOfBoundsException(); + return pItem->GetAccessible(); +} + +Reference< XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleCaption( ) +{ + return Reference< XAccessible >(); +} + +Reference< XAccessible > SAL_CALL SvxShowCharSetAcc::getAccessibleSummary( ) +{ + return Reference< XAccessible >(); +} + +sal_Bool SAL_CALL SvxShowCharSetAcc::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) +{ + OExternalLockGuard aGuard( this ); + + return m_pParent->GetSelectIndexId() == getAccessibleIndex(nRow,nColumn); +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) +{ + return (nRow*COLUMN_COUNT) + nColumn; +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleRow( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + return SvxShowCharSet::GetRowPos(sal::static_int_cast<sal_uInt16>(nChildIndex)); +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getAccessibleColumn( sal_Int32 nChildIndex ) +{ + OExternalLockGuard aGuard( this ); + + return SvxShowCharSet::GetColumnPos(sal::static_int_cast<sal_uInt16>(nChildIndex)); +} + + +SvxShowCharSetItemAcc::SvxShowCharSetItemAcc( SvxShowCharSetItem* pParent ) : mpParent( pParent ) +{ + OSL_ENSURE(pParent,"NO parent supplied!"); + osl_atomic_increment(&m_refCount); + { // #b6211265 # + lateInit(this); + } + osl_atomic_decrement(&m_refCount); +} + + +SvxShowCharSetItemAcc::~SvxShowCharSetItemAcc() +{ + ensureDisposed(); +} + +IMPLEMENT_FORWARD_XINTERFACE2( SvxShowCharSetItemAcc, OAccessibleComponentHelper, OAccessibleHelper_Base_3 ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvxShowCharSetItemAcc, OAccessibleComponentHelper, OAccessibleHelper_Base_3 ) + +void SvxShowCharSetItemAcc::ParentDestroyed() +{ + const ::osl::MutexGuard aGuard( GetMutex() ); + mpParent = nullptr; +} + +sal_Int32 SAL_CALL SvxShowCharSetItemAcc::getAccessibleChildCount() +{ + return 0; +} + + +uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetItemAcc::getAccessibleChild( sal_Int32 /*i*/ ) +{ + throw lang::IndexOutOfBoundsException(); +} + + +uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetItemAcc::getAccessibleParent() +{ + OExternalLockGuard aGuard( this ); + + return mpParent->m_pParent; +} + + +sal_Int16 SAL_CALL SvxShowCharSetItemAcc::getAccessibleRole() +{ + return css::accessibility::AccessibleRole::TABLE_CELL; +} + + +OUString SAL_CALL SvxShowCharSetItemAcc::getAccessibleDescription() +{ + OExternalLockGuard aGuard( this ); + + OUString sDescription; + + const OUString aCharStr( mpParent->maText); + const sal_UCS4 c = aCharStr.iterateCodePoints( &o3tl::temporary(sal_Int32(0)) ); + const int tmp_len = (c < 0x10000) ? 4 : 6; + char buf[16] = "0x0000"; + sal_UCS4 c_Shifted = c; + for( int i = 0; i < tmp_len; ++i ) + { + char h = static_cast<char>(c_Shifted & 0x0F); + buf[tmp_len+1-i] = (h > 9) ? (h - 10 + 'A') : (h + '0'); + c_Shifted >>= 4; + } + if( c < 256 ) + snprintf( buf+6, 10, " (%" SAL_PRIuUINT32 ")", c ); + + sDescription = SvxResId( RID_SVXSTR_CHARACTER_CODE ) + + " " + + OUString(buf, strlen(buf), RTL_TEXTENCODING_ASCII_US); + + return sDescription; +} + + +OUString SAL_CALL SvxShowCharSetItemAcc::getAccessibleName() +{ + OExternalLockGuard aGuard( this ); + + OUString aRet; + + if( mpParent ) + { + aRet = mpParent->maText; + + if (aRet.isEmpty()) + aRet = getAccessibleDescription(); + } + + return aRet; +} + + +uno::Reference< css::accessibility::XAccessibleRelationSet > SAL_CALL SvxShowCharSetItemAcc::getAccessibleRelationSet() +{ + return uno::Reference< css::accessibility::XAccessibleRelationSet >(); +} + + +uno::Reference< css::accessibility::XAccessibleStateSet > SAL_CALL SvxShowCharSetItemAcc::getAccessibleStateSet() +{ + OExternalLockGuard aGuard( this ); + + rtl::Reference<::utl::AccessibleStateSetHelper> pStateSet = new ::utl::AccessibleStateSetHelper; + + if( mpParent ) + { + if (mpParent->mrParent.IsEnabled()) + { + pStateSet->AddState( css::accessibility::AccessibleStateType::ENABLED ); + // SELECTABLE + pStateSet->AddState( css::accessibility::AccessibleStateType::SELECTABLE ); + pStateSet->AddState( css::accessibility::AccessibleStateType::FOCUSABLE ); + } + + // SELECTED + if( mpParent->mrParent.GetSelectIndexId() == mpParent->mnId ) + { + pStateSet->AddState( css::accessibility::AccessibleStateType::SELECTED ); + pStateSet->AddState( css::accessibility::AccessibleStateType::FOCUSED ); + } + if ( mpParent->mnId >= mpParent->mrParent.FirstInView() && mpParent->mnId <= mpParent->mrParent.LastInView() ) + { + pStateSet->AddState( AccessibleStateType::VISIBLE ); + pStateSet->AddState( AccessibleStateType::SHOWING ); + } + pStateSet->AddState( AccessibleStateType::TRANSIENT ); + } + + return pStateSet; +} + + +sal_Int32 SvxShowCharSetItemAcc::getAccessibleActionCount() +{ + return 1; +} + + +sal_Bool SvxShowCharSetItemAcc::doAccessibleAction ( sal_Int32 nIndex ) +{ + OExternalLockGuard aGuard( this ); + + if( nIndex == 0 ) + { + mpParent->mrParent.OutputIndex( mpParent->mnId ); + return true; + } + throw IndexOutOfBoundsException(); +} + + +OUString SvxShowCharSetItemAcc::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + if( nIndex == 0 ) + return "press"; + throw IndexOutOfBoundsException(); +} + + +Reference< css::accessibility::XAccessibleKeyBinding > SvxShowCharSetItemAcc::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + if( nIndex == 0 ) + return Reference< css::accessibility::XAccessibleKeyBinding >(); + throw IndexOutOfBoundsException(); +} + + +void SAL_CALL SvxShowCharSetItemAcc::grabFocus() +{ + // nothing to do +} + +awt::Rectangle SvxShowCharSetItemAcc::implGetBounds( ) +{ + awt::Rectangle aRet; + + if( mpParent ) + { + tools::Rectangle aRect( mpParent->maRect ); + tools::Rectangle aParentRect(Point(), mpParent->mrParent.GetOutputSizePixel()); + + aRect.Intersection( aParentRect ); + + aRet.X = aRect.Left(); + aRet.Y = aRect.Top(); + aRet.Width = aRect.GetWidth(); + aRet.Height = aRect.GetHeight(); + } + + return aRet; +} + +uno::Reference< css::accessibility::XAccessible > SAL_CALL SvxShowCharSetItemAcc::getAccessibleAtPoint( const awt::Point& /*aPoint*/ ) +{ + return uno::Reference< css::accessibility::XAccessible >(); +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getForeground( ) +{ + OExternalLockGuard aGuard( this ); + + //see SvxShowCharSet::InitSettings + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + return static_cast<sal_Int32>(rStyleSettings.GetDialogTextColor()); +} + +sal_Int32 SAL_CALL SvxShowCharSetAcc::getBackground( ) +{ + OExternalLockGuard aGuard( this ); + + //see SvxShowCharSet::InitSettings + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + return static_cast<sal_Int32>(rStyleSettings.GetWindowColor()); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/lookupcolorname.cxx b/svx/source/accessibility/lookupcolorname.cxx new file mode 100644 index 000000000..373dae469 --- /dev/null +++ b/svx/source/accessibility/lookupcolorname.cxx @@ -0,0 +1,121 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <sal/config.h> + +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/drawing/ColorTable.hpp> +#include <com/sun/star/uno/Any.hxx> +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/uno/RuntimeException.hpp> +#include <com/sun/star/uno/Sequence.hxx> +#include <comphelper/processfactory.hxx> +#include <rtl/ustring.hxx> +#include <vcl/svapp.hxx> + +#include "lookupcolorname.hxx" +#include <unordered_map> + +namespace +{ +class ColorNameMap +{ +public: + ColorNameMap(); + ColorNameMap(const ColorNameMap&) = delete; + ColorNameMap& operator=(const ColorNameMap&) = delete; + + OUString lookUp(tools::Long color) const; + +private: + typedef std::unordered_map<tools::Long, OUString> Map; + + Map map_; +}; + +ColorNameMap::ColorNameMap() +{ + css::uno::Sequence<OUString> aNames; + css::uno::Reference<css::container::XNameAccess> xNA; + + try + { + // Create color table in which to look up the given color. + css::uno::Reference<css::container::XNameContainer> xColorTable + = css::drawing::ColorTable::create(comphelper::getProcessComponentContext()); + + // Get list of color names in order to iterate over the color table. + + // Lock the solar mutex here as workaround for missing lock in + // called function. + SolarMutexGuard aGuard; + xNA = xColorTable; + aNames = xColorTable->getElementNames(); + } + catch (css::uno::RuntimeException const&) + { + // When an exception occurred then we have an empty name sequence + // and the loop below is not entered. + } + + // Fill the map to convert from numerical color values to names. + if (!xNA.is()) + return; + + for (const auto& rName : std::as_const(aNames)) + { + // Get the numerical value for the i-th color name. + try + { + css::uno::Any aColor = xNA->getByName(rName); + tools::Long nColor = 0; + aColor >>= nColor; + map_[nColor] = rName; + } + catch (css::uno::RuntimeException const&) + { + // Ignore the exception: the color who lead to the exception + // is not included into the map. + } + } +} + +OUString ColorNameMap::lookUp(tools::Long color) const +{ + Map::const_iterator i(map_.find(color)); + if (i != map_.end()) + { + return i->second; + } + // Did not find the given color; return its RGB tuple representation: + return "#" + OUString::number(color, 16); +} +} + +namespace accessibility +{ +OUString lookUpColorName(tools::Long color) +{ + static ColorNameMap theColorNameMap; + return theColorNameMap.lookUp(color); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/lookupcolorname.hxx b/svx/source/accessibility/lookupcolorname.hxx new file mode 100644 index 000000000..0d752c0fa --- /dev/null +++ b/svx/source/accessibility/lookupcolorname.hxx @@ -0,0 +1,57 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_ACCESSIBILITY_LOOKUPCOLORNAME_HXX +#define INCLUDED_SVX_SOURCE_ACCESSIBILITY_LOOKUPCOLORNAME_HXX + +#include <sal/config.h> + +#include <rtl/ustring.hxx> +#include <tools/long.hxx> + +namespace accessibility +{ +/** This is a color name lookup targeted to be used by the accessibility + <type>DescriptionGenerator</type> class. It encapsulates a + <type>com.sun.star.drawing.ColorTable</type> and provides an inverse look + up of color names for given numerical color descriptions (the RGB values + encoded as an integer). + + <p>The implementation uses as singleton so that the + <type>com.sun.star.drawing.ColorTable</type> object needs to be created + only once. That singleton instance for now lives until the application + terminates. However, the color table from which it takes its values may + change during this time. Reacting to these changes remains a task for the + future.</p> + + @param nColor + This integer is the sum of the 8 Bit red value shifted left 16 Bits, the + green value shifted left 8 Bits, and the unshifted blue value. + + @return + The returned string is either the color name of the specified color or, + when no name exists, a string of the form "#RRGGBB" with two hexadecimal + digits for each color component. +*/ +OUString lookUpColorName(tools::Long color); +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx b/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx new file mode 100644 index 000000000..4873b3cfe --- /dev/null +++ b/svx/source/accessibility/svxpixelctlaccessiblecontext.cxx @@ -0,0 +1,468 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <toolkit/helper/convert.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <osl/mutex.hxx> +#include <tools/debug.hxx> +#include <tools/gen.hxx> + +#include <svx/dlgctrl.hxx> + +#include <svxpixelctlaccessiblecontext.hxx> + +using namespace ::cppu; +using namespace ::osl; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; + +SvxPixelCtlAccessible::SvxPixelCtlAccessible(SvxPixelCtl* pControl) + : mpPixelCtl(pControl) +{ +} + +SvxPixelCtlAccessible::~SvxPixelCtlAccessible() +{ + ensureDisposed(); +} + +IMPLEMENT_FORWARD_XINTERFACE2( SvxPixelCtlAccessible, OAccessibleSelectionHelper, OAccessibleHelper_Base ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvxPixelCtlAccessible, OAccessibleSelectionHelper, OAccessibleHelper_Base ) + +uno::Reference< XAccessibleContext > SvxPixelCtlAccessible::getAccessibleContext( ) +{ + return this; +} + +sal_Int32 SvxPixelCtlAccessible::getAccessibleChildCount( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return SvxPixelCtl::GetSquares(); +} +uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleChild( sal_Int32 i ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if ( i < 0 || i >= getAccessibleChildCount()) + throw lang::IndexOutOfBoundsException(); + Reference< XAccessible > xChild; + if (mpPixelCtl) + xChild = CreateChild(i, mpPixelCtl->IndexToPoint(i)); + return xChild; +} + +uno::Reference< XAccessible > SvxPixelCtlAccessible::getAccessibleParent( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if (mpPixelCtl) + return mpPixelCtl->getAccessibleParent(); + return uno::Reference<css::accessibility::XAccessible>(); +} + +sal_Int16 SvxPixelCtlAccessible::getAccessibleRole( ) +{ + return AccessibleRole::LIST; +} + +OUString SvxPixelCtlAccessible::getAccessibleDescription( ) +{ + + ::osl::MutexGuard aGuard( m_aMutex ); + return mpPixelCtl ? mpPixelCtl->GetAccessibleDescription() : ""; +} + +OUString SvxPixelCtlAccessible::getAccessibleName( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return mpPixelCtl ? mpPixelCtl->GetAccessibleName() : ""; +} + +Reference< XAccessibleRelationSet > SAL_CALL SvxPixelCtlAccessible::getAccessibleRelationSet() +{ + if (mpPixelCtl) + return mpPixelCtl->get_accessible_relation_set(); + return uno::Reference<css::accessibility::XAccessibleRelationSet>(); +} + +uno::Reference< XAccessibleStateSet > SvxPixelCtlAccessible::getAccessibleStateSet( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if (mpPixelCtl) + { + const sal_Int16 aStandardStates[] = + { + AccessibleStateType::FOCUSABLE, + AccessibleStateType::SELECTABLE, + AccessibleStateType::SHOWING, + AccessibleStateType::VISIBLE, + AccessibleStateType::OPAQUE, + 0 + }; + + sal_Int16 nState = 0; + while (aStandardStates[nState]) + { + pStateSetHelper->AddState(aStandardStates[nState++]); + } + if (mpPixelCtl->IsEnabled()) + pStateSetHelper->AddState(AccessibleStateType::ENABLED); + if (mpPixelCtl->HasFocus()) + pStateSetHelper->AddState(AccessibleStateType::FOCUSED); + pStateSetHelper->AddState(AccessibleStateType::MANAGES_DESCENDANTS); + } + + return pStateSetHelper; +} + +uno::Reference<XAccessible > SAL_CALL SvxPixelCtlAccessible::getAccessibleAtPoint ( + const awt::Point& rPoint) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + Reference< XAccessible > xRet; + + if (mpPixelCtl) + { + tools::Long nIndex = mpPixelCtl->PointToIndex(Point(rPoint.X, rPoint.Y)); + xRet = CreateChild(nIndex, mpPixelCtl->IndexToPoint(nIndex)); + } + + return xRet; +} + +awt::Rectangle SvxPixelCtlAccessible::implGetBounds() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + awt::Rectangle aRet; + + if (mpPixelCtl) + { + const Point aOutPos; + Size aOutSize(mpPixelCtl->GetOutputSizePixel()); + + aRet.X = aOutPos.X(); + aRet.Y = aOutPos.Y(); + aRet.Width = aOutSize.Width(); + aRet.Height = aOutSize.Height(); + } + + return aRet; +} + +void SvxPixelCtlAccessible::grabFocus( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if (mpPixelCtl) + mpPixelCtl->GrabFocus(); +} + +sal_Int32 SvxPixelCtlAccessible::getForeground( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + //see SvxPixelCtl::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetLabelTextColor()); +} + +sal_Int32 SvxPixelCtlAccessible::getBackground( ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + //see SvxPixelCtl::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetDialogColor()); +} + +void SvxPixelCtlAccessible::implSelect(sal_Int32 nChildIndex, bool bSelect) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount()) + throw lang::IndexOutOfBoundsException(); + + if (!mpPixelCtl) + return; + + tools::Long nIndex = mpPixelCtl->ShowPosition(mpPixelCtl->IndexToPoint(nChildIndex)); + NotifyChild(nIndex, bSelect, false); +} + +bool SvxPixelCtlAccessible::implIsSelected(sal_Int32 nChildIndex) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + if (!mpPixelCtl) + return false; + + return mpPixelCtl->GetFocusPosIndex() == nChildIndex; +} + +void SAL_CALL SvxPixelCtlAccessible::disposing() +{ + ::osl::MutexGuard aGuard(m_aMutex); + OAccessibleSelectionHelper::disposing(); + m_xCurChild.clear(); + mpPixelCtl = nullptr; +} + +void SvxPixelCtlAccessible::NotifyChild(tools::Long nIndex,bool bSelect ,bool bCheck) +{ + DBG_ASSERT( !(!bSelect && !bCheck),"" );//non is false + + SvxPixelCtlAccessibleChild *pChild= nullptr; + + if (m_xCurChild.is()) + { + pChild= static_cast<SvxPixelCtlAccessibleChild*>(m_xCurChild.get()); + DBG_ASSERT(pChild,"Child Must be Valid"); + if (pChild->getAccessibleIndexInParent() == nIndex ) + { + if (bSelect) + { + pChild->SelectChild(true); + } + if (bCheck) + { + pChild->ChangePixelColorOrBG(mpPixelCtl->GetBitmapPixel(sal_uInt16(nIndex)) != 0); + pChild->CheckChild(); + } + return ; + } + } + uno::Reference <XAccessible> xNewChild =CreateChild(nIndex, mpPixelCtl->IndexToPoint(nIndex)); + SvxPixelCtlAccessibleChild *pNewChild= static_cast<SvxPixelCtlAccessibleChild*>(xNewChild.get()); + DBG_ASSERT(pNewChild,"Child Must be Valid"); + + Any aNewValue,aOldValue; + aNewValue<<= xNewChild; + NotifyAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldValue, aNewValue); + + if (bSelect) + { + if (pChild) + { + pChild->SelectChild(false); + } + pNewChild->SelectChild(true); + } + if (bCheck) + { + pNewChild->CheckChild(); + } + m_xCurChild= xNewChild; +} + +uno::Reference<XAccessible> SvxPixelCtlAccessible::CreateChild (tools::Long nIndex,Point mPoint) +{ + bool bPixelColorOrBG = mpPixelCtl->GetBitmapPixel(sal_uInt16(nIndex)) != 0; + Size size(mpPixelCtl->GetWidth() / SvxPixelCtl::GetLineCount(), mpPixelCtl->GetHeight() / SvxPixelCtl::GetLineCount()); + uno::Reference<XAccessible> xChild = new SvxPixelCtlAccessibleChild(*mpPixelCtl, + bPixelColorOrBG, + tools::Rectangle(mPoint,size), + this, + nIndex); + + return xChild; +} + +void SvxPixelCtlAccessibleChild::CheckChild() +{ + Any aChecked; + aChecked <<= AccessibleStateType::CHECKED; + + if (m_bPixelColorOrBG)//Current Child State + { + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(), aChecked); + } + else + { + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aChecked, Any()); + } +} + +void SvxPixelCtlAccessibleChild::SelectChild( bool bSelect) +{ + Any aSelected; + aSelected <<= AccessibleStateType::SELECTED; + + if (bSelect) + { + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(), aSelected); + } + else + { + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aSelected, Any()); + } +} + +SvxPixelCtlAccessibleChild::SvxPixelCtlAccessibleChild( SvxPixelCtl& rWindow, bool bPixelColorOrBG, + const tools::Rectangle& rBoundingBox, const rtl::Reference<SvxPixelCtlAccessible>& rxParent, + tools::Long nIndexInParent) + : mrParentWindow( rWindow ) + , mxParent(rxParent) + , m_bPixelColorOrBG(bPixelColorOrBG) + , maBoundingBox( rBoundingBox ) + , mnIndexInParent( nIndexInParent ) +{ +} + +SvxPixelCtlAccessibleChild::~SvxPixelCtlAccessibleChild() +{ + ensureDisposed(); +} + +IMPLEMENT_FORWARD_XINTERFACE2( SvxPixelCtlAccessibleChild, OAccessibleComponentHelper, OAccessibleHelper_Base ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvxPixelCtlAccessibleChild, OAccessibleComponentHelper, OAccessibleHelper_Base ) + +// XAccessible +uno::Reference< XAccessibleContext> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleContext() +{ + return this; +} + +uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleAtPoint( const awt::Point& ) +{ + return uno::Reference< XAccessible >(); +} + +void SAL_CALL SvxPixelCtlAccessibleChild::grabFocus() +{ +} + +sal_Int32 SvxPixelCtlAccessibleChild::getForeground() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return mxParent.is() ? mxParent->getForeground() : -1; +} + +sal_Int32 SvxPixelCtlAccessibleChild::getBackground() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return mxParent.is() ? mxParent->getBackground() : -1; +} + +// XAccessibleContext +sal_Int32 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChildCount() +{ + return 0; +} + +uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleChild( sal_Int32 ) +{ + throw lang::IndexOutOfBoundsException(); +} + +uno::Reference< XAccessible > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleParent() +{ + return mxParent; +} + +sal_Int16 SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRole() +{ + return AccessibleRole::CHECK_BOX; +} + +OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleDescription() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + return GetName(); +} + +OUString SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleName() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return GetName(); +} + +/** Return empty uno::Reference to indicate that the relation set is not + supported. +*/ +uno::Reference<XAccessibleRelationSet> SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleRelationSet() +{ + return uno::Reference< XAccessibleRelationSet >(); +} + +uno::Reference< XAccessibleStateSet > SAL_CALL SvxPixelCtlAccessibleChild::getAccessibleStateSet() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if (!rBHelper.bDisposed) + { + + pStateSetHelper->AddState( AccessibleStateType::TRANSIENT ); + pStateSetHelper->AddState( AccessibleStateType::ENABLED ); + pStateSetHelper->AddState( AccessibleStateType::OPAQUE ); + pStateSetHelper->AddState( AccessibleStateType::SELECTABLE ); + pStateSetHelper->AddState( AccessibleStateType::SHOWING ); + pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); + + tools::Long nIndex = mrParentWindow.GetFocusPosIndex(); + if ( nIndex == mnIndexInParent) + { + pStateSetHelper->AddState( AccessibleStateType::SELECTED ); + } + if (mrParentWindow.GetBitmapPixel(sal_uInt16(mnIndexInParent))) + { + pStateSetHelper->AddState( AccessibleStateType::CHECKED ); + } + } + else + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + + return pStateSetHelper; +} + +void SAL_CALL SvxPixelCtlAccessibleChild::disposing() +{ + OAccessibleComponentHelper::disposing(); + mxParent.clear(); +} + +awt::Rectangle SvxPixelCtlAccessibleChild::implGetBounds() +{ + // no guard necessary, because no one changes maBoundingBox after creating it + return AWTRectangle(maBoundingBox); +} + +OUString SvxPixelCtlAccessibleChild::GetName() const +{ + sal_Int32 nXIndex = mnIndexInParent % SvxPixelCtl::GetLineCount(); + sal_Int32 nYIndex = mnIndexInParent / SvxPixelCtl::GetLineCount(); + + OUString str = "(" + + OUString::number(nXIndex) + + "," + + OUString::number(nYIndex) + + ")"; + return str; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/accessibility/svxrectctaccessiblecontext.cxx b/svx/source/accessibility/svxrectctaccessiblecontext.cxx new file mode 100644 index 000000000..bca421c29 --- /dev/null +++ b/svx/source/accessibility/svxrectctaccessiblecontext.cxx @@ -0,0 +1,647 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <svxrectctaccessiblecontext.hxx> +#include <com/sun/star/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <unotools/accessiblestatesethelper.hxx> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <toolkit/helper/convert.hxx> +#include <vcl/svapp.hxx> +#include <osl/mutex.hxx> +#include <tools/debug.hxx> +#include <tools/gen.hxx> +#include <sal/log.hxx> +#include <vcl/settings.hxx> +#include <svx/strings.hrc> +#include <svx/dlgctrl.hxx> +#include <svx/dialmgr.hxx> +#include <com/sun/star/accessibility/AccessibleRelationType.hpp> +#include <unotools/accessiblerelationsethelper.hxx> + +using namespace ::cppu; +using namespace ::osl; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::accessibility; + +using namespace ::com::sun::star::lang; + +#define MAX_NUM_OF_CHILDREN 9 +#define NOCHILDSELECTED -1 + +// internal +namespace +{ + struct ChildIndexToPointData + { + TranslateId pResIdName; + TranslateId pResIdDescr; + RectPoint ePoint; + }; +} + + +static const ChildIndexToPointData* IndexToPoint( tools::Long nIndex ) +{ + DBG_ASSERT( nIndex < 9 && nIndex >= 0, "-IndexToPoint(): invalid child index! You have been warned..." ); + + // corners are counted from left to right and top to bottom + static const ChildIndexToPointData pCornerData[] = + { // index + { RID_SVXSTR_RECTCTL_ACC_CHLD_LT, RID_SVXSTR_RECTCTL_ACC_CHLD_LT, RectPoint::LT }, // 0 + { RID_SVXSTR_RECTCTL_ACC_CHLD_MT, RID_SVXSTR_RECTCTL_ACC_CHLD_MT, RectPoint::MT }, // 1 + { RID_SVXSTR_RECTCTL_ACC_CHLD_RT, RID_SVXSTR_RECTCTL_ACC_CHLD_RT, RectPoint::RT }, // 2 + { RID_SVXSTR_RECTCTL_ACC_CHLD_LM, RID_SVXSTR_RECTCTL_ACC_CHLD_LM, RectPoint::LM }, // 3 + { RID_SVXSTR_RECTCTL_ACC_CHLD_MM, RID_SVXSTR_RECTCTL_ACC_CHLD_MM, RectPoint::MM }, // 4 + { RID_SVXSTR_RECTCTL_ACC_CHLD_RM, RID_SVXSTR_RECTCTL_ACC_CHLD_RM, RectPoint::RM }, // 5 + { RID_SVXSTR_RECTCTL_ACC_CHLD_LB, RID_SVXSTR_RECTCTL_ACC_CHLD_LB, RectPoint::LB }, // 6 + { RID_SVXSTR_RECTCTL_ACC_CHLD_MB, RID_SVXSTR_RECTCTL_ACC_CHLD_MB, RectPoint::MB }, // 7 + { RID_SVXSTR_RECTCTL_ACC_CHLD_RB, RID_SVXSTR_RECTCTL_ACC_CHLD_RB, RectPoint::RB } // 8 + }; + + return pCornerData + nIndex; +} + + +static tools::Long PointToIndex( RectPoint ePoint ) +{ + tools::Long nRet( static_cast<tools::Long>(ePoint) ); + // corner control + // corners are counted from left to right and top to bottom + DBG_ASSERT( int(RectPoint::LT) == 0 && int(RectPoint::MT) == 1 && int(RectPoint::RT) == 2 && int(RectPoint::LM) == 3 && int(RectPoint::MM) == 4 && int(RectPoint::RM) == 5 && + int(RectPoint::LB) == 6 && int(RectPoint::MB) == 7 && int(RectPoint::RB) == 8, "*PointToIndex(): unexpected enum value!" ); + + nRet = static_cast<tools::Long>(ePoint); + + return nRet; +} + +SvxRectCtlAccessibleContext::SvxRectCtlAccessibleContext(SvxRectCtl* pRepr) + : mpRepr(pRepr) + , mnSelectedChild(NOCHILDSELECTED) +{ + { + ::SolarMutexGuard aSolarGuard; + msName = SvxResId( RID_SVXSTR_RECTCTL_ACC_CORN_NAME ); + msDescription = SvxResId( RID_SVXSTR_RECTCTL_ACC_CORN_DESCR ); + } + + mvChildren.resize(MAX_NUM_OF_CHILDREN); +} + +SvxRectCtlAccessibleContext::~SvxRectCtlAccessibleContext() +{ + ensureDisposed(); +} + +IMPLEMENT_FORWARD_XINTERFACE2( SvxRectCtlAccessibleContext, OAccessibleSelectionHelper, OAccessibleHelper_Base ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvxRectCtlAccessibleContext, OAccessibleSelectionHelper, OAccessibleHelper_Base ) + +Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleAtPoint( const awt::Point& rPoint ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + Reference< XAccessible > xRet; + + tools::Long nChild = mpRepr ? PointToIndex(mpRepr->GetApproxRPFromPixPt(rPoint)) : NOCHILDSELECTED; + + if (nChild != NOCHILDSELECTED) + xRet = getAccessibleChild( nChild ); + + return xRet; +} + +// XAccessibleContext +sal_Int32 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleChildCount() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + return SvxRectCtl::NO_CHILDREN; +} + +Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleChild( sal_Int32 nIndex ) +{ + checkChildIndex( nIndex ); + + Reference< XAccessible > xChild(mvChildren[ nIndex ]); + if( !xChild.is() ) + { + ::SolarMutexGuard aSolarGuard; + + ::osl::MutexGuard aGuard( m_aMutex ); + + xChild = mvChildren[ nIndex ].get(); + + if (!xChild.is() && mpRepr) + { + const ChildIndexToPointData* p = IndexToPoint( nIndex ); + OUString aName(SvxResId(p->pResIdName)); + OUString aDescr(SvxResId(p->pResIdDescr)); + + tools::Rectangle aFocusRect( mpRepr->CalculateFocusRectangle( p->ePoint ) ); + + rtl::Reference<SvxRectCtlChildAccessibleContext> pChild = new SvxRectCtlChildAccessibleContext(this, aName, + aDescr, aFocusRect, nIndex ); + mvChildren[ nIndex ] = pChild; + xChild = pChild; + + // set actual state + if( mnSelectedChild == nIndex ) + pChild->setStateChecked( true ); + } + } + + return xChild; +} + +Reference< XAccessible > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleParent() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if (mpRepr) + return mpRepr->getAccessibleParent(); + return uno::Reference<css::accessibility::XAccessible>(); +} + +sal_Int16 SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRole() +{ + return AccessibleRole::PANEL; +} + +OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleDescription() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return msDescription + " Please use arrow key to selection."; +} + +OUString SAL_CALL SvxRectCtlAccessibleContext::getAccessibleName() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return msName; +} + +/** Return empty reference to indicate that the relation set is not + supported. +*/ +Reference< XAccessibleRelationSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleRelationSet() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if (mpRepr) + return mpRepr->get_accessible_relation_set(); + return uno::Reference<css::accessibility::XAccessibleRelationSet>(); +} + +Reference< XAccessibleStateSet > SAL_CALL SvxRectCtlAccessibleContext::getAccessibleStateSet() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if (mpRepr) + { + pStateSetHelper->AddState( AccessibleStateType::ENABLED ); + pStateSetHelper->AddState( AccessibleStateType::FOCUSABLE ); + if( mpRepr->HasFocus() ) + pStateSetHelper->AddState( AccessibleStateType::FOCUSED ); + pStateSetHelper->AddState( AccessibleStateType::OPAQUE ); + + pStateSetHelper->AddState( AccessibleStateType::SHOWING ); + + if( mpRepr->IsVisible() ) + pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); + } + else + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + + return pStateSetHelper; +} + +void SAL_CALL SvxRectCtlAccessibleContext::grabFocus() +{ + ::SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + if (mpRepr) + mpRepr->GrabFocus(); +} + +sal_Int32 SvxRectCtlAccessibleContext::getForeground() +{ + ::SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + //see SvxRectCtl::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetLabelTextColor()); +} + +sal_Int32 SvxRectCtlAccessibleContext::getBackground( ) +{ + ::SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + //see SvxRectCtl::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetDialogColor()); +} + +// XAccessibleSelection +void SvxRectCtlAccessibleContext::implSelect(sal_Int32 nIndex, bool bSelect) +{ + ::SolarMutexGuard aSolarGuard; + + ::osl::MutexGuard aGuard( m_aMutex ); + + checkChildIndex( nIndex ); + + const ChildIndexToPointData* pData = IndexToPoint( nIndex ); + + DBG_ASSERT(pData, "SvxRectCtlAccessibleContext::selectAccessibleChild(): this is an impossible state! Or at least should be..."); + + if (mpRepr) + { + if (bSelect) + { + // this does all what is needed, including the change of the child's state! + mpRepr->SetActualRP( pData->ePoint ); + } + else + { + SAL_WARN( "svx", "SvxRectCtlAccessibleContext::clearAccessibleSelection() is not possible!" ); + } + } +} + +bool SvxRectCtlAccessibleContext::implIsSelected( sal_Int32 nIndex ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + checkChildIndex( nIndex ); + + return nIndex == mnSelectedChild; +} + +// internals +void SvxRectCtlAccessibleContext::checkChildIndex( tools::Long nIndex ) +{ + if( nIndex < 0 || nIndex >= getAccessibleChildCount() ) + throw lang::IndexOutOfBoundsException(); +} + +void SvxRectCtlAccessibleContext::FireChildFocus( RectPoint eButton ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + tools::Long nNew = PointToIndex( eButton ); + tools::Long nNumOfChildren = getAccessibleChildCount(); + if( nNew < nNumOfChildren ) + { + // select new child + mnSelectedChild = nNew; + if( nNew != NOCHILDSELECTED ) + { + if( mvChildren[ nNew ].is() ) + mvChildren[ nNew ]->FireFocusEvent(); + } + else + { + Any aOld; + Any aNew; + aNew <<= AccessibleStateType::FOCUSED; + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew); + } + } + else + mnSelectedChild = NOCHILDSELECTED; +} + +void SvxRectCtlAccessibleContext::selectChild( tools::Long nNew ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + if( nNew == mnSelectedChild ) + return; + + tools::Long nNumOfChildren = getAccessibleChildCount(); + if( nNew < nNumOfChildren ) + { // valid index + if( mnSelectedChild != NOCHILDSELECTED ) + { // deselect old selected child if one is selected + SvxRectCtlChildAccessibleContext* pChild = mvChildren[ mnSelectedChild ].get(); + if( pChild ) + pChild->setStateChecked( false ); + } + + // select new child + mnSelectedChild = nNew; + + if( nNew != NOCHILDSELECTED ) + { + if( mvChildren[ nNew ].is() ) + mvChildren[ nNew ]->setStateChecked( true ); + } + } + else + mnSelectedChild = NOCHILDSELECTED; +} + +void SvxRectCtlAccessibleContext::selectChild(RectPoint eButton ) +{ + // no guard -> is done in next selectChild + selectChild(PointToIndex( eButton )); +} + +void SAL_CALL SvxRectCtlAccessibleContext::disposing() +{ + ::osl::MutexGuard aGuard(m_aMutex); + OAccessibleSelectionHelper::disposing(); + for (auto & rxChild : mvChildren) + { + if( rxChild.is() ) + rxChild->dispose(); + } + mvChildren.clear(); + mpRepr = nullptr; +} + +awt::Rectangle SvxRectCtlAccessibleContext::implGetBounds() +{ + ::SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + awt::Rectangle aRet; + + if (mpRepr) + { + const Point aOutPos; + Size aOutSize(mpRepr->GetOutputSizePixel()); + + aRet.X = aOutPos.X(); + aRet.Y = aOutPos.Y(); + aRet.Width = aOutSize.Width(); + aRet.Height = aOutSize.Height(); + } + + return aRet; +} + +SvxRectCtlChildAccessibleContext::SvxRectCtlChildAccessibleContext( + const Reference<XAccessible>& rxParent, + const OUString& rName, + const OUString& rDescription, + const tools::Rectangle& rBoundingBox, + tools::Long nIndexInParent ) + : msDescription( rDescription ) + , msName( rName ) + , mxParent(rxParent) + , maBoundingBox( rBoundingBox ) + , mnIndexInParent( nIndexInParent ) + , mbIsChecked( false ) +{ +} + +SvxRectCtlChildAccessibleContext::~SvxRectCtlChildAccessibleContext() +{ + ensureDisposed(); +} + +Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleAtPoint( const awt::Point& /*rPoint*/ ) +{ + return Reference< XAccessible >(); +} + +void SAL_CALL SvxRectCtlChildAccessibleContext::grabFocus() +{ +} + +sal_Int32 SvxRectCtlChildAccessibleContext::getForeground( ) +{ + ::SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + //see SvxRectCtl::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetLabelTextColor()); +} + +sal_Int32 SvxRectCtlChildAccessibleContext::getBackground( ) +{ + ::SolarMutexGuard aSolarGuard; + ::osl::MutexGuard aGuard( m_aMutex ); + + //see SvxRectCtl::Paint + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + return sal_Int32(rStyles.GetDialogColor()); +} + +// XAccessibleContext +sal_Int32 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleChildCount() +{ + return 0; +} + +Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleChild( sal_Int32 /*nIndex*/ ) +{ + throw lang::IndexOutOfBoundsException(); +} + +Reference< XAccessible > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleParent() +{ + return mxParent; +} + +sal_Int16 SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRole() +{ + return AccessibleRole::RADIO_BUTTON; +} + +OUString SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleDescription() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return msDescription; +} + +OUString SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleName() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return msName; +} + +/** Return empty reference to indicate that the relation set is not + supported. +*/ +Reference<XAccessibleRelationSet> SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleRelationSet() +{ + rtl::Reference<utl::AccessibleRelationSetHelper> pRelationSetHelper = new utl::AccessibleRelationSetHelper; + if( mxParent.is() ) + { + uno::Sequence< uno::Reference< uno::XInterface > > aSequence { mxParent }; + pRelationSetHelper->AddRelation( css::accessibility::AccessibleRelation( css::accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) ); + } + + return pRelationSetHelper; +} + +Reference< XAccessibleStateSet > SAL_CALL SvxRectCtlChildAccessibleContext::getAccessibleStateSet() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper; + + if (!rBHelper.bDisposed) + { + if( mbIsChecked ) + { + pStateSetHelper->AddState( AccessibleStateType::CHECKED ); + } + + pStateSetHelper->AddState( AccessibleStateType::ENABLED ); + pStateSetHelper->AddState( AccessibleStateType::SENSITIVE ); + pStateSetHelper->AddState( AccessibleStateType::OPAQUE ); + pStateSetHelper->AddState( AccessibleStateType::SELECTABLE ); + pStateSetHelper->AddState( AccessibleStateType::SHOWING ); + pStateSetHelper->AddState( AccessibleStateType::VISIBLE ); + } + else + pStateSetHelper->AddState( AccessibleStateType::DEFUNC ); + + return pStateSetHelper; +} + +// XAccessibleValue +Any SAL_CALL SvxRectCtlChildAccessibleContext::getCurrentValue() +{ + Any aRet; + aRet <<= ( mbIsChecked? 1.0 : 0.0 ); + return aRet; +} + +sal_Bool SAL_CALL SvxRectCtlChildAccessibleContext::setCurrentValue( const Any& /*aNumber*/ ) +{ + return false; +} + +Any SAL_CALL SvxRectCtlChildAccessibleContext::getMaximumValue() +{ + Any aRet; + aRet <<= 1.0; + return aRet; +} + +Any SAL_CALL SvxRectCtlChildAccessibleContext::getMinimumValue() +{ + Any aRet; + aRet <<= 0.0; + return aRet; +} + +Any SAL_CALL SvxRectCtlChildAccessibleContext::getMinimumIncrement() +{ + Any aRet; + aRet <<= 1.0; + return aRet; +} + + +// XAccessibleAction + + +sal_Int32 SvxRectCtlChildAccessibleContext::getAccessibleActionCount( ) +{ + return 1; +} + + +sal_Bool SvxRectCtlChildAccessibleContext::doAccessibleAction ( sal_Int32 nIndex ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( nIndex < 0 || nIndex >= getAccessibleActionCount() ) + throw IndexOutOfBoundsException(); + + Reference<XAccessibleSelection> xSelection( mxParent, UNO_QUERY); + + xSelection->selectAccessibleChild(mnIndexInParent); + + return true; +} + + +OUString SvxRectCtlChildAccessibleContext::getAccessibleActionDescription ( sal_Int32 nIndex ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( nIndex < 0 || nIndex >= getAccessibleActionCount() ) + throw IndexOutOfBoundsException(); + + return "select"; +} + + +Reference< XAccessibleKeyBinding > SvxRectCtlChildAccessibleContext::getAccessibleActionKeyBinding( sal_Int32 nIndex ) +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + if ( nIndex < 0 || nIndex >= getAccessibleActionCount() ) + throw IndexOutOfBoundsException(); + + return Reference< XAccessibleKeyBinding >(); +} + +void SAL_CALL SvxRectCtlChildAccessibleContext::disposing() +{ + OAccessibleComponentHelper::disposing(); + mxParent.clear(); +} + +awt::Rectangle SvxRectCtlChildAccessibleContext::implGetBounds( ) +{ + // no guard necessary, because no one changes maBoundingBox after creating it + return AWTRectangle(maBoundingBox); +} + +void SvxRectCtlChildAccessibleContext::setStateChecked( bool bChecked ) +{ + if( mbIsChecked == bChecked ) + return; + + mbIsChecked = bChecked; + + Any aOld; + Any aNew; + Any& rMod = bChecked? aNew : aOld; + + //Send the STATE_CHANGED(Focused) event to accessible + rMod <<= AccessibleStateType::FOCUSED; + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew); + + rMod <<= AccessibleStateType::CHECKED; + + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew); +} + +void SvxRectCtlChildAccessibleContext::FireFocusEvent() +{ + Any aOld; + Any aNew; + aNew <<= AccessibleStateType::FOCUSED; + NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOld, aNew); +} + +IMPLEMENT_FORWARD_XINTERFACE2( SvxRectCtlChildAccessibleContext, OAccessibleComponentHelper, OAccessibleHelper_Base_3 ) +IMPLEMENT_FORWARD_XTYPEPROVIDER2( SvxRectCtlChildAccessibleContext, OAccessibleComponentHelper, OAccessibleHelper_Base_3 ) + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |