| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _SVX_ACCESSIBLE_PARA_MANAGER_HXX |
| #define _SVX_ACCESSIBLE_PARA_MANAGER_HXX |
| |
| #include <vector> |
| #include <algorithm> |
| #include <functional> |
| #include <utility> |
| #include <tools/gen.hxx> |
| #include <com/sun/star/awt/Rectangle.hpp> |
| #include <com/sun/star/uno/Reference.hxx> |
| #include <cppuhelper/weakref.hxx> |
| #include <com/sun/star/accessibility/XAccessibleContext.hpp> |
| #include "editeng/editengdllapi.h" |
| |
| class SvxEditSourceAdapter; |
| |
| namespace accessibility |
| { |
| class AccessibleEditableTextPara; |
| |
| /** Helper class for WeakCppRef |
| |
| This class is returned by WeakChild::get() and contains a hard |
| reference and a reference to the c++ object. This combination |
| prevents the c++ object from destruction during usage. Hold |
| this object only as long as absolutely necessary, prevents |
| referenced object from vanishing otherwise |
| */ |
| template < class UnoType, class CppType > class HardCppRef |
| { |
| public: |
| |
| typedef UnoType UnoInterfaceType; |
| typedef CppType InterfaceType; |
| |
| HardCppRef( const ::com::sun::star::uno::WeakReference< UnoInterfaceType >& xRef, InterfaceType* rImpl ) : |
| mxRef( xRef ), |
| mpImpl( rImpl ) |
| { |
| } |
| |
| /** Query whether the reference is still valid. |
| |
| Hands off also from the implementation pointer if this |
| returns sal_False! |
| */ |
| sal_Bool is() const { return mxRef.is(); } |
| InterfaceType* operator->() const { return mpImpl; } |
| InterfaceType& operator*() const { return *mpImpl; } |
| ::com::sun::star::uno::Reference< UnoInterfaceType >& getRef() { return mxRef; } |
| const ::com::sun::star::uno::Reference< UnoInterfaceType >& getRef() const { return mxRef; } |
| |
| // default copy constructor and assignment will do |
| // HardCppRef( const HardCppRef& ); |
| // HardCppRef& operator= ( const HardCppRef& ); |
| |
| private: |
| |
| // the interface, hard reference to prevent object from vanishing |
| ::com::sun::star::uno::Reference< UnoInterfaceType > mxRef; |
| |
| // the c++ object, for our internal stuff |
| InterfaceType* mpImpl; |
| |
| }; |
| |
| /** Helper class for weak object references plus implementation |
| |
| This class combines a weak reference (to facilitate automatic |
| object disposal if user drops last reference) and hard |
| reference to the c++ class (for fast access and bypassing of |
| the UNO interface) |
| */ |
| template < class UnoType, class CppType > class WeakCppRef |
| { |
| public: |
| |
| typedef UnoType UnoInterfaceType; |
| typedef CppType InterfaceType; |
| typedef HardCppRef< UnoInterfaceType, InterfaceType > HardRefType; |
| |
| WeakCppRef() : maWeakRef(), maUnsafeRef( NULL ) {} |
| WeakCppRef( InterfaceType& rImpl ) : |
| maWeakRef( ::com::sun::star::uno::Reference< UnoInterfaceType >( rImpl, ::com::sun::star::uno::UNO_QUERY ) ), |
| maUnsafeRef( &rImpl ) |
| { |
| } |
| |
| WeakCppRef( HardRefType& rImpl ) : |
| maWeakRef( rImpl.getRef() ), |
| maUnsafeRef( rImpl.operator->() ) |
| { |
| } |
| |
| // get object with c++ object and hard reference (which |
| // prevents the c++ object from destruction during use) |
| HardRefType get() const { return HardRefType( maWeakRef, maUnsafeRef ); } |
| |
| // default copy constructor and assignment will do |
| // WeakCppRef( const WeakCppRef& ); |
| // WeakCppRef& operator= ( const WeakCppRef& ); |
| |
| private: |
| |
| // the interface, hold weakly |
| ::com::sun::star::uno::WeakReference< UnoInterfaceType > maWeakRef; |
| |
| // hard ref to c++ class, _only_ valid if maWeakRef.is() is true |
| InterfaceType* maUnsafeRef; |
| }; |
| |
| |
| /** This class manages the paragraphs of an AccessibleTextHelper |
| |
| To facilitate automatic deletion of paragraphs no longer used, |
| this class uses the WeakCppRef helper to hold the objects weakly. |
| */ |
| class EDITENG_DLLPUBLIC AccessibleParaManager |
| { |
| public: |
| typedef WeakCppRef < ::com::sun::star::accessibility::XAccessible, AccessibleEditableTextPara > WeakPara; |
| typedef ::std::pair< WeakPara, ::com::sun::star::awt::Rectangle > WeakChild; |
| typedef ::std::pair< ::com::sun::star::uno::Reference< |
| ::com::sun::star::accessibility::XAccessible > , ::com::sun::star::awt::Rectangle > Child; |
| typedef ::std::vector< WeakChild > VectorOfChildren; |
| typedef ::std::vector< sal_Int16 > VectorOfStates; |
| |
| AccessibleParaManager(); |
| ~AccessibleParaManager(); |
| |
| /** Sets a vector of additional accessible states. |
| |
| The states are passed to every created child object |
| (text paragraph). The state values are defined in |
| com::sun::star::accessibility::AccessibleStateType. |
| */ |
| void SetAdditionalChildStates( const VectorOfStates& rChildStates ); |
| |
| /** Returns the additional accessible states for children. |
| */ |
| const VectorOfStates& GetAdditionalChildStates() const; |
| |
| /** Set the number of paragraphs |
| |
| @param nNumPara |
| The total number of paragraphs the EditEngine currently |
| has (_not_ the number of currently visible children) |
| */ |
| void SetNum( sal_Int32 nNumParas ); |
| |
| /** Get the number of paragraphs currently possible */ |
| sal_uInt32 GetNum() const; |
| |
| // iterators |
| VectorOfChildren::iterator begin(); |
| VectorOfChildren::iterator end(); |
| VectorOfChildren::const_iterator begin() const; |
| VectorOfChildren::const_iterator end() const; |
| |
| // dealing with single paragraphs (release reference, return reference etc) |
| void Release( sal_uInt32 nPara ); |
| /// Set focus to given child |
| void SetFocus( sal_Int32 nChild ); |
| |
| void FireEvent( sal_uInt32 nPara, |
| const sal_Int16 nEventId, |
| const ::com::sun::star::uno::Any& rNewValue = ::com::sun::star::uno::Any(), |
| const ::com::sun::star::uno::Any& rOldValue = ::com::sun::star::uno::Any() ) const; |
| |
| static sal_Bool IsReferencable( WeakPara::HardRefType aChild ); |
| sal_Bool IsReferencable( sal_uInt32 nChild ) const; |
| static void ShutdownPara( const WeakChild& rChild ); |
| |
| Child CreateChild( sal_Int32 nChild, |
| const ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >& xFrontEnd, |
| SvxEditSourceAdapter& rEditSource, |
| sal_uInt32 nParagraphIndex ); |
| |
| WeakChild GetChild( sal_uInt32 nParagraphIndex ) const; |
| |
| // forwarder to all paragraphs |
| /// Make all children active and editable (or off) |
| void SetActive( sal_Bool bActive = sal_True ); |
| /// Set state of all children |
| void SetState( const sal_Int16 nStateId ); |
| /// Unset state of all children |
| void UnSetState( const sal_Int16 nStateId ); |
| /// Set offset to edit engine for all children |
| void SetEEOffset ( const Point& rOffset ); |
| /// Change edit source on all living children |
| void SetEditSource ( SvxEditSourceAdapter* pEditSource ); |
| /// Dispose all living children |
| void Dispose (); |
| |
| // forwarder to given paragraphs |
| //------------------------------------------------------------------------ |
| /** Release the given range of paragraphs |
| |
| All ranges have the meaning [start,end), similar to STL |
| |
| @param nStartPara |
| Index of paragraph to start with releasing |
| |
| @param nEndPara |
| Index of first paragraph to stop with releasing |
| */ |
| void Release( sal_uInt32 nStartPara, sal_uInt32 nEndPara ); |
| |
| /** Fire event for the given range of paragraphs |
| |
| All ranges have the meaning [start,end), similar to STL |
| |
| @param nStartPara |
| Index of paragraph to start with event firing |
| |
| @param nEndPara |
| Index of first paragraph to stop with event firing |
| */ |
| void FireEvent( sal_uInt32 nStartPara, |
| sal_uInt32 nEndPara, |
| const sal_Int16 nEventId, |
| const ::com::sun::star::uno::Any& rNewValue = ::com::sun::star::uno::Any(), |
| const ::com::sun::star::uno::Any& rOldValue = ::com::sun::star::uno::Any() ) const; |
| |
| /** Functor adapter for ForEach template |
| |
| Adapts giving functor such that only the paragraph objects |
| are accessed and the fact that our children are held |
| weakly is hidden |
| |
| The functor must provide the following method: |
| void operator() ( AccessibleEditablePara& ) |
| |
| */ |
| template < typename Functor > class WeakChildAdapter : public ::std::unary_function< const WeakChild&, void > |
| { |
| public: |
| WeakChildAdapter( Functor& rFunctor ) : mrFunctor(rFunctor) {} |
| void operator()( const WeakChild& rPara ) |
| { |
| // retrieve hard reference from weak one |
| WeakPara::HardRefType aHardRef( rPara.first.get() ); |
| |
| if( aHardRef.is() ) |
| mrFunctor( *aHardRef ); |
| } |
| |
| private: |
| Functor& mrFunctor; |
| }; |
| |
| /** Adapter for unary member functions |
| |
| Since STL's binder don't work with const& arguments (and |
| BOOST's neither, at least on MSVC), have to provide our |
| own adapter for unary member functions. |
| |
| Create with pointer to member function of |
| AccessibleEditableTextPara and the corresponding argument. |
| */ |
| template < typename Argument > class MemFunAdapter : public ::std::unary_function< const WeakChild&, void > |
| { |
| public: |
| typedef void (::accessibility::AccessibleEditableTextPara::*FunctionPointer)( Argument ); |
| |
| MemFunAdapter( FunctionPointer aFunPtr, Argument aArg ) : maFunPtr(aFunPtr), maArg(aArg) {} |
| void operator()( const WeakChild& rPara ) |
| { |
| // retrieve hard reference from weak one |
| WeakPara::HardRefType aHardRef( rPara.first.get() ); |
| |
| if( aHardRef.is() ) |
| (*aHardRef.*maFunPtr)( maArg ); |
| } |
| |
| private: |
| FunctionPointer maFunPtr; |
| Argument maArg; |
| }; |
| |
| /** Generic algorithm on given paragraphs |
| |
| Convenience method, that already adapts the given functor with WeakChildAdapter |
| */ |
| template < typename Functor > void ForEach( Functor& rFunctor ) |
| { |
| ::std::for_each( begin(), end(), WeakChildAdapter< Functor >(rFunctor) ); |
| } |
| |
| private: |
| /// Set state on given child |
| void SetState( sal_Int32 nChild, const sal_Int16 nStateId ); |
| /// Unset state on given child |
| void UnSetState( sal_Int32 nChild, const sal_Int16 nStateId ); |
| /// Init child with default state (as stored in previous SetFocus and SetActive calls) |
| void InitChild( AccessibleEditableTextPara& rChild, |
| SvxEditSourceAdapter& rEditSource, |
| sal_Int32 nChild, |
| sal_uInt32 nParagraphIndex ) const; |
| |
| // vector the size of the paragraph number of the underlying EditEngine |
| VectorOfChildren maChildren; |
| |
| /// Additional states that will be set at every created child object. |
| VectorOfStates maChildStates; |
| |
| // cache EE offset for child creation |
| Point maEEOffset; |
| |
| // which child currently has the focus (-1 for none) |
| sal_Int32 mnFocusedChild; |
| |
| // whether children are active and editable |
| sal_Bool mbActive; |
| }; |
| |
| } // end of namespace accessibility |
| |
| #endif |
| |
