1efeef26fSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file
5efeef26fSAndrew Rist * distributed with this work for additional information
6efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the
8efeef26fSAndrew Rist * "License"); you may not use this file except in compliance
9efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at
10efeef26fSAndrew Rist *
11efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12efeef26fSAndrew Rist *
13efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing,
14efeef26fSAndrew Rist * software distributed under the License is distributed on an
15efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16efeef26fSAndrew Rist * KIND, either express or implied. See the License for the
17efeef26fSAndrew Rist * specific language governing permissions and limitations
18efeef26fSAndrew Rist * under the License.
19efeef26fSAndrew Rist *
20efeef26fSAndrew Rist *************************************************************/
21efeef26fSAndrew Rist
22efeef26fSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sw.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir #include <vos/ref.hxx>
29cdf0e10cSrcweir #include <cppuhelper/weakref.hxx>
30cdf0e10cSrcweir #include <vcl/window.hxx>
31cdf0e10cSrcweir #include <svx/svdmodel.hxx>
32cdf0e10cSrcweir #include <svx/unomod.hxx>
33cdf0e10cSrcweir #include <tools/debug.hxx>
34cdf0e10cSrcweir
35cdf0e10cSrcweir #include <map>
36cdf0e10cSrcweir #include <list>
37ca62e2c2SSteve Yin #include <vector>
38cdf0e10cSrcweir #include <accmap.hxx>
39cdf0e10cSrcweir #include <acccontext.hxx>
40cdf0e10cSrcweir #include <accdoc.hxx>
41cdf0e10cSrcweir #include <accpreview.hxx>
42cdf0e10cSrcweir #include <accpage.hxx>
43cdf0e10cSrcweir #include <accpara.hxx>
44cdf0e10cSrcweir #include <accheaderfooter.hxx>
45cdf0e10cSrcweir #include <accfootnote.hxx>
46cdf0e10cSrcweir #include <acctextframe.hxx>
47cdf0e10cSrcweir #include <accgraphic.hxx>
48cdf0e10cSrcweir #include <accembedded.hxx>
49cdf0e10cSrcweir #include <acccell.hxx>
50cdf0e10cSrcweir #include <acctable.hxx>
51cdf0e10cSrcweir #include <fesh.hxx>
52cdf0e10cSrcweir #include <rootfrm.hxx>
53cdf0e10cSrcweir #include <txtfrm.hxx>
54cdf0e10cSrcweir #include <hffrm.hxx>
55cdf0e10cSrcweir #include <ftnfrm.hxx>
56cdf0e10cSrcweir #include <cellfrm.hxx>
57cdf0e10cSrcweir #include <tabfrm.hxx>
58cdf0e10cSrcweir #include <pagefrm.hxx>
59cdf0e10cSrcweir #include <flyfrm.hxx>
60cdf0e10cSrcweir #include <ndtyp.hxx>
61cdf0e10cSrcweir #include <IDocumentDrawModelAccess.hxx>
62cdf0e10cSrcweir #include <svx/ShapeTypeHandler.hxx>
63cdf0e10cSrcweir #include <vcl/svapp.hxx>
64ca62e2c2SSteve Yin #ifndef _SVX_ACCESSIBILITY_SHAPE_TYPE_HANDLER_HXX
65ca62e2c2SSteve Yin #include <svx/ShapeTypeHandler.hxx>
66ca62e2c2SSteve Yin #endif
67ca62e2c2SSteve Yin #ifndef _SVX_ACCESSIBILITY_SVX_SHAPE_TYPES_HXX
68ca62e2c2SSteve Yin #include <svx/SvxShapeTypes.hxx>
69ca62e2c2SSteve Yin #endif
70ca62e2c2SSteve Yin #ifndef _SVDPAGE_HXX
71ca62e2c2SSteve Yin #include <svx/svdpage.hxx>
72ca62e2c2SSteve Yin #endif
73cdf0e10cSrcweir #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
74cdf0e10cSrcweir #include <com/sun/star/accessibility/AccessibleEventId.hpp>
75cdf0e10cSrcweir #include <com/sun/star/accessibility/AccessibleStateType.hpp>
76ca62e2c2SSteve Yin #include <com/sun/star/accessibility/AccessibleRole.hpp>
77cdf0e10cSrcweir #include <cppuhelper/implbase1.hxx>
78cdf0e10cSrcweir #include <pagepreviewlayout.hxx>
79ca62e2c2SSteve Yin #include <dcontact.hxx>
80ca62e2c2SSteve Yin #include <svx/unoapi.hxx>
81ca62e2c2SSteve Yin #include <svx/svdmark.hxx>
82ca62e2c2SSteve Yin #include <doc.hxx>
83cdf0e10cSrcweir #include <pam.hxx>
84cdf0e10cSrcweir #include <ndtxt.hxx>
85cdf0e10cSrcweir #include <dflyobj.hxx>
86cdf0e10cSrcweir #include <prevwpage.hxx>
87cdf0e10cSrcweir #include <switerator.hxx>
88cdf0e10cSrcweir
89cdf0e10cSrcweir using namespace ::com::sun::star;
90cdf0e10cSrcweir using namespace ::com::sun::star::accessibility;
91cdf0e10cSrcweir using ::rtl::OUString;
92cdf0e10cSrcweir using namespace ::sw::access;
93cdf0e10cSrcweir
94cdf0e10cSrcweir struct SwFrmFunc
95cdf0e10cSrcweir {
operator ()SwFrmFunc96cdf0e10cSrcweir sal_Bool operator()( const SwFrm * p1,
97cdf0e10cSrcweir const SwFrm * p2) const
98cdf0e10cSrcweir {
99cdf0e10cSrcweir return p1 < p2;
100cdf0e10cSrcweir }
101cdf0e10cSrcweir };
102cdf0e10cSrcweir
103cdf0e10cSrcweir typedef ::std::map < const SwFrm *, uno::WeakReference < XAccessible >, SwFrmFunc > _SwAccessibleContextMap_Impl;
104cdf0e10cSrcweir
105cdf0e10cSrcweir class SwAccessibleContextMap_Impl: public _SwAccessibleContextMap_Impl
106cdf0e10cSrcweir {
107cdf0e10cSrcweir public:
108cdf0e10cSrcweir
109cdf0e10cSrcweir #ifdef DBG_UTIL
110cdf0e10cSrcweir sal_Bool mbLocked;
111cdf0e10cSrcweir #endif
112cdf0e10cSrcweir
SwAccessibleContextMap_Impl()113cdf0e10cSrcweir SwAccessibleContextMap_Impl()
114cdf0e10cSrcweir #ifdef DBG_UTIL
115cdf0e10cSrcweir : mbLocked( sal_False )
116cdf0e10cSrcweir #endif
117cdf0e10cSrcweir {}
118cdf0e10cSrcweir
119cdf0e10cSrcweir };
120cdf0e10cSrcweir
121cdf0e10cSrcweir //------------------------------------------------------------------------------
122cdf0e10cSrcweir class SwDrawModellListener_Impl : public SfxListener,
123cdf0e10cSrcweir public ::cppu::WeakImplHelper1< document::XEventBroadcaster >
124cdf0e10cSrcweir {
125cdf0e10cSrcweir mutable ::osl::Mutex maListenerMutex;
126cdf0e10cSrcweir ::cppu::OInterfaceContainerHelper maEventListeners;
127cdf0e10cSrcweir SdrModel *mpDrawModel;
128cdf0e10cSrcweir protected:
129cdf0e10cSrcweir virtual ~SwDrawModellListener_Impl();
130cdf0e10cSrcweir public:
131cdf0e10cSrcweir
132cdf0e10cSrcweir SwDrawModellListener_Impl( SdrModel *pDrawModel );
133cdf0e10cSrcweir
134cdf0e10cSrcweir
135cdf0e10cSrcweir virtual void SAL_CALL addEventListener( const uno::Reference< document::XEventListener >& xListener ) throw (uno::RuntimeException);
136cdf0e10cSrcweir virtual void SAL_CALL removeEventListener( const uno::Reference< document::XEventListener >& xListener ) throw (uno::RuntimeException);
137cdf0e10cSrcweir
138cdf0e10cSrcweir virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint );
139cdf0e10cSrcweir void Dispose();
140cdf0e10cSrcweir };
141cdf0e10cSrcweir
SwDrawModellListener_Impl(SdrModel * pDrawModel)142cdf0e10cSrcweir SwDrawModellListener_Impl::SwDrawModellListener_Impl( SdrModel *pDrawModel ) :
143cdf0e10cSrcweir maEventListeners( maListenerMutex ),
144cdf0e10cSrcweir mpDrawModel( pDrawModel )
145cdf0e10cSrcweir {
146cdf0e10cSrcweir StartListening( *mpDrawModel );
147cdf0e10cSrcweir }
148cdf0e10cSrcweir
~SwDrawModellListener_Impl()149cdf0e10cSrcweir SwDrawModellListener_Impl::~SwDrawModellListener_Impl()
150cdf0e10cSrcweir {
151cdf0e10cSrcweir EndListening( *mpDrawModel );
152cdf0e10cSrcweir }
153cdf0e10cSrcweir
addEventListener(const uno::Reference<document::XEventListener> & xListener)154cdf0e10cSrcweir void SAL_CALL SwDrawModellListener_Impl::addEventListener( const uno::Reference< document::XEventListener >& xListener ) throw (uno::RuntimeException)
155cdf0e10cSrcweir {
156cdf0e10cSrcweir maEventListeners.addInterface( xListener );
157cdf0e10cSrcweir }
158cdf0e10cSrcweir
removeEventListener(const uno::Reference<document::XEventListener> & xListener)159cdf0e10cSrcweir void SAL_CALL SwDrawModellListener_Impl::removeEventListener( const uno::Reference< document::XEventListener >& xListener ) throw (uno::RuntimeException)
160cdf0e10cSrcweir {
161cdf0e10cSrcweir maEventListeners.removeInterface( xListener );
162cdf0e10cSrcweir }
163cdf0e10cSrcweir
Notify(SfxBroadcaster &,const SfxHint & rHint)164cdf0e10cSrcweir void SwDrawModellListener_Impl::Notify( SfxBroadcaster& /*rBC*/,
165cdf0e10cSrcweir const SfxHint& rHint )
166cdf0e10cSrcweir {
167cdf0e10cSrcweir // do not broadcast notifications for writer fly frames, because there
168cdf0e10cSrcweir // are no shapes that need to know about them.
169cdf0e10cSrcweir // OD 01.07.2003 #110554# - correct condition in order not to broadcast
170cdf0e10cSrcweir // notifications for writer fly frames.
171cdf0e10cSrcweir // OD 01.07.2003 #110554# - do not broadcast notifications for plane
172cdf0e10cSrcweir // <SdrObject>objects
173cdf0e10cSrcweir const SdrHint *pSdrHint = PTR_CAST( SdrHint, &rHint );
174cdf0e10cSrcweir if ( !pSdrHint ||
175cdf0e10cSrcweir ( pSdrHint->GetObject() &&
176cdf0e10cSrcweir ( pSdrHint->GetObject()->ISA(SwFlyDrawObj) ||
177cdf0e10cSrcweir pSdrHint->GetObject()->ISA(SwVirtFlyDrawObj) ||
178cdf0e10cSrcweir IS_TYPE(SdrObject,pSdrHint->GetObject()) ) ) )
179cdf0e10cSrcweir {
180cdf0e10cSrcweir return;
181cdf0e10cSrcweir }
182cdf0e10cSrcweir
183cdf0e10cSrcweir ASSERT( mpDrawModel, "draw model listener is disposed" );
184cdf0e10cSrcweir if( !mpDrawModel )
185cdf0e10cSrcweir return;
186cdf0e10cSrcweir
187cdf0e10cSrcweir document::EventObject aEvent;
188cdf0e10cSrcweir if( !SvxUnoDrawMSFactory::createEvent( mpDrawModel, pSdrHint, aEvent ) )
189cdf0e10cSrcweir return;
190cdf0e10cSrcweir
191cdf0e10cSrcweir ::cppu::OInterfaceIteratorHelper aIter( maEventListeners );
192cdf0e10cSrcweir while( aIter.hasMoreElements() )
193cdf0e10cSrcweir {
194cdf0e10cSrcweir uno::Reference < document::XEventListener > xListener( aIter.next(),
195cdf0e10cSrcweir uno::UNO_QUERY );
196cdf0e10cSrcweir try
197cdf0e10cSrcweir {
198cdf0e10cSrcweir xListener->notifyEvent( aEvent );
199cdf0e10cSrcweir }
200cdf0e10cSrcweir catch( uno::RuntimeException const & r )
201cdf0e10cSrcweir {
202cdf0e10cSrcweir (void)r;
203cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
204cdf0e10cSrcweir ByteString aError( "Runtime exception caught while notifying shape.:\n" );
205cdf0e10cSrcweir aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US );
206cdf0e10cSrcweir DBG_ERROR( aError.GetBuffer() );
207cdf0e10cSrcweir #endif
208cdf0e10cSrcweir }
209cdf0e10cSrcweir }
210cdf0e10cSrcweir }
211cdf0e10cSrcweir
Dispose()212cdf0e10cSrcweir void SwDrawModellListener_Impl::Dispose()
213cdf0e10cSrcweir {
214cdf0e10cSrcweir mpDrawModel = 0;
215cdf0e10cSrcweir }
216cdf0e10cSrcweir
217cdf0e10cSrcweir //------------------------------------------------------------------------------
218cdf0e10cSrcweir struct SwShapeFunc
219cdf0e10cSrcweir {
operator ()SwShapeFunc220cdf0e10cSrcweir sal_Bool operator()( const SdrObject * p1,
221cdf0e10cSrcweir const SdrObject * p2) const
222cdf0e10cSrcweir {
223cdf0e10cSrcweir return p1 < p2;
224cdf0e10cSrcweir }
225cdf0e10cSrcweir };
226cdf0e10cSrcweir typedef ::std::map < const SdrObject *, uno::WeakReference < XAccessible >, SwShapeFunc > _SwAccessibleShapeMap_Impl;
227cdf0e10cSrcweir typedef ::std::pair < const SdrObject *, ::vos::ORef < ::accessibility::AccessibleShape > > SwAccessibleObjShape_Impl;
228cdf0e10cSrcweir
229cdf0e10cSrcweir class SwAccessibleShapeMap_Impl: public _SwAccessibleShapeMap_Impl
230cdf0e10cSrcweir
231cdf0e10cSrcweir {
232cdf0e10cSrcweir ::accessibility::AccessibleShapeTreeInfo maInfo;
233cdf0e10cSrcweir
234cdf0e10cSrcweir public:
235cdf0e10cSrcweir
236cdf0e10cSrcweir #ifdef DBG_UTIL
237cdf0e10cSrcweir sal_Bool mbLocked;
238cdf0e10cSrcweir #endif
SwAccessibleShapeMap_Impl(SwAccessibleMap * pMap)239cdf0e10cSrcweir SwAccessibleShapeMap_Impl( SwAccessibleMap *pMap )
240cdf0e10cSrcweir #ifdef DBG_UTIL
241cdf0e10cSrcweir : mbLocked( sal_False )
242cdf0e10cSrcweir #endif
243cdf0e10cSrcweir {
244cdf0e10cSrcweir maInfo.SetSdrView( pMap->GetShell()->GetDrawView() );
245cdf0e10cSrcweir maInfo.SetWindow( pMap->GetShell()->GetWin() );
246cdf0e10cSrcweir maInfo.SetViewForwarder( pMap );
247cdf0e10cSrcweir // --> OD 2005-08-08 #i52858# - method name changed
248cdf0e10cSrcweir uno::Reference < document::XEventBroadcaster > xModelBroadcaster =
249cdf0e10cSrcweir new SwDrawModellListener_Impl(
250cdf0e10cSrcweir pMap->GetShell()->getIDocumentDrawModelAccess()->GetOrCreateDrawModel() );
251cdf0e10cSrcweir // <--
252cdf0e10cSrcweir maInfo.SetControllerBroadcaster( xModelBroadcaster );
253cdf0e10cSrcweir }
254cdf0e10cSrcweir
255cdf0e10cSrcweir ~SwAccessibleShapeMap_Impl();
256cdf0e10cSrcweir
GetInfo() const257cdf0e10cSrcweir const ::accessibility::AccessibleShapeTreeInfo& GetInfo() const { return maInfo; }
258cdf0e10cSrcweir
259cdf0e10cSrcweir SwAccessibleObjShape_Impl *Copy( size_t& rSize,
260cdf0e10cSrcweir const SwFEShell *pFESh = 0,
261cdf0e10cSrcweir SwAccessibleObjShape_Impl **pSelShape = 0 ) const;
262cdf0e10cSrcweir };
263cdf0e10cSrcweir
~SwAccessibleShapeMap_Impl()264cdf0e10cSrcweir SwAccessibleShapeMap_Impl::~SwAccessibleShapeMap_Impl()
265cdf0e10cSrcweir {
266cdf0e10cSrcweir uno::Reference < document::XEventBroadcaster > xBrd( maInfo.GetControllerBroadcaster() );
267cdf0e10cSrcweir if( xBrd.is() )
268cdf0e10cSrcweir static_cast < SwDrawModellListener_Impl * >( xBrd.get() )->Dispose();
269cdf0e10cSrcweir }
270cdf0e10cSrcweir
271cdf0e10cSrcweir SwAccessibleObjShape_Impl
Copy(size_t & rSize,const SwFEShell * pFESh,SwAccessibleObjShape_Impl ** pSelStart) const272cdf0e10cSrcweir *SwAccessibleShapeMap_Impl::Copy(
273cdf0e10cSrcweir size_t& rSize, const SwFEShell *pFESh,
274cdf0e10cSrcweir SwAccessibleObjShape_Impl **pSelStart ) const
275cdf0e10cSrcweir {
276cdf0e10cSrcweir SwAccessibleObjShape_Impl *pShapes = 0;
277cdf0e10cSrcweir SwAccessibleObjShape_Impl *pSelShape = 0;
278cdf0e10cSrcweir
279cdf0e10cSrcweir sal_uInt16 nSelShapes = pFESh ? pFESh->IsObjSelected() : 0;
280cdf0e10cSrcweir rSize = size();
281cdf0e10cSrcweir
282cdf0e10cSrcweir if( rSize > 0 )
283cdf0e10cSrcweir {
284cdf0e10cSrcweir pShapes =
285cdf0e10cSrcweir new SwAccessibleObjShape_Impl[rSize];
286cdf0e10cSrcweir
287cdf0e10cSrcweir const_iterator aIter = begin();
288cdf0e10cSrcweir const_iterator aEndIter = end();
289cdf0e10cSrcweir
290cdf0e10cSrcweir SwAccessibleObjShape_Impl *pShape = pShapes;
291cdf0e10cSrcweir pSelShape = &(pShapes[rSize]);
292cdf0e10cSrcweir while( aIter != aEndIter )
293cdf0e10cSrcweir {
294cdf0e10cSrcweir const SdrObject *pObj = (*aIter).first;
295cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
296ca62e2c2SSteve Yin if( nSelShapes && pFESh &&pFESh->IsObjSelected( *pObj ) )
297cdf0e10cSrcweir {
298cdf0e10cSrcweir // selected objects are inserted from the back
299cdf0e10cSrcweir --pSelShape;
300cdf0e10cSrcweir pSelShape->first = pObj;
301cdf0e10cSrcweir pSelShape->second =
302cdf0e10cSrcweir static_cast < ::accessibility::AccessibleShape* >(
303cdf0e10cSrcweir xAcc.get() );
304cdf0e10cSrcweir --nSelShapes;
305cdf0e10cSrcweir }
306cdf0e10cSrcweir else
307cdf0e10cSrcweir {
308cdf0e10cSrcweir pShape->first = pObj;
309cdf0e10cSrcweir pShape->second =
310cdf0e10cSrcweir static_cast < ::accessibility::AccessibleShape* >(
311cdf0e10cSrcweir xAcc.get() );
312cdf0e10cSrcweir ++pShape;
313cdf0e10cSrcweir }
314cdf0e10cSrcweir ++aIter;
315cdf0e10cSrcweir }
316cdf0e10cSrcweir ASSERT( pSelShape == pShape, "copying shapes went wrong!" );
317cdf0e10cSrcweir }
318cdf0e10cSrcweir
319cdf0e10cSrcweir if( pSelStart )
320cdf0e10cSrcweir *pSelStart = pSelShape;
321cdf0e10cSrcweir
322cdf0e10cSrcweir return pShapes;
323cdf0e10cSrcweir }
324cdf0e10cSrcweir
325cdf0e10cSrcweir //------------------------------------------------------------------------------
326cdf0e10cSrcweir struct SwAccessibleEvent_Impl
327cdf0e10cSrcweir {
328cdf0e10cSrcweir public:
329cdf0e10cSrcweir enum EventType { CARET_OR_STATES,
330cdf0e10cSrcweir INVALID_CONTENT,
331cdf0e10cSrcweir POS_CHANGED,
332cdf0e10cSrcweir CHILD_POS_CHANGED,
333cdf0e10cSrcweir SHAPE_SELECTION,
334cdf0e10cSrcweir DISPOSE,
335cdf0e10cSrcweir INVALID_ATTR };
336cdf0e10cSrcweir
337cdf0e10cSrcweir private:
338cdf0e10cSrcweir SwRect maOldBox; // the old bounds for CHILD_POS_CHANGED
339cdf0e10cSrcweir // and POS_CHANGED
340cdf0e10cSrcweir uno::WeakReference < XAccessible > mxAcc; // The object that fires the event
341cdf0e10cSrcweir SwAccessibleChild maFrmOrObj; // the child for CHILD_POS_CHANGED and
342cdf0e10cSrcweir // the same as xAcc for any other
343cdf0e10cSrcweir // event type
344cdf0e10cSrcweir EventType meType; // The event type
345cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - use new type definition for <mnStates>
346cdf0e10cSrcweir tAccessibleStates mnStates; // check states or update caret pos
347cdf0e10cSrcweir // <--
348cdf0e10cSrcweir
349cdf0e10cSrcweir SwAccessibleEvent_Impl& operator==( const SwAccessibleEvent_Impl& );
350cdf0e10cSrcweir
351ca62e2c2SSteve Yin public:
352ca62e2c2SSteve Yin const SwFrm* mpParentFrm; // The object that fires the event
IsNoXaccParentFrmSwAccessibleEvent_Impl353ca62e2c2SSteve Yin sal_Bool IsNoXaccParentFrm() const
354ca62e2c2SSteve Yin {
355ca62e2c2SSteve Yin return CHILD_POS_CHANGED == meType && mpParentFrm != 0;
356ca62e2c2SSteve Yin }
GetxAccSwAccessibleEvent_Impl357ca62e2c2SSteve Yin uno::WeakReference < XAccessible > GetxAcc() const { return mxAcc;}
358cdf0e10cSrcweir public:
SwAccessibleEvent_ImplSwAccessibleEvent_Impl359cdf0e10cSrcweir SwAccessibleEvent_Impl( EventType eT,
360cdf0e10cSrcweir SwAccessibleContext *pA,
361cdf0e10cSrcweir const SwAccessibleChild& rFrmOrObj )
362cdf0e10cSrcweir : mxAcc( pA ),
363cdf0e10cSrcweir maFrmOrObj( rFrmOrObj ),
364cdf0e10cSrcweir meType( eT ),
365ca62e2c2SSteve Yin mnStates( 0 ),
366ca62e2c2SSteve Yin mpParentFrm( 0 )
367cdf0e10cSrcweir {}
368cdf0e10cSrcweir
SwAccessibleEvent_ImplSwAccessibleEvent_Impl369cdf0e10cSrcweir SwAccessibleEvent_Impl( EventType eT,
370cdf0e10cSrcweir const SwAccessibleChild& rFrmOrObj )
371cdf0e10cSrcweir : maFrmOrObj( rFrmOrObj ),
372cdf0e10cSrcweir meType( eT ),
373ca62e2c2SSteve Yin mnStates( 0 ),
374ca62e2c2SSteve Yin mpParentFrm( 0 )
375cdf0e10cSrcweir {
376cdf0e10cSrcweir ASSERT( SwAccessibleEvent_Impl::DISPOSE == meType,
377cdf0e10cSrcweir "wrong event constructor, DISPOSE only" );
378cdf0e10cSrcweir }
379cdf0e10cSrcweir
SwAccessibleEvent_ImplSwAccessibleEvent_Impl380cdf0e10cSrcweir SwAccessibleEvent_Impl( EventType eT )
381cdf0e10cSrcweir : meType( eT ),
382ca62e2c2SSteve Yin mnStates( 0 ),
383ca62e2c2SSteve Yin mpParentFrm( 0 )
384cdf0e10cSrcweir {
385cdf0e10cSrcweir ASSERT( SwAccessibleEvent_Impl::SHAPE_SELECTION == meType,
386cdf0e10cSrcweir "wrong event constructor, SHAPE_SELECTION only" );
387cdf0e10cSrcweir }
388cdf0e10cSrcweir
SwAccessibleEvent_ImplSwAccessibleEvent_Impl389cdf0e10cSrcweir SwAccessibleEvent_Impl( EventType eT,
390cdf0e10cSrcweir SwAccessibleContext *pA,
391cdf0e10cSrcweir const SwAccessibleChild& rFrmOrObj,
392cdf0e10cSrcweir const SwRect& rR )
393cdf0e10cSrcweir : maOldBox( rR ),
394cdf0e10cSrcweir mxAcc( pA ),
395cdf0e10cSrcweir maFrmOrObj( rFrmOrObj ),
396cdf0e10cSrcweir meType( eT ),
397ca62e2c2SSteve Yin mnStates( 0 ),
398ca62e2c2SSteve Yin mpParentFrm( 0 )
399cdf0e10cSrcweir {
400cdf0e10cSrcweir ASSERT( SwAccessibleEvent_Impl::CHILD_POS_CHANGED == meType ||
401cdf0e10cSrcweir SwAccessibleEvent_Impl::POS_CHANGED == meType,
402cdf0e10cSrcweir "wrong event constructor, (CHILD_)POS_CHANGED only" );
403cdf0e10cSrcweir }
404cdf0e10cSrcweir
405cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - use new type definition for parameter <_nStates>
SwAccessibleEvent_ImplSwAccessibleEvent_Impl406cdf0e10cSrcweir SwAccessibleEvent_Impl( EventType eT,
407cdf0e10cSrcweir SwAccessibleContext *pA,
408cdf0e10cSrcweir const SwAccessibleChild& rFrmOrObj,
409cdf0e10cSrcweir const tAccessibleStates _nStates )
410cdf0e10cSrcweir : mxAcc( pA ),
411cdf0e10cSrcweir maFrmOrObj( rFrmOrObj ),
412cdf0e10cSrcweir meType( eT ),
413ca62e2c2SSteve Yin mnStates( _nStates ),
414ca62e2c2SSteve Yin mpParentFrm( 0 )
415cdf0e10cSrcweir {
416cdf0e10cSrcweir ASSERT( SwAccessibleEvent_Impl::CARET_OR_STATES == meType,
417cdf0e10cSrcweir "wrong event constructor, CARET_OR_STATES only" );
418cdf0e10cSrcweir }
419cdf0e10cSrcweir
SwAccessibleEvent_ImplSwAccessibleEvent_Impl420ca62e2c2SSteve Yin SwAccessibleEvent_Impl( EventType eT,
421ca62e2c2SSteve Yin const SwFrm *pParentFrm,
422ca62e2c2SSteve Yin const SwAccessibleChild& rFrmOrObj,
423ca62e2c2SSteve Yin const SwRect& rR ) :
424ca62e2c2SSteve Yin maOldBox( rR ),
425ca62e2c2SSteve Yin maFrmOrObj( rFrmOrObj ),
426ca62e2c2SSteve Yin meType( eT ),
427ca62e2c2SSteve Yin mnStates( 0 ),
428ca62e2c2SSteve Yin mpParentFrm( pParentFrm )
429ca62e2c2SSteve Yin {
430ca62e2c2SSteve Yin OSL_ENSURE( SwAccessibleEvent_Impl::CHILD_POS_CHANGED == meType,
431ca62e2c2SSteve Yin "wrong event constructor, CHILD_POS_CHANGED only" );
432ca62e2c2SSteve Yin }
433cdf0e10cSrcweir // <SetType(..)> only used in method <SwAccessibleMap::AppendEvent(..)>
SetTypeSwAccessibleEvent_Impl434cdf0e10cSrcweir inline void SetType( EventType eT )
435cdf0e10cSrcweir {
436cdf0e10cSrcweir meType = eT;
437cdf0e10cSrcweir }
GetTypeSwAccessibleEvent_Impl438cdf0e10cSrcweir inline EventType GetType() const
439cdf0e10cSrcweir {
440cdf0e10cSrcweir return meType;
441cdf0e10cSrcweir }
442cdf0e10cSrcweir
GetContextSwAccessibleEvent_Impl443cdf0e10cSrcweir inline ::vos::ORef < SwAccessibleContext > GetContext() const
444cdf0e10cSrcweir {
445cdf0e10cSrcweir uno::Reference < XAccessible > xTmp( mxAcc );
446cdf0e10cSrcweir ::vos::ORef < SwAccessibleContext > xAccImpl(
447cdf0e10cSrcweir static_cast<SwAccessibleContext*>( xTmp.get() ) );
448cdf0e10cSrcweir
449cdf0e10cSrcweir return xAccImpl;
450cdf0e10cSrcweir }
451cdf0e10cSrcweir
GetOldBoxSwAccessibleEvent_Impl452cdf0e10cSrcweir inline const SwRect& GetOldBox() const
453cdf0e10cSrcweir {
454cdf0e10cSrcweir return maOldBox;
455cdf0e10cSrcweir }
456cdf0e10cSrcweir // <SetOldBox(..)> only used in method <SwAccessibleMap::AppendEvent(..)>
SetOldBoxSwAccessibleEvent_Impl457cdf0e10cSrcweir inline void SetOldBox( const SwRect& rOldBox )
458cdf0e10cSrcweir {
459cdf0e10cSrcweir maOldBox = rOldBox;
460cdf0e10cSrcweir }
461cdf0e10cSrcweir
GetFrmOrObjSwAccessibleEvent_Impl462cdf0e10cSrcweir inline const SwAccessibleChild& GetFrmOrObj() const
463cdf0e10cSrcweir {
464cdf0e10cSrcweir return maFrmOrObj;
465cdf0e10cSrcweir }
466cdf0e10cSrcweir
467cdf0e10cSrcweir // <SetStates(..)> only used in method <SwAccessibleMap::AppendEvent(..)>
468cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - use new type definition for parameter <_nStates>
SetStatesSwAccessibleEvent_Impl469cdf0e10cSrcweir inline void SetStates( tAccessibleStates _nStates )
470cdf0e10cSrcweir {
471cdf0e10cSrcweir mnStates |= _nStates;
472cdf0e10cSrcweir }
473cdf0e10cSrcweir // <--
474cdf0e10cSrcweir
IsUpdateCursorPosSwAccessibleEvent_Impl475cdf0e10cSrcweir inline sal_Bool IsUpdateCursorPos() const
476cdf0e10cSrcweir {
477cdf0e10cSrcweir return (mnStates & ACC_STATE_CARET) != 0;
478cdf0e10cSrcweir }
IsInvalidateStatesSwAccessibleEvent_Impl479cdf0e10cSrcweir inline sal_Bool IsInvalidateStates() const
480cdf0e10cSrcweir {
481cdf0e10cSrcweir return (mnStates & ACC_STATE_MASK) != 0;
482cdf0e10cSrcweir }
IsInvalidateRelationSwAccessibleEvent_Impl483cdf0e10cSrcweir inline sal_Bool IsInvalidateRelation() const
484cdf0e10cSrcweir {
485cdf0e10cSrcweir return (mnStates & ACC_STATE_RELATION_MASK) != 0;
486cdf0e10cSrcweir }
487cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - new event TEXT_SELECTION_CHANGED
IsInvalidateTextSelectionSwAccessibleEvent_Impl488cdf0e10cSrcweir inline sal_Bool IsInvalidateTextSelection() const
489cdf0e10cSrcweir {
490cdf0e10cSrcweir return ( mnStates & ACC_STATE_TEXT_SELECTION_CHANGED ) != 0;
491cdf0e10cSrcweir }
492cdf0e10cSrcweir // <--
493cdf0e10cSrcweir // --> OD 2009-01-07 #i88069# - new event TEXT_ATTRIBUTE_CHANGED
IsInvalidateTextAttrsSwAccessibleEvent_Impl494cdf0e10cSrcweir inline sal_Bool IsInvalidateTextAttrs() const
495cdf0e10cSrcweir {
496cdf0e10cSrcweir return ( mnStates & ACC_STATE_TEXT_ATTRIBUTE_CHANGED ) != 0;
497cdf0e10cSrcweir }
498cdf0e10cSrcweir // <--
499cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - use new type definition <tAccessibleStates>
500cdf0e10cSrcweir // for return value
GetStatesSwAccessibleEvent_Impl501cdf0e10cSrcweir inline tAccessibleStates GetStates() const
502cdf0e10cSrcweir {
503cdf0e10cSrcweir return mnStates & ACC_STATE_MASK;
504cdf0e10cSrcweir }
505cdf0e10cSrcweir // <--
506cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - use new type definition <tAccessibleStates>
507cdf0e10cSrcweir // for return value
GetAllStatesSwAccessibleEvent_Impl508cdf0e10cSrcweir inline tAccessibleStates GetAllStates() const
509cdf0e10cSrcweir {
510cdf0e10cSrcweir return mnStates;
511cdf0e10cSrcweir }
512cdf0e10cSrcweir // <--
513cdf0e10cSrcweir };
514cdf0e10cSrcweir
515cdf0e10cSrcweir //------------------------------------------------------------------------------
516cdf0e10cSrcweir typedef ::std::list < SwAccessibleEvent_Impl > _SwAccessibleEventList_Impl;
517cdf0e10cSrcweir
518cdf0e10cSrcweir class SwAccessibleEventList_Impl: public _SwAccessibleEventList_Impl
519cdf0e10cSrcweir {
520cdf0e10cSrcweir sal_Bool mbFiring;
521cdf0e10cSrcweir
522cdf0e10cSrcweir public:
523cdf0e10cSrcweir
SwAccessibleEventList_Impl()524cdf0e10cSrcweir SwAccessibleEventList_Impl()
525cdf0e10cSrcweir : mbFiring( sal_False )
526cdf0e10cSrcweir {}
527cdf0e10cSrcweir
SetFiring()528cdf0e10cSrcweir inline void SetFiring()
529cdf0e10cSrcweir {
530cdf0e10cSrcweir mbFiring = sal_True;
531cdf0e10cSrcweir }
IsFiring() const532cdf0e10cSrcweir inline sal_Bool IsFiring() const
533cdf0e10cSrcweir {
534cdf0e10cSrcweir return mbFiring;
535cdf0e10cSrcweir }
536ca62e2c2SSteve Yin struct XAccisNULL
537ca62e2c2SSteve Yin {
operator ()SwAccessibleEventList_Impl::XAccisNULL538ca62e2c2SSteve Yin bool operator()(const SwAccessibleEvent_Impl& e)
539ca62e2c2SSteve Yin {
540ca62e2c2SSteve Yin return e.IsNoXaccParentFrm();
541ca62e2c2SSteve Yin }
542ca62e2c2SSteve Yin };
543ca62e2c2SSteve Yin void MoveInvalidXAccToEnd();
544cdf0e10cSrcweir };
545cdf0e10cSrcweir
MoveInvalidXAccToEnd()546ca62e2c2SSteve Yin void SwAccessibleEventList_Impl::MoveInvalidXAccToEnd()
547ca62e2c2SSteve Yin {
548ca62e2c2SSteve Yin int nSize = size();
549ca62e2c2SSteve Yin if (nSize < 2 )
550ca62e2c2SSteve Yin {
551ca62e2c2SSteve Yin return;
552ca62e2c2SSteve Yin }
553ca62e2c2SSteve Yin SwAccessibleEventList_Impl lstEvent;
554ca62e2c2SSteve Yin iterator li = begin();
555ca62e2c2SSteve Yin for ( ;li != end();)
556ca62e2c2SSteve Yin {
557ca62e2c2SSteve Yin SwAccessibleEvent_Impl e = *li;
558ca62e2c2SSteve Yin if (e.IsNoXaccParentFrm())
559ca62e2c2SSteve Yin {
560ca62e2c2SSteve Yin iterator liNext = li;
561ca62e2c2SSteve Yin ++liNext;
562ca62e2c2SSteve Yin erase(li);
563ca62e2c2SSteve Yin li = liNext;
564ca62e2c2SSteve Yin lstEvent.insert(lstEvent.end(),e);
565ca62e2c2SSteve Yin }
566ca62e2c2SSteve Yin else
567ca62e2c2SSteve Yin ++li;
568ca62e2c2SSteve Yin }
569ca62e2c2SSteve Yin OSL_ENSURE(size() + lstEvent.size() == nSize ,"");
570ca62e2c2SSteve Yin insert(end(),lstEvent.begin(),lstEvent.end());
571ca62e2c2SSteve Yin OSL_ENSURE(size() == nSize ,"");
572ca62e2c2SSteve Yin }
573cdf0e10cSrcweir //------------------------------------------------------------------------------
574cdf0e10cSrcweir // The shape list is filled if an accessible shape is destroyed. It
575cdf0e10cSrcweir // simply keeps a reference to the accessible shape's XShape. These
576cdf0e10cSrcweir // references are destroyed within the EndAction when firing events,
577cdf0e10cSrcweir // There are twp reason for this. First of all, a new accessible shape
578cdf0e10cSrcweir // for the XShape might be created soon. It's then cheaper if the XShape
579cdf0e10cSrcweir // still exists. The other reason are situations where an accessible shape
580cdf0e10cSrcweir // is destroyed within an SwFrmFmt::Modify. In this case, destryoing
581cdf0e10cSrcweir // the XShape at the same time (indirectly by destroying the accessible
582cdf0e10cSrcweir // shape) leads to an assert, because a client of the Modify is destroyed
583cdf0e10cSrcweir // within a Modify call.
584cdf0e10cSrcweir
585cdf0e10cSrcweir typedef ::std::list < uno::Reference < drawing::XShape > > _SwShapeList_Impl;
586cdf0e10cSrcweir
587cdf0e10cSrcweir class SwShapeList_Impl: public _SwShapeList_Impl
588cdf0e10cSrcweir {
589cdf0e10cSrcweir public:
590cdf0e10cSrcweir
SwShapeList_Impl()591cdf0e10cSrcweir SwShapeList_Impl() {}
592cdf0e10cSrcweir };
593cdf0e10cSrcweir
594cdf0e10cSrcweir
595cdf0e10cSrcweir //------------------------------------------------------------------------------
596cdf0e10cSrcweir struct SwAccessibleChildFunc
597cdf0e10cSrcweir {
operator ()SwAccessibleChildFunc598cdf0e10cSrcweir sal_Bool operator()( const SwAccessibleChild& r1,
599cdf0e10cSrcweir const SwAccessibleChild& r2 ) const
600cdf0e10cSrcweir {
601cdf0e10cSrcweir const void *p1 = r1.GetSwFrm()
602cdf0e10cSrcweir ? static_cast < const void * >( r1.GetSwFrm())
603cdf0e10cSrcweir : ( r1.GetDrawObject()
604cdf0e10cSrcweir ? static_cast < const void * >( r1.GetDrawObject() )
605cdf0e10cSrcweir : static_cast < const void * >( r1.GetWindow() ) );
606cdf0e10cSrcweir const void *p2 = r2.GetSwFrm()
607cdf0e10cSrcweir ? static_cast < const void * >( r2.GetSwFrm())
608cdf0e10cSrcweir : ( r2.GetDrawObject()
609cdf0e10cSrcweir ? static_cast < const void * >( r2.GetDrawObject() )
610cdf0e10cSrcweir : static_cast < const void * >( r2.GetWindow() ) );
611cdf0e10cSrcweir return p1 < p2;
612cdf0e10cSrcweir }
613cdf0e10cSrcweir };
614cdf0e10cSrcweir typedef ::std::map < SwAccessibleChild, SwAccessibleEventList_Impl::iterator,
615cdf0e10cSrcweir SwAccessibleChildFunc > _SwAccessibleEventMap_Impl;
616cdf0e10cSrcweir
617cdf0e10cSrcweir class SwAccessibleEventMap_Impl: public _SwAccessibleEventMap_Impl
618cdf0e10cSrcweir {
619cdf0e10cSrcweir };
620cdf0e10cSrcweir
621cdf0e10cSrcweir //------------------------------------------------------------------------------
622cdf0e10cSrcweir // --> OD 2005-12-13 #i27301# - map containing the accessible paragraph, which
623cdf0e10cSrcweir // have a selection. Needed to keep this information to submit corresponding
624cdf0e10cSrcweir // TEXT_SELECTION_CHANGED events.
625cdf0e10cSrcweir struct SwAccessibleParaSelection
626cdf0e10cSrcweir {
627cdf0e10cSrcweir xub_StrLen nStartOfSelection;
628cdf0e10cSrcweir xub_StrLen nEndOfSelection;
629cdf0e10cSrcweir
SwAccessibleParaSelectionSwAccessibleParaSelection630cdf0e10cSrcweir SwAccessibleParaSelection( const xub_StrLen _nStartOfSelection,
631cdf0e10cSrcweir const xub_StrLen _nEndOfSelection )
632cdf0e10cSrcweir : nStartOfSelection( _nStartOfSelection ),
633cdf0e10cSrcweir nEndOfSelection( _nEndOfSelection )
634cdf0e10cSrcweir {}
635cdf0e10cSrcweir };
636cdf0e10cSrcweir
637cdf0e10cSrcweir struct SwXAccWeakRefComp
638cdf0e10cSrcweir {
operator ()SwXAccWeakRefComp639cdf0e10cSrcweir sal_Bool operator()( const uno::WeakReference<XAccessible>& _rXAccWeakRef1,
640cdf0e10cSrcweir const uno::WeakReference<XAccessible>& _rXAccWeakRef2 ) const
641cdf0e10cSrcweir {
642cdf0e10cSrcweir return _rXAccWeakRef1.get() < _rXAccWeakRef2.get();
643cdf0e10cSrcweir }
644cdf0e10cSrcweir };
645cdf0e10cSrcweir
646cdf0e10cSrcweir typedef ::std::map< uno::WeakReference < XAccessible >,
647cdf0e10cSrcweir SwAccessibleParaSelection,
648cdf0e10cSrcweir SwXAccWeakRefComp > _SwAccessibleSelectedParas_Impl;
649cdf0e10cSrcweir
650cdf0e10cSrcweir class SwAccessibleSelectedParas_Impl: public _SwAccessibleSelectedParas_Impl
651cdf0e10cSrcweir {};
652cdf0e10cSrcweir // <--
653cdf0e10cSrcweir
654cdf0e10cSrcweir // helper class that stores preview data
655cdf0e10cSrcweir class SwAccPreviewData
656cdf0e10cSrcweir {
657cdf0e10cSrcweir typedef std::vector<Rectangle> Rectangles;
658cdf0e10cSrcweir Rectangles maPreviewRects;
659cdf0e10cSrcweir Rectangles maLogicRects;
660cdf0e10cSrcweir
661cdf0e10cSrcweir SwRect maVisArea;
662cdf0e10cSrcweir Fraction maScale;
663cdf0e10cSrcweir
664cdf0e10cSrcweir const SwPageFrm *mpSelPage;
665cdf0e10cSrcweir
666cdf0e10cSrcweir /** adjust logic page retangle to its visible part
667cdf0e10cSrcweir
668cdf0e10cSrcweir OD 17.01.2003 #103492#
669cdf0e10cSrcweir
670cdf0e10cSrcweir @author OD
671cdf0e10cSrcweir
672cdf0e10cSrcweir @param _iorLogicPgSwRect
673cdf0e10cSrcweir input/output parameter - reference to the logic page rectangle, which
674cdf0e10cSrcweir has to be adjusted.
675cdf0e10cSrcweir
676cdf0e10cSrcweir @param _rPrevwPgSwRect
677cdf0e10cSrcweir input parameter - constant reference to the corresponding preview page
678cdf0e10cSrcweir rectangle; needed to determine the visible part of the logic page rectangle.
679cdf0e10cSrcweir
680cdf0e10cSrcweir @param _rPrevwWinSize
681cdf0e10cSrcweir input paramter - constant reference to the preview window size in TWIP;
682cdf0e10cSrcweir needed to determine the visible part of the logic page rectangle
683cdf0e10cSrcweir */
684cdf0e10cSrcweir void AdjustLogicPgRectToVisibleArea( SwRect& _iorLogicPgSwRect,
685cdf0e10cSrcweir const SwRect& _rPrevwPgSwRect,
686cdf0e10cSrcweir const Size& _rPrevwWinSize );
687cdf0e10cSrcweir
688cdf0e10cSrcweir public:
689cdf0e10cSrcweir SwAccPreviewData();
690cdf0e10cSrcweir ~SwAccPreviewData();
691cdf0e10cSrcweir
692cdf0e10cSrcweir // OD 14.01.2003 #103492# - complete re-factoring of method due to new
693cdf0e10cSrcweir // page/print preview functionality.
694cdf0e10cSrcweir void Update( const SwAccessibleMap& rAccMap,
695cdf0e10cSrcweir const std::vector<PrevwPage*>& _rPrevwPages,
696cdf0e10cSrcweir const Fraction& _rScale,
697cdf0e10cSrcweir const SwPageFrm* _pSelectedPageFrm,
698cdf0e10cSrcweir const Size& _rPrevwWinSize );
699cdf0e10cSrcweir
700cdf0e10cSrcweir // OD 14.01.2003 #103492# - complete re-factoring of method due to new
701cdf0e10cSrcweir // page/print preview functionality.
702cdf0e10cSrcweir void InvalidateSelection( const SwPageFrm* _pSelectedPageFrm );
703cdf0e10cSrcweir
704cdf0e10cSrcweir const SwRect& GetVisArea() const;
705cdf0e10cSrcweir
706cdf0e10cSrcweir MapMode GetMapModeForPreview( ) const;
707cdf0e10cSrcweir
708cdf0e10cSrcweir /** Adjust the MapMode so that the preview page appears at the
709cdf0e10cSrcweir * proper position. rPoint identifies the page for which the
710cdf0e10cSrcweir * MapMode should be adjusted. If bFromPreview is true, rPoint is
711cdf0e10cSrcweir * a preview coordinate; else it's a document coordinate. */
712cdf0e10cSrcweir // OD 17.01.2003 #103492# - delete unused 3rd parameter.
713cdf0e10cSrcweir void AdjustMapMode( MapMode& rMapMode,
714cdf0e10cSrcweir const Point& rPoint ) const;
715cdf0e10cSrcweir
GetSelPage() const716cdf0e10cSrcweir inline const SwPageFrm *GetSelPage() const { return mpSelPage; }
717cdf0e10cSrcweir
718cdf0e10cSrcweir void DisposePage(const SwPageFrm *pPageFrm );
719cdf0e10cSrcweir };
720cdf0e10cSrcweir
SwAccPreviewData()721cdf0e10cSrcweir SwAccPreviewData::SwAccPreviewData() :
722cdf0e10cSrcweir mpSelPage( 0 )
723cdf0e10cSrcweir {
724cdf0e10cSrcweir }
725cdf0e10cSrcweir
~SwAccPreviewData()726cdf0e10cSrcweir SwAccPreviewData::~SwAccPreviewData()
727cdf0e10cSrcweir {
728cdf0e10cSrcweir }
729cdf0e10cSrcweir
730cdf0e10cSrcweir // OD 13.01.2003 #103492# - complete re-factoring of method due to new page/print
731cdf0e10cSrcweir // preview functionality.
Update(const SwAccessibleMap & rAccMap,const std::vector<PrevwPage * > & _rPrevwPages,const Fraction & _rScale,const SwPageFrm * _pSelectedPageFrm,const Size & _rPrevwWinSize)732cdf0e10cSrcweir void SwAccPreviewData::Update( const SwAccessibleMap& rAccMap,
733cdf0e10cSrcweir const std::vector<PrevwPage*>& _rPrevwPages,
734cdf0e10cSrcweir const Fraction& _rScale,
735cdf0e10cSrcweir const SwPageFrm* _pSelectedPageFrm,
736cdf0e10cSrcweir const Size& _rPrevwWinSize )
737cdf0e10cSrcweir {
738cdf0e10cSrcweir // store preview scaling, maximal preview page size and selected page
739cdf0e10cSrcweir maScale = _rScale;
740cdf0e10cSrcweir mpSelPage = _pSelectedPageFrm;
741cdf0e10cSrcweir
742cdf0e10cSrcweir // prepare loop on preview pages
743cdf0e10cSrcweir maPreviewRects.clear();
744cdf0e10cSrcweir maLogicRects.clear();
745cdf0e10cSrcweir SwAccessibleChild aPage;
746cdf0e10cSrcweir maVisArea.Clear();
747cdf0e10cSrcweir
748cdf0e10cSrcweir // loop on preview pages to calculate <maPreviewRects>, <maLogicRects> and
749cdf0e10cSrcweir // <maVisArea>
750cdf0e10cSrcweir for ( std::vector<PrevwPage*>::const_iterator aPageIter = _rPrevwPages.begin();
751cdf0e10cSrcweir aPageIter != _rPrevwPages.end();
752cdf0e10cSrcweir ++aPageIter )
753cdf0e10cSrcweir {
754cdf0e10cSrcweir aPage = (*aPageIter)->pPage;
755cdf0e10cSrcweir
756cdf0e10cSrcweir // add preview page rectangle to <maPreviewRects>
757cdf0e10cSrcweir Rectangle aPrevwPgRect( (*aPageIter)->aPrevwWinPos, (*aPageIter)->aPageSize );
758cdf0e10cSrcweir maPreviewRects.push_back( aPrevwPgRect );
759cdf0e10cSrcweir
760cdf0e10cSrcweir // add logic page rectangle to <maLogicRects>
761cdf0e10cSrcweir SwRect aLogicPgSwRect( aPage.GetBox( rAccMap ) );
762cdf0e10cSrcweir Rectangle aLogicPgRect( aLogicPgSwRect.SVRect() );
763cdf0e10cSrcweir maLogicRects.push_back( aLogicPgRect );
764cdf0e10cSrcweir // union visible area with visible part of logic page rectangle
765cdf0e10cSrcweir if ( (*aPageIter)->bVisible )
766cdf0e10cSrcweir {
767cdf0e10cSrcweir if ( !(*aPageIter)->pPage->IsEmptyPage() )
768cdf0e10cSrcweir {
769cdf0e10cSrcweir AdjustLogicPgRectToVisibleArea( aLogicPgSwRect,
770cdf0e10cSrcweir SwRect( aPrevwPgRect ),
771cdf0e10cSrcweir _rPrevwWinSize );
772cdf0e10cSrcweir }
773cdf0e10cSrcweir if ( maVisArea.IsEmpty() )
774cdf0e10cSrcweir maVisArea = aLogicPgSwRect;
775cdf0e10cSrcweir else
776cdf0e10cSrcweir maVisArea.Union( aLogicPgSwRect );
777cdf0e10cSrcweir }
778cdf0e10cSrcweir }
779cdf0e10cSrcweir }
780cdf0e10cSrcweir
781cdf0e10cSrcweir // OD 16.01.2003 #103492# - complete re-factoring of method due to new page/print
782cdf0e10cSrcweir // preview functionality.
InvalidateSelection(const SwPageFrm * _pSelectedPageFrm)783cdf0e10cSrcweir void SwAccPreviewData::InvalidateSelection( const SwPageFrm* _pSelectedPageFrm )
784cdf0e10cSrcweir {
785cdf0e10cSrcweir mpSelPage = _pSelectedPageFrm;
786cdf0e10cSrcweir ASSERT( mpSelPage, "selected page not found" );
787cdf0e10cSrcweir }
788cdf0e10cSrcweir
789cdf0e10cSrcweir struct ContainsPredicate
790cdf0e10cSrcweir {
791cdf0e10cSrcweir const Point& mrPoint;
ContainsPredicateContainsPredicate792cdf0e10cSrcweir ContainsPredicate( const Point& rPoint ) : mrPoint(rPoint) {}
operator ()ContainsPredicate793cdf0e10cSrcweir bool operator() ( const Rectangle& rRect ) const
794cdf0e10cSrcweir {
795cdf0e10cSrcweir return rRect.IsInside( mrPoint ) ? true : false;
796cdf0e10cSrcweir }
797cdf0e10cSrcweir };
798cdf0e10cSrcweir
GetVisArea() const799cdf0e10cSrcweir const SwRect& SwAccPreviewData::GetVisArea() const
800cdf0e10cSrcweir {
801cdf0e10cSrcweir return maVisArea;
802cdf0e10cSrcweir }
803cdf0e10cSrcweir
AdjustMapMode(MapMode & rMapMode,const Point & rPoint) const804cdf0e10cSrcweir void SwAccPreviewData::AdjustMapMode( MapMode& rMapMode,
805cdf0e10cSrcweir const Point& rPoint ) const
806cdf0e10cSrcweir {
807cdf0e10cSrcweir // adjust scale
808cdf0e10cSrcweir rMapMode.SetScaleX( maScale );
809cdf0e10cSrcweir rMapMode.SetScaleY( maScale );
810cdf0e10cSrcweir
811cdf0e10cSrcweir // find proper rectangle
812cdf0e10cSrcweir Rectangles::const_iterator aBegin = maLogicRects.begin();
813cdf0e10cSrcweir Rectangles::const_iterator aEnd = maLogicRects.end();
814cdf0e10cSrcweir Rectangles::const_iterator aFound = ::std::find_if( aBegin, aEnd,
815cdf0e10cSrcweir ContainsPredicate( rPoint ) );
816cdf0e10cSrcweir
817cdf0e10cSrcweir if( aFound != aEnd )
818cdf0e10cSrcweir {
819cdf0e10cSrcweir // found! set new origin
820cdf0e10cSrcweir Point aPoint = (maPreviewRects.begin() + (aFound - aBegin))->TopLeft();
821cdf0e10cSrcweir aPoint -= (maLogicRects.begin() + (aFound-aBegin))->TopLeft();
822cdf0e10cSrcweir rMapMode.SetOrigin( aPoint );
823cdf0e10cSrcweir }
824cdf0e10cSrcweir // else: don't adjust MapMode
825cdf0e10cSrcweir }
826cdf0e10cSrcweir
DisposePage(const SwPageFrm * pPageFrm)827cdf0e10cSrcweir void SwAccPreviewData::DisposePage(const SwPageFrm *pPageFrm )
828cdf0e10cSrcweir {
829cdf0e10cSrcweir if( mpSelPage == pPageFrm )
830cdf0e10cSrcweir mpSelPage = 0;
831cdf0e10cSrcweir }
832cdf0e10cSrcweir
833cdf0e10cSrcweir /** adjust logic page retangle to its visible part
834cdf0e10cSrcweir
835cdf0e10cSrcweir OD 17.01.2003 #103492#
836cdf0e10cSrcweir
837cdf0e10cSrcweir @author OD
838cdf0e10cSrcweir */
AdjustLogicPgRectToVisibleArea(SwRect & _iorLogicPgSwRect,const SwRect & _rPrevwPgSwRect,const Size & _rPrevwWinSize)839cdf0e10cSrcweir void SwAccPreviewData::AdjustLogicPgRectToVisibleArea(
840cdf0e10cSrcweir SwRect& _iorLogicPgSwRect,
841cdf0e10cSrcweir const SwRect& _rPrevwPgSwRect,
842cdf0e10cSrcweir const Size& _rPrevwWinSize )
843cdf0e10cSrcweir {
844cdf0e10cSrcweir // determine preview window rectangle
845cdf0e10cSrcweir const SwRect aPrevwWinSwRect( Point( 0, 0 ), _rPrevwWinSize );
846cdf0e10cSrcweir // calculate visible preview page rectangle
847cdf0e10cSrcweir SwRect aVisPrevwPgSwRect( _rPrevwPgSwRect );
848cdf0e10cSrcweir aVisPrevwPgSwRect.Intersection( aPrevwWinSwRect );
849cdf0e10cSrcweir // adjust logic page rectangle
850cdf0e10cSrcweir SwTwips nTmpDiff;
851cdf0e10cSrcweir // left
852cdf0e10cSrcweir nTmpDiff = aVisPrevwPgSwRect.Left() - _rPrevwPgSwRect.Left();
853cdf0e10cSrcweir if ( nTmpDiff > 0 )
854cdf0e10cSrcweir _iorLogicPgSwRect.Left( _iorLogicPgSwRect.Left() + nTmpDiff );
855cdf0e10cSrcweir // top
856cdf0e10cSrcweir nTmpDiff = aVisPrevwPgSwRect.Top() - _rPrevwPgSwRect.Top();
857cdf0e10cSrcweir if ( nTmpDiff > 0 )
858cdf0e10cSrcweir _iorLogicPgSwRect.Top( _iorLogicPgSwRect.Top() + nTmpDiff );
859cdf0e10cSrcweir // right
860cdf0e10cSrcweir nTmpDiff = _rPrevwPgSwRect.Right() - aVisPrevwPgSwRect.Right();
861cdf0e10cSrcweir if ( nTmpDiff > 0 )
862cdf0e10cSrcweir _iorLogicPgSwRect.Right( _iorLogicPgSwRect.Right() - nTmpDiff );
863cdf0e10cSrcweir // bottom
864cdf0e10cSrcweir nTmpDiff = _rPrevwPgSwRect.Bottom() - aVisPrevwPgSwRect.Bottom();
865cdf0e10cSrcweir if ( nTmpDiff > 0 )
866cdf0e10cSrcweir _iorLogicPgSwRect.Bottom( _iorLogicPgSwRect.Bottom() - nTmpDiff );
867cdf0e10cSrcweir }
868cdf0e10cSrcweir
869cdf0e10cSrcweir //------------------------------------------------------------------------------
AreInSameTable(const uno::Reference<XAccessible> & rAcc,const SwFrm * pFrm)870cdf0e10cSrcweir static sal_Bool AreInSameTable( const uno::Reference< XAccessible >& rAcc,
871cdf0e10cSrcweir const SwFrm *pFrm )
872cdf0e10cSrcweir {
873cdf0e10cSrcweir sal_Bool bRet = sal_False;
874cdf0e10cSrcweir
875cdf0e10cSrcweir if( pFrm && pFrm->IsCellFrm() && rAcc.is() )
876cdf0e10cSrcweir {
877cdf0e10cSrcweir // Is it in the same table? We check that
878cdf0e10cSrcweir // by comparing the last table frame in the
879cdf0e10cSrcweir // follow chain, because that's cheaper than
880cdf0e10cSrcweir // searching the first one.
881cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
882cdf0e10cSrcweir static_cast< SwAccessibleContext *>( rAcc.get() );
883cdf0e10cSrcweir if( pAccImpl->GetFrm()->IsCellFrm() )
884cdf0e10cSrcweir {
885cdf0e10cSrcweir const SwTabFrm *pTabFrm1 = pAccImpl->GetFrm()->FindTabFrm();
886cdf0e10cSrcweir while( pTabFrm1->GetFollow() )
887cdf0e10cSrcweir pTabFrm1 = pTabFrm1->GetFollow();
888cdf0e10cSrcweir
889cdf0e10cSrcweir const SwTabFrm *pTabFrm2 = pFrm->FindTabFrm();
890cdf0e10cSrcweir while( pTabFrm2->GetFollow() )
891cdf0e10cSrcweir pTabFrm2 = pTabFrm2->GetFollow();
892cdf0e10cSrcweir
893cdf0e10cSrcweir bRet = (pTabFrm1 == pTabFrm2);
894cdf0e10cSrcweir }
895cdf0e10cSrcweir }
896cdf0e10cSrcweir
897cdf0e10cSrcweir return bRet;
898cdf0e10cSrcweir }
899cdf0e10cSrcweir
FireEvent(const SwAccessibleEvent_Impl & rEvent)900cdf0e10cSrcweir void SwAccessibleMap::FireEvent( const SwAccessibleEvent_Impl& rEvent )
901cdf0e10cSrcweir {
902cdf0e10cSrcweir ::vos::ORef < SwAccessibleContext > xAccImpl( rEvent.GetContext() );
903ca62e2c2SSteve Yin if (!xAccImpl.isValid() && rEvent.mpParentFrm != 0 )
904ca62e2c2SSteve Yin {
905ca62e2c2SSteve Yin SwAccessibleContextMap_Impl::iterator aIter =
906ca62e2c2SSteve Yin mpFrmMap->find( rEvent.mpParentFrm );
907ca62e2c2SSteve Yin if( aIter != mpFrmMap->end() )
908ca62e2c2SSteve Yin {
909ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
910ca62e2c2SSteve Yin if (xAcc.is())
911ca62e2c2SSteve Yin {
912ca62e2c2SSteve Yin uno::Reference < XAccessibleContext > xContext(xAcc,uno::UNO_QUERY);
913ca62e2c2SSteve Yin if (xContext.is() && xContext->getAccessibleRole() == AccessibleRole::PARAGRAPH)
914ca62e2c2SSteve Yin {
915ca62e2c2SSteve Yin xAccImpl = static_cast< SwAccessibleContext *>( xAcc.get() );
916ca62e2c2SSteve Yin }
917ca62e2c2SSteve Yin }
918ca62e2c2SSteve Yin }
919ca62e2c2SSteve Yin }
920cdf0e10cSrcweir if( SwAccessibleEvent_Impl::SHAPE_SELECTION == rEvent.GetType() )
921cdf0e10cSrcweir {
922cdf0e10cSrcweir DoInvalidateShapeSelection();
923cdf0e10cSrcweir }
924cdf0e10cSrcweir else if( xAccImpl.isValid() && xAccImpl->GetFrm() )
925cdf0e10cSrcweir {
926cdf0e10cSrcweir // --> OD 2009-01-07 #i88069#
927cdf0e10cSrcweir if ( rEvent.GetType() != SwAccessibleEvent_Impl::DISPOSE &&
928cdf0e10cSrcweir rEvent.IsInvalidateTextAttrs() )
929cdf0e10cSrcweir {
930cdf0e10cSrcweir xAccImpl->InvalidateAttr();
931cdf0e10cSrcweir }
932cdf0e10cSrcweir // <--
933cdf0e10cSrcweir switch( rEvent.GetType() )
934cdf0e10cSrcweir {
935cdf0e10cSrcweir case SwAccessibleEvent_Impl::INVALID_CONTENT:
936cdf0e10cSrcweir xAccImpl->InvalidateContent();
937cdf0e10cSrcweir break;
938cdf0e10cSrcweir case SwAccessibleEvent_Impl::POS_CHANGED:
939cdf0e10cSrcweir xAccImpl->InvalidatePosOrSize( rEvent.GetOldBox() );
940cdf0e10cSrcweir break;
941cdf0e10cSrcweir case SwAccessibleEvent_Impl::CHILD_POS_CHANGED:
942cdf0e10cSrcweir xAccImpl->InvalidateChildPosOrSize( rEvent.GetFrmOrObj(),
943cdf0e10cSrcweir rEvent.GetOldBox() );
944cdf0e10cSrcweir break;
945cdf0e10cSrcweir case SwAccessibleEvent_Impl::DISPOSE:
946cdf0e10cSrcweir ASSERT( xAccImpl.isValid(),
947cdf0e10cSrcweir "dispose event has been stored" );
948cdf0e10cSrcweir break;
949cdf0e10cSrcweir // --> OD 2009-01-06 #i88069#
950cdf0e10cSrcweir case SwAccessibleEvent_Impl::INVALID_ATTR:
951cdf0e10cSrcweir // nothing to do here - handled above
952cdf0e10cSrcweir break;
953cdf0e10cSrcweir // <--
954cdf0e10cSrcweir default:
955cdf0e10cSrcweir break;
956cdf0e10cSrcweir }
957cdf0e10cSrcweir if( SwAccessibleEvent_Impl::DISPOSE != rEvent.GetType() )
958cdf0e10cSrcweir {
959cdf0e10cSrcweir if( rEvent.IsUpdateCursorPos() )
960cdf0e10cSrcweir xAccImpl->InvalidateCursorPos();
961cdf0e10cSrcweir if( rEvent.IsInvalidateStates() )
962cdf0e10cSrcweir xAccImpl->InvalidateStates( rEvent.GetStates() );
963cdf0e10cSrcweir if( rEvent.IsInvalidateRelation() )
964cdf0e10cSrcweir {
965cdf0e10cSrcweir // --> OD 2005-12-01 #i27138#
966cdf0e10cSrcweir // both events CONTENT_FLOWS_FROM_RELATION_CHANGED and
967cdf0e10cSrcweir // CONTENT_FLOWS_TO_RELATION_CHANGED are possible
968cdf0e10cSrcweir if ( rEvent.GetAllStates() & ACC_STATE_RELATION_FROM )
969cdf0e10cSrcweir {
970cdf0e10cSrcweir xAccImpl->InvalidateRelation(
971cdf0e10cSrcweir AccessibleEventId::CONTENT_FLOWS_FROM_RELATION_CHANGED );
972cdf0e10cSrcweir }
973cdf0e10cSrcweir if ( rEvent.GetAllStates() & ACC_STATE_RELATION_TO )
974cdf0e10cSrcweir {
975cdf0e10cSrcweir xAccImpl->InvalidateRelation(
976cdf0e10cSrcweir AccessibleEventId::CONTENT_FLOWS_TO_RELATION_CHANGED );
977cdf0e10cSrcweir }
978cdf0e10cSrcweir // <--
979cdf0e10cSrcweir }
980cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - submit event TEXT_SELECTION_CHANGED
981cdf0e10cSrcweir if ( rEvent.IsInvalidateTextSelection() )
982cdf0e10cSrcweir {
983cdf0e10cSrcweir xAccImpl->InvalidateTextSelection();
984cdf0e10cSrcweir }
985cdf0e10cSrcweir // <--
986cdf0e10cSrcweir }
987cdf0e10cSrcweir }
988cdf0e10cSrcweir }
989cdf0e10cSrcweir
AppendEvent(const SwAccessibleEvent_Impl & rEvent)990cdf0e10cSrcweir void SwAccessibleMap::AppendEvent( const SwAccessibleEvent_Impl& rEvent )
991cdf0e10cSrcweir {
992cdf0e10cSrcweir vos::OGuard aGuard( maEventMutex );
993cdf0e10cSrcweir
994cdf0e10cSrcweir if( !mpEvents )
995cdf0e10cSrcweir mpEvents = new SwAccessibleEventList_Impl;
996cdf0e10cSrcweir if( !mpEventMap )
997cdf0e10cSrcweir mpEventMap = new SwAccessibleEventMap_Impl;
998cdf0e10cSrcweir
999cdf0e10cSrcweir if( mpEvents->IsFiring() )
1000cdf0e10cSrcweir {
1001cdf0e10cSrcweir // While events are fired new ones are generated. They have to be fired
1002cdf0e10cSrcweir // now. This does not work for DISPOSE events!
1003cdf0e10cSrcweir ASSERT( rEvent.GetType() != SwAccessibleEvent_Impl::DISPOSE,
1004cdf0e10cSrcweir "dispose event while firing events" );
1005cdf0e10cSrcweir FireEvent( rEvent );
1006cdf0e10cSrcweir }
1007cdf0e10cSrcweir else
1008cdf0e10cSrcweir {
1009cdf0e10cSrcweir
1010cdf0e10cSrcweir SwAccessibleEventMap_Impl::iterator aIter =
1011cdf0e10cSrcweir mpEventMap->find( rEvent.GetFrmOrObj() );
1012cdf0e10cSrcweir if( aIter != mpEventMap->end() )
1013cdf0e10cSrcweir {
1014cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent( *(*aIter).second );
1015cdf0e10cSrcweir ASSERT( aEvent.GetType() != SwAccessibleEvent_Impl::DISPOSE,
1016cdf0e10cSrcweir "dispose events should not be stored" );
1017cdf0e10cSrcweir sal_Bool bAppendEvent = sal_True;
1018cdf0e10cSrcweir switch( rEvent.GetType() )
1019cdf0e10cSrcweir {
1020cdf0e10cSrcweir case SwAccessibleEvent_Impl::CARET_OR_STATES:
1021cdf0e10cSrcweir // A CARET_OR_STATES event is added to any other
1022cdf0e10cSrcweir // event only. It is broadcasted after any other event, so the
1023cdf0e10cSrcweir // event should be put to the back.
1024cdf0e10cSrcweir ASSERT( aEvent.GetType() != SwAccessibleEvent_Impl::CHILD_POS_CHANGED,
1025cdf0e10cSrcweir "invalid event combination" );
1026cdf0e10cSrcweir aEvent.SetStates( rEvent.GetAllStates() );
1027cdf0e10cSrcweir break;
1028cdf0e10cSrcweir case SwAccessibleEvent_Impl::INVALID_CONTENT:
1029cdf0e10cSrcweir // An INVALID_CONTENT event overwrites a CARET_OR_STATES
1030cdf0e10cSrcweir // event (but keeps its flags) and it is contained in a
1031cdf0e10cSrcweir // POS_CHANGED event.
1032cdf0e10cSrcweir // Therefor, the event's type has to be adapted and the event
1033cdf0e10cSrcweir // has to be put at the end.
1034cdf0e10cSrcweir ASSERT( aEvent.GetType() != SwAccessibleEvent_Impl::CHILD_POS_CHANGED,
1035cdf0e10cSrcweir "invalid event combination" );
1036cdf0e10cSrcweir if( aEvent.GetType() == SwAccessibleEvent_Impl::CARET_OR_STATES )
1037cdf0e10cSrcweir aEvent.SetType( SwAccessibleEvent_Impl::INVALID_CONTENT );
1038cdf0e10cSrcweir break;
1039cdf0e10cSrcweir case SwAccessibleEvent_Impl::POS_CHANGED:
1040cdf0e10cSrcweir // A pos changed event overwrites CARET_STATES (keeping its
1041cdf0e10cSrcweir // flags) as well as INVALID_CONTENT. The old box position
1042cdf0e10cSrcweir // has to be stored however if the old event is not a
1043cdf0e10cSrcweir // POS_CHANGED itself.
1044cdf0e10cSrcweir ASSERT( aEvent.GetType() != SwAccessibleEvent_Impl::CHILD_POS_CHANGED,
1045cdf0e10cSrcweir "invalid event combination" );
1046cdf0e10cSrcweir if( aEvent.GetType() != SwAccessibleEvent_Impl::POS_CHANGED )
1047cdf0e10cSrcweir aEvent.SetOldBox( rEvent.GetOldBox() );
1048cdf0e10cSrcweir aEvent.SetType( SwAccessibleEvent_Impl::POS_CHANGED );
1049cdf0e10cSrcweir break;
1050cdf0e10cSrcweir case SwAccessibleEvent_Impl::CHILD_POS_CHANGED:
1051cdf0e10cSrcweir // CHILD_POS_CHANGED events can only follow CHILD_POS_CHANGED
1052cdf0e10cSrcweir // events. The only action that needs to be done again is
1053cdf0e10cSrcweir // to put the old event to the back. The new one cannot be used,
1054cdf0e10cSrcweir // because we are interested in the old frame bounds.
1055cdf0e10cSrcweir ASSERT( aEvent.GetType() == SwAccessibleEvent_Impl::CHILD_POS_CHANGED,
1056cdf0e10cSrcweir "invalid event combination" );
1057cdf0e10cSrcweir break;
1058cdf0e10cSrcweir case SwAccessibleEvent_Impl::SHAPE_SELECTION:
1059cdf0e10cSrcweir ASSERT( aEvent.GetType() == SwAccessibleEvent_Impl::SHAPE_SELECTION,
1060cdf0e10cSrcweir "invalid event combination" );
1061cdf0e10cSrcweir break;
1062cdf0e10cSrcweir case SwAccessibleEvent_Impl::DISPOSE:
1063cdf0e10cSrcweir // DISPOSE events overwrite all others. They are not stored
1064cdf0e10cSrcweir // but executed immediatly to avoid broadcasting of
1065cdf0e10cSrcweir // defunctional objects. So what needs to be done here is to
1066cdf0e10cSrcweir // remove all events for the frame in question.
1067cdf0e10cSrcweir bAppendEvent = sal_False;
1068cdf0e10cSrcweir break;
1069cdf0e10cSrcweir // --> OD 2009-01-06 #i88069#
1070cdf0e10cSrcweir case SwAccessibleEvent_Impl::INVALID_ATTR:
1071cdf0e10cSrcweir ASSERT( aEvent.GetType() == SwAccessibleEvent_Impl::INVALID_ATTR,
1072cdf0e10cSrcweir "invalid event combination" );
1073cdf0e10cSrcweir break;
1074cdf0e10cSrcweir // <--
1075cdf0e10cSrcweir }
1076cdf0e10cSrcweir if( bAppendEvent )
1077cdf0e10cSrcweir {
1078cdf0e10cSrcweir mpEvents->erase( (*aIter).second );
1079cdf0e10cSrcweir (*aIter).second = mpEvents->insert( mpEvents->end(), aEvent );
1080cdf0e10cSrcweir }
1081cdf0e10cSrcweir else
1082cdf0e10cSrcweir {
1083cdf0e10cSrcweir mpEvents->erase( (*aIter).second );
1084cdf0e10cSrcweir mpEventMap->erase( aIter );
1085cdf0e10cSrcweir }
1086cdf0e10cSrcweir }
1087cdf0e10cSrcweir else if( SwAccessibleEvent_Impl::DISPOSE != rEvent.GetType() )
1088cdf0e10cSrcweir {
1089cdf0e10cSrcweir SwAccessibleEventMap_Impl::value_type aEntry( rEvent.GetFrmOrObj(),
1090cdf0e10cSrcweir mpEvents->insert( mpEvents->end(), rEvent ) );
1091cdf0e10cSrcweir mpEventMap->insert( aEntry );
1092cdf0e10cSrcweir }
1093cdf0e10cSrcweir }
1094cdf0e10cSrcweir }
1095cdf0e10cSrcweir
InvalidateCursorPosition(const uno::Reference<XAccessible> & rAcc)1096cdf0e10cSrcweir void SwAccessibleMap::InvalidateCursorPosition(
1097cdf0e10cSrcweir const uno::Reference< XAccessible >& rAcc )
1098cdf0e10cSrcweir {
1099cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
1100cdf0e10cSrcweir static_cast< SwAccessibleContext *>( rAcc.get() );
1101cdf0e10cSrcweir ASSERT( pAccImpl, "no caret context" );
1102cdf0e10cSrcweir ASSERT( pAccImpl->GetFrm(), "caret context is disposed" );
1103cdf0e10cSrcweir if( GetShell()->ActionPend() )
1104cdf0e10cSrcweir {
1105cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent( SwAccessibleEvent_Impl::CARET_OR_STATES,
1106cdf0e10cSrcweir pAccImpl,
1107cdf0e10cSrcweir SwAccessibleChild(pAccImpl->GetFrm()),
1108cdf0e10cSrcweir ACC_STATE_CARET );
1109cdf0e10cSrcweir AppendEvent( aEvent );
1110cdf0e10cSrcweir }
1111cdf0e10cSrcweir else
1112cdf0e10cSrcweir {
1113cdf0e10cSrcweir FireEvents();
1114cdf0e10cSrcweir // While firing events the current frame might have
1115cdf0e10cSrcweir // been disposed because it moved out of the vis area.
1116cdf0e10cSrcweir // Setting the cursor for such frames is useless and even
1117cdf0e10cSrcweir // causes asserts.
1118cdf0e10cSrcweir if( pAccImpl->GetFrm() )
1119cdf0e10cSrcweir pAccImpl->InvalidateCursorPos();
1120cdf0e10cSrcweir }
1121cdf0e10cSrcweir }
1122cdf0e10cSrcweir
InvalidateShapeSelection()1123cdf0e10cSrcweir void SwAccessibleMap::InvalidateShapeSelection()
1124cdf0e10cSrcweir {
1125cdf0e10cSrcweir if( GetShell()->ActionPend() )
1126cdf0e10cSrcweir {
1127cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent(
1128cdf0e10cSrcweir SwAccessibleEvent_Impl::SHAPE_SELECTION );
1129cdf0e10cSrcweir AppendEvent( aEvent );
1130cdf0e10cSrcweir }
1131cdf0e10cSrcweir else
1132cdf0e10cSrcweir {
1133cdf0e10cSrcweir FireEvents();
1134cdf0e10cSrcweir DoInvalidateShapeSelection();
1135cdf0e10cSrcweir }
1136cdf0e10cSrcweir }
1137ca62e2c2SSteve Yin //This method should implement the following functions:
1138ca62e2c2SSteve Yin //1.find the shape objects and set the selected state.
1139ca62e2c2SSteve Yin //2.find the Swframe objects and set the selected state.
1140ca62e2c2SSteve Yin //3.find the paragraph objects and set the selected state.
InvalidateShapeInParaSelection()1141ca62e2c2SSteve Yin void SwAccessibleMap::InvalidateShapeInParaSelection()
1142ca62e2c2SSteve Yin {
1143ca62e2c2SSteve Yin SwAccessibleObjShape_Impl *pShapes = 0;
1144ca62e2c2SSteve Yin SwAccessibleObjShape_Impl *pSelShape = 0;
1145ca62e2c2SSteve Yin size_t nShapes = 0;
1146ca62e2c2SSteve Yin
1147ca62e2c2SSteve Yin const ViewShell *pVSh = GetShell();
1148ca62e2c2SSteve Yin const SwFEShell *pFESh = pVSh->ISA( SwFEShell ) ?
1149ca62e2c2SSteve Yin static_cast< const SwFEShell * >( pVSh ) : 0;
11504d7c9de0SHerbert Dürr SwPaM* pCrsr = pFESh ? pFESh->GetCrsr( sal_False /* ??? */ ) : NULL;
1151ca62e2c2SSteve Yin //sal_uInt16 nSelShapes = pFESh ? pFESh->IsObjSelected() : 0;
1152ca62e2c2SSteve Yin
1153ca62e2c2SSteve Yin {
1154ca62e2c2SSteve Yin vos::OGuard aGuard( maMutex );
1155ca62e2c2SSteve Yin if( mpShapeMap )
1156ca62e2c2SSteve Yin pShapes = mpShapeMap->Copy( nShapes, pFESh, &pSelShape );
1157ca62e2c2SSteve Yin }
1158ca62e2c2SSteve Yin
1159ca62e2c2SSteve Yin sal_Bool bIsSelAll =IsDocumentSelAll();
1160ca62e2c2SSteve Yin
1161ca62e2c2SSteve Yin if( mpShapeMap )
1162ca62e2c2SSteve Yin {
1163ca62e2c2SSteve Yin //Checked for shapes.
1164ca62e2c2SSteve Yin _SwAccessibleShapeMap_Impl::const_iterator aIter = mpShapeMap->begin();
1165ca62e2c2SSteve Yin _SwAccessibleShapeMap_Impl::const_iterator aEndIter = mpShapeMap->end();
1166ca62e2c2SSteve Yin ::vos::ORef< SwAccessibleContext > xParentAccImpl;
1167ca62e2c2SSteve Yin
1168ca62e2c2SSteve Yin if( bIsSelAll)
1169ca62e2c2SSteve Yin {
1170ca62e2c2SSteve Yin while( aIter != aEndIter )
1171ca62e2c2SSteve Yin {
1172ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1173ca62e2c2SSteve Yin if( xAcc.is() )
1174ca62e2c2SSteve Yin (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->SetState( AccessibleStateType::SELECTED );
1175ca62e2c2SSteve Yin
1176ca62e2c2SSteve Yin ++aIter;
1177ca62e2c2SSteve Yin }
1178ca62e2c2SSteve Yin }
1179ca62e2c2SSteve Yin else
1180ca62e2c2SSteve Yin {
1181ca62e2c2SSteve Yin while( aIter != aEndIter )
1182ca62e2c2SSteve Yin {
1183ca62e2c2SSteve Yin sal_Bool bChanged = sal_False;
1184ca62e2c2SSteve Yin sal_Bool bMarked = sal_False;
1185ca62e2c2SSteve Yin SwAccessibleChild pFrm( (*aIter).first );
1186ca62e2c2SSteve Yin
1187ca62e2c2SSteve Yin const SwFrmFmt *pFrmFmt = (*aIter).first ? ::FindFrmFmt( (*aIter).first ) : 0;
1188ca62e2c2SSteve Yin if( !pFrmFmt ) { ++aIter; continue; }
1189ca62e2c2SSteve Yin const SwFmtAnchor& pAnchor = pFrmFmt->GetAnchor();
1190ca62e2c2SSteve Yin const SwPosition *pPos = pAnchor.GetCntntAnchor();
1191ca62e2c2SSteve Yin
1192ca62e2c2SSteve Yin if(pAnchor.GetAnchorId() == FLY_AT_PAGE)
1193ca62e2c2SSteve Yin {
1194ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1195ca62e2c2SSteve Yin if(xAcc.is())
1196ca62e2c2SSteve Yin (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->ResetState( AccessibleStateType::SELECTED );
1197ca62e2c2SSteve Yin
1198ca62e2c2SSteve Yin ++aIter; continue;
1199ca62e2c2SSteve Yin }
1200ca62e2c2SSteve Yin
1201ca62e2c2SSteve Yin if( !pPos ) { ++aIter; continue; }
1202ca62e2c2SSteve Yin if( pPos->nNode.GetNode().GetTxtNode() )
1203ca62e2c2SSteve Yin {
1204ca62e2c2SSteve Yin int pIndex = pPos->nContent.GetIndex();
1205ca62e2c2SSteve Yin SwPaM* pTmpCrsr = pCrsr;
1206ca62e2c2SSteve Yin if( pTmpCrsr != NULL )
1207ca62e2c2SSteve Yin {
1208ca62e2c2SSteve Yin const SwTxtNode* pNode = pPos->nNode.GetNode().GetTxtNode();
1209ca62e2c2SSteve Yin sal_uLong nHere = pNode->GetIndex();
1210ca62e2c2SSteve Yin
1211ca62e2c2SSteve Yin do
1212ca62e2c2SSteve Yin {
1213ca62e2c2SSteve Yin // ignore, if no mark
1214ca62e2c2SSteve Yin if( pTmpCrsr->HasMark() )
1215ca62e2c2SSteve Yin {
1216ca62e2c2SSteve Yin bMarked = sal_True;
1217ca62e2c2SSteve Yin // check whether nHere is 'inside' pCrsr
1218ca62e2c2SSteve Yin SwPosition* pStart = pTmpCrsr->Start();
1219ca62e2c2SSteve Yin sal_uLong nStartIndex = pStart->nNode.GetIndex();
1220ca62e2c2SSteve Yin SwPosition* pEnd = pTmpCrsr->End();
1221ca62e2c2SSteve Yin sal_uLong nEndIndex = pEnd->nNode.GetIndex();
1222ca62e2c2SSteve Yin if( ( nHere >= nStartIndex ) && (nHere <= nEndIndex) )
1223ca62e2c2SSteve Yin {
1224ca62e2c2SSteve Yin if( pAnchor.GetAnchorId() == FLY_AS_CHAR )
1225ca62e2c2SSteve Yin {
1226ca62e2c2SSteve Yin if( ( (nHere == nStartIndex) && (pIndex >= pStart->nContent.GetIndex()) || (nHere > nStartIndex) )
1227ca62e2c2SSteve Yin &&( (nHere == nEndIndex) && (pIndex < pEnd->nContent.GetIndex()) || (nHere < nEndIndex) ) )
1228ca62e2c2SSteve Yin {
1229ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1230ca62e2c2SSteve Yin if( xAcc.is() )
1231ca62e2c2SSteve Yin bChanged = (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->SetState( AccessibleStateType::SELECTED );
1232ca62e2c2SSteve Yin }
1233ca62e2c2SSteve Yin else
1234ca62e2c2SSteve Yin {
1235ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1236ca62e2c2SSteve Yin if( xAcc.is() )
1237ca62e2c2SSteve Yin bChanged = (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->ResetState( AccessibleStateType::SELECTED );
1238ca62e2c2SSteve Yin }
1239ca62e2c2SSteve Yin }
1240ca62e2c2SSteve Yin else if( pAnchor.GetAnchorId() == FLY_AT_PARA )
1241ca62e2c2SSteve Yin {
1242ca62e2c2SSteve Yin if( ((nHere > nStartIndex) || pStart->nContent.GetIndex() ==0 )
1243ca62e2c2SSteve Yin && (nHere < nEndIndex ) )
1244ca62e2c2SSteve Yin {
1245ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1246ca62e2c2SSteve Yin if( xAcc.is() )
1247ca62e2c2SSteve Yin bChanged = (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->SetState( AccessibleStateType::SELECTED );
1248ca62e2c2SSteve Yin }
1249ca62e2c2SSteve Yin else
1250ca62e2c2SSteve Yin {
1251ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1252ca62e2c2SSteve Yin if(xAcc.is())
1253ca62e2c2SSteve Yin bChanged = (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->ResetState( AccessibleStateType::SELECTED );
1254ca62e2c2SSteve Yin }
1255ca62e2c2SSteve Yin }
1256ca62e2c2SSteve Yin }
1257ca62e2c2SSteve Yin }
1258ca62e2c2SSteve Yin // next PaM in ring
1259ca62e2c2SSteve Yin pTmpCrsr = static_cast<SwPaM*>( pTmpCrsr->GetNext() );
1260ca62e2c2SSteve Yin }
1261ca62e2c2SSteve Yin while( pTmpCrsr != pCrsr );
1262ca62e2c2SSteve Yin }
1263ca62e2c2SSteve Yin if( !bMarked )
1264ca62e2c2SSteve Yin {
1265ca62e2c2SSteve Yin SwAccessibleObjShape_Impl *pShape = pShapes;
1266ca62e2c2SSteve Yin size_t nNumShapes = nShapes;
1267ca62e2c2SSteve Yin while( nNumShapes )
1268ca62e2c2SSteve Yin {
1269ca62e2c2SSteve Yin if( pShape < pSelShape && (pShape->first==(*aIter).first) )
1270ca62e2c2SSteve Yin {
1271ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
1272ca62e2c2SSteve Yin if(xAcc.is())
1273ca62e2c2SSteve Yin bChanged = (static_cast < ::accessibility::AccessibleShape* >(xAcc.get()))->ResetState( AccessibleStateType::SELECTED );
1274ca62e2c2SSteve Yin }
1275ca62e2c2SSteve Yin --nNumShapes;
1276ca62e2c2SSteve Yin ++pShape;
1277ca62e2c2SSteve Yin }
1278ca62e2c2SSteve Yin }
1279ca62e2c2SSteve Yin }
1280ca62e2c2SSteve Yin ++aIter;
1281ca62e2c2SSteve Yin }//while( aIter != aEndIter )
1282ca62e2c2SSteve Yin }//else
1283ca62e2c2SSteve Yin }
1284ca62e2c2SSteve Yin
1285ca62e2c2SSteve Yin //Checked for FlyFrm
1286ca62e2c2SSteve Yin SwAccessibleContextMap_Impl::iterator aIter = mpFrmMap->begin();
1287ca62e2c2SSteve Yin while( aIter != mpFrmMap->end() )
1288ca62e2c2SSteve Yin {
1289ca62e2c2SSteve Yin const SwFrm *pFrm = (*aIter).first;
1290ca62e2c2SSteve Yin if(pFrm->IsFlyFrm())
1291ca62e2c2SSteve Yin {
1292ca62e2c2SSteve Yin sal_Bool bFrmChanged = sal_False;
1293ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc = (*aIter).second;
1294ca62e2c2SSteve Yin
1295ca62e2c2SSteve Yin if(xAcc.is())
1296ca62e2c2SSteve Yin {
1297ca62e2c2SSteve Yin SwAccessibleFrameBase *pAccFrame = (static_cast< SwAccessibleFrameBase * >(xAcc.get()));
1298ca62e2c2SSteve Yin bFrmChanged = pAccFrame->SetSelectedState( sal_True );
1299ca62e2c2SSteve Yin if (bFrmChanged)
1300ca62e2c2SSteve Yin {
1301ca62e2c2SSteve Yin const SwFlyFrm *pFlyFrm = static_cast< const SwFlyFrm * >( pFrm );
1302ca62e2c2SSteve Yin const SwFrmFmt *pFrmFmt = pFlyFrm->GetFmt();
1303ca62e2c2SSteve Yin if (pFrmFmt)
1304ca62e2c2SSteve Yin {
1305ca62e2c2SSteve Yin const SwFmtAnchor& pAnchor = pFrmFmt->GetAnchor();
1306ca62e2c2SSteve Yin if( pAnchor.GetAnchorId() == FLY_AS_CHAR )
1307ca62e2c2SSteve Yin {
1308ca62e2c2SSteve Yin uno::Reference< XAccessible > xAccParent = pAccFrame->getAccessibleParent();
1309ca62e2c2SSteve Yin if (xAccParent.is())
1310ca62e2c2SSteve Yin {
1311ca62e2c2SSteve Yin uno::Reference< XAccessibleContext > xAccContext = xAccParent->getAccessibleContext();
1312ca62e2c2SSteve Yin if(xAccContext.is() && xAccContext->getAccessibleRole() == AccessibleRole::PARAGRAPH)
1313ca62e2c2SSteve Yin {
1314ca62e2c2SSteve Yin SwAccessibleParagraph* pAccPara = static_cast< SwAccessibleParagraph *>(xAccContext.get());
1315ca62e2c2SSteve Yin if(pAccFrame->IsSeletedInDoc())
1316ca62e2c2SSteve Yin {
1317ca62e2c2SSteve Yin m_setParaAdd.insert(pAccPara);
1318ca62e2c2SSteve Yin }
1319ca62e2c2SSteve Yin else if(m_setParaAdd.count(pAccPara) == 0)
1320ca62e2c2SSteve Yin {
1321ca62e2c2SSteve Yin m_setParaRemove.insert(pAccPara);
1322ca62e2c2SSteve Yin }
1323ca62e2c2SSteve Yin }
1324ca62e2c2SSteve Yin }
1325ca62e2c2SSteve Yin }
1326ca62e2c2SSteve Yin }
1327ca62e2c2SSteve Yin }
1328ca62e2c2SSteve Yin }
1329ca62e2c2SSteve Yin }
1330ca62e2c2SSteve Yin ++aIter;
1331ca62e2c2SSteve Yin }
1332ca62e2c2SSteve Yin typedef std::vector< SwAccessibleContext* > VEC_PARA;
1333ca62e2c2SSteve Yin VEC_PARA vecAdd;
1334ca62e2c2SSteve Yin VEC_PARA vecRemove;
1335ca62e2c2SSteve Yin //Checked for Paras.
1336ca62e2c2SSteve Yin SwPaM* pTmpCrsr = pCrsr;
1337ca62e2c2SSteve Yin sal_Bool bMarkChanged = sal_False;
1338ca62e2c2SSteve Yin SwAccessibleContextMap_Impl mapTemp;
1339ca62e2c2SSteve Yin if( pTmpCrsr != NULL )
1340ca62e2c2SSteve Yin {
1341ca62e2c2SSteve Yin do
1342ca62e2c2SSteve Yin {
1343ca62e2c2SSteve Yin if( pTmpCrsr->HasMark() )
1344ca62e2c2SSteve Yin {
1345ca62e2c2SSteve Yin SwNodeIndex nStartIndex( pTmpCrsr->Start()->nNode );
1346ca62e2c2SSteve Yin SwNodeIndex nEndIndex( pTmpCrsr->End()->nNode );
1347ca62e2c2SSteve Yin while(nStartIndex <= nEndIndex)
1348ca62e2c2SSteve Yin {
1349ca62e2c2SSteve Yin SwFrm *pFrm = NULL;
1350ca62e2c2SSteve Yin if(nStartIndex.GetNode().IsCntntNode())
1351ca62e2c2SSteve Yin {
1352ca62e2c2SSteve Yin SwCntntNode* pCNd = (SwCntntNode*)&(nStartIndex.GetNode());
1353ca62e2c2SSteve Yin SwClientIter aClientIter( *pCNd );
1354ca62e2c2SSteve Yin pFrm = (SwFrm*)aClientIter.First( TYPE(SwFrm));
1355ca62e2c2SSteve Yin }
1356ca62e2c2SSteve Yin else if( nStartIndex.GetNode().IsTableNode() )
1357ca62e2c2SSteve Yin {
1358ca62e2c2SSteve Yin SwTableNode * pTable= (SwTableNode *)&(nStartIndex.GetNode());
1359ca62e2c2SSteve Yin SwFrmFmt* pFmt = const_cast<SwFrmFmt*>(pTable->GetTable().GetFrmFmt());
1360ca62e2c2SSteve Yin SwClientIter aClientIter( *pFmt );
1361ca62e2c2SSteve Yin pFrm = (SwFrm*)aClientIter.First( TYPE(SwFrm));
1362ca62e2c2SSteve Yin }
1363ca62e2c2SSteve Yin
1364ca62e2c2SSteve Yin if( pFrm && mpFrmMap)
1365ca62e2c2SSteve Yin {
1366ca62e2c2SSteve Yin aIter = mpFrmMap->find( pFrm );
1367ca62e2c2SSteve Yin if( aIter != mpFrmMap->end() )
1368ca62e2c2SSteve Yin {
1369ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc = (*aIter).second;
1370ca62e2c2SSteve Yin sal_Bool isChanged = sal_False;
1371ca62e2c2SSteve Yin if( xAcc.is() )
1372ca62e2c2SSteve Yin {
1373ca62e2c2SSteve Yin isChanged = (static_cast< SwAccessibleContext * >(xAcc.get()))->SetSelectedState( sal_True );
1374ca62e2c2SSteve Yin }
1375ca62e2c2SSteve Yin if(!isChanged)
1376ca62e2c2SSteve Yin {
1377ca62e2c2SSteve Yin SwAccessibleContextMap_Impl::iterator aEraseIter = mpSeletedFrmMap->find( pFrm );
1378ca62e2c2SSteve Yin if(aEraseIter != mpSeletedFrmMap->end())
1379ca62e2c2SSteve Yin mpSeletedFrmMap->erase(aEraseIter);
1380ca62e2c2SSteve Yin }
1381ca62e2c2SSteve Yin else
1382ca62e2c2SSteve Yin {
1383ca62e2c2SSteve Yin bMarkChanged = sal_True;
1384ca62e2c2SSteve Yin vecAdd.push_back(static_cast< SwAccessibleContext * >(xAcc.get()));
1385ca62e2c2SSteve Yin }
1386ca62e2c2SSteve Yin
1387ca62e2c2SSteve Yin mapTemp.insert( SwAccessibleContextMap_Impl::value_type( pFrm, xAcc ) );
1388ca62e2c2SSteve Yin }
1389ca62e2c2SSteve Yin }
1390ca62e2c2SSteve Yin nStartIndex++;
1391ca62e2c2SSteve Yin }
1392ca62e2c2SSteve Yin }
1393ca62e2c2SSteve Yin pTmpCrsr = static_cast<SwPaM*>( pTmpCrsr->GetNext() );
1394ca62e2c2SSteve Yin }
1395ca62e2c2SSteve Yin while( pTmpCrsr != pCrsr );
1396ca62e2c2SSteve Yin }
1397ca62e2c2SSteve Yin if( !mpSeletedFrmMap )
1398ca62e2c2SSteve Yin mpSeletedFrmMap = new SwAccessibleContextMap_Impl;
1399ca62e2c2SSteve Yin if( !mpSeletedFrmMap->empty() )
1400ca62e2c2SSteve Yin {
1401ca62e2c2SSteve Yin aIter = mpSeletedFrmMap->begin();
1402ca62e2c2SSteve Yin while( aIter != mpSeletedFrmMap->end() )
1403ca62e2c2SSteve Yin {
1404ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc = (*aIter).second;
1405ca62e2c2SSteve Yin if(xAcc.is())
1406ca62e2c2SSteve Yin (static_cast< SwAccessibleContext * >(xAcc.get()))->SetSelectedState( sal_False );
1407ca62e2c2SSteve Yin ++aIter;
1408ca62e2c2SSteve Yin vecRemove.push_back(static_cast< SwAccessibleContext * >(xAcc.get()));
1409ca62e2c2SSteve Yin }
1410ca62e2c2SSteve Yin bMarkChanged = sal_True;
1411ca62e2c2SSteve Yin mpSeletedFrmMap->clear();
1412ca62e2c2SSteve Yin }
1413ca62e2c2SSteve Yin
1414ca62e2c2SSteve Yin if( !mapTemp.empty() )
1415ca62e2c2SSteve Yin {
1416ca62e2c2SSteve Yin aIter = mapTemp.begin();
1417ca62e2c2SSteve Yin while( aIter != mapTemp.end() )
1418ca62e2c2SSteve Yin {
1419ca62e2c2SSteve Yin mpSeletedFrmMap->insert( SwAccessibleContextMap_Impl::value_type( (*aIter).first, (*aIter).second ) );
1420ca62e2c2SSteve Yin ++aIter;
1421ca62e2c2SSteve Yin }
1422ca62e2c2SSteve Yin mapTemp.clear();
1423ca62e2c2SSteve Yin }
1424ca62e2c2SSteve Yin if( bMarkChanged && mpFrmMap)
1425ca62e2c2SSteve Yin {
1426ca62e2c2SSteve Yin VEC_PARA::iterator vi = vecAdd.begin();
1427ca62e2c2SSteve Yin for (; vi != vecAdd.end() ; ++vi)
1428ca62e2c2SSteve Yin {
1429ca62e2c2SSteve Yin AccessibleEventObject aEvent;
1430ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::SELECTION_CHANGED;
1431ca62e2c2SSteve Yin SwAccessibleContext* pAccPara = *vi;
1432ca62e2c2SSteve Yin if (pAccPara)
1433ca62e2c2SSteve Yin {
1434ca62e2c2SSteve Yin pAccPara->FireAccessibleEvent( aEvent );
1435ca62e2c2SSteve Yin }
1436ca62e2c2SSteve Yin }
1437ca62e2c2SSteve Yin vi = vecRemove.begin();
1438ca62e2c2SSteve Yin for (; vi != vecRemove.end() ; ++vi)
1439ca62e2c2SSteve Yin {
1440ca62e2c2SSteve Yin AccessibleEventObject aEvent;
1441ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_REMOVE;
1442ca62e2c2SSteve Yin SwAccessibleContext* pAccPara = *vi;
1443ca62e2c2SSteve Yin if (pAccPara)
1444ca62e2c2SSteve Yin {
1445ca62e2c2SSteve Yin pAccPara->FireAccessibleEvent( aEvent );
1446ca62e2c2SSteve Yin }
1447ca62e2c2SSteve Yin }
1448ca62e2c2SSteve Yin }
1449ca62e2c2SSteve Yin }
1450ca62e2c2SSteve Yin
1451ca62e2c2SSteve Yin //Marge with DoInvalidateShapeFocus
DoInvalidateShapeSelection(sal_Bool bInvalidateFocusMode)1452ca62e2c2SSteve Yin void SwAccessibleMap::DoInvalidateShapeSelection(sal_Bool bInvalidateFocusMode /*=sal_False*/)
1453cdf0e10cSrcweir {
1454cdf0e10cSrcweir SwAccessibleObjShape_Impl *pShapes = 0;
1455cdf0e10cSrcweir SwAccessibleObjShape_Impl *pSelShape = 0;
1456cdf0e10cSrcweir size_t nShapes = 0;
1457cdf0e10cSrcweir
1458cdf0e10cSrcweir const ViewShell *pVSh = GetShell();
1459cdf0e10cSrcweir const SwFEShell *pFESh = pVSh->ISA( SwFEShell ) ?
1460cdf0e10cSrcweir static_cast< const SwFEShell * >( pVSh ) : 0;
1461cdf0e10cSrcweir sal_uInt16 nSelShapes = pFESh ? pFESh->IsObjSelected() : 0;
1462ca62e2c2SSteve Yin
1463cdf0e10cSrcweir
1464ca62e2c2SSteve Yin //when InvalidateFocus Call this function ,and the current selected shape count is not 1 ,
1465ca62e2c2SSteve Yin //return
1466ca62e2c2SSteve Yin if (bInvalidateFocusMode && nSelShapes != 1)
1467ca62e2c2SSteve Yin {
1468ca62e2c2SSteve Yin return;
1469ca62e2c2SSteve Yin }
1470cdf0e10cSrcweir {
1471cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
1472cdf0e10cSrcweir if( mpShapeMap )
1473cdf0e10cSrcweir pShapes = mpShapeMap->Copy( nShapes, pFESh, &pSelShape );
1474cdf0e10cSrcweir }
1475cdf0e10cSrcweir
1476cdf0e10cSrcweir if( pShapes )
1477cdf0e10cSrcweir {
1478ca62e2c2SSteve Yin typedef std::vector< ::vos::ORef < ::accessibility::AccessibleShape > > VEC_SHAPE;
1479ca62e2c2SSteve Yin VEC_SHAPE vecxShapeAdd;
1480ca62e2c2SSteve Yin VEC_SHAPE vecxShapeRemove;
1481ca62e2c2SSteve Yin int nCountSelectedShape=0;
1482ca62e2c2SSteve Yin
1483cdf0e10cSrcweir Window *pWin = GetShell()->GetWin();
1484cdf0e10cSrcweir sal_Bool bFocused = pWin && pWin->HasFocus();
1485cdf0e10cSrcweir SwAccessibleObjShape_Impl *pShape = pShapes;
1486ca62e2c2SSteve Yin int nShapeCount = nShapes;
1487ca62e2c2SSteve Yin while( nShapeCount )
1488ca62e2c2SSteve Yin {
1489ca62e2c2SSteve Yin //if( pShape->second.isValid() )
1490ca62e2c2SSteve Yin if (pShape->second.isValid() && IsInSameLevel(pShape->first, pFESh))
1491ca62e2c2SSteve Yin {
1492ca62e2c2SSteve Yin if( pShape < pSelShape )
1493ca62e2c2SSteve Yin {
1494ca62e2c2SSteve Yin if(pShape->second->ResetState( AccessibleStateType::SELECTED ))
1495ca62e2c2SSteve Yin {
1496ca62e2c2SSteve Yin vecxShapeRemove.push_back(pShape->second);
1497ca62e2c2SSteve Yin }
1498ca62e2c2SSteve Yin pShape->second->ResetState( AccessibleStateType::FOCUSED );
1499ca62e2c2SSteve Yin }
1500ca62e2c2SSteve Yin }
1501ca62e2c2SSteve Yin --nShapeCount;
1502ca62e2c2SSteve Yin ++pShape;
1503ca62e2c2SSteve Yin }
1504ca62e2c2SSteve Yin
1505ca62e2c2SSteve Yin VEC_SHAPE::iterator vi =vecxShapeRemove.begin();
1506ca62e2c2SSteve Yin for (; vi != vecxShapeRemove.end(); ++vi)
1507ca62e2c2SSteve Yin {
1508ca62e2c2SSteve Yin ::accessibility::AccessibleShape *pAccShape = static_cast< ::accessibility::AccessibleShape * >(vi->getBodyPtr());
1509ca62e2c2SSteve Yin if (pAccShape)
1510ca62e2c2SSteve Yin {
1511ca62e2c2SSteve Yin pAccShape->CommitChange(AccessibleEventId::SELECTION_CHANGED_REMOVE, uno::Any(), uno::Any());
1512ca62e2c2SSteve Yin }
1513ca62e2c2SSteve Yin }
1514ca62e2c2SSteve Yin
1515ca62e2c2SSteve Yin pShape = pShapes;
1516cdf0e10cSrcweir while( nShapes )
1517cdf0e10cSrcweir {
1518ca62e2c2SSteve Yin //if( pShape->second.isValid() )
1519ca62e2c2SSteve Yin if (pShape->second.isValid() && IsInSameLevel(pShape->first, pFESh))
1520cdf0e10cSrcweir {
1521ca62e2c2SSteve Yin // IA2 - why?
1522ca62e2c2SSteve Yin // sal_Bool bChanged;
1523cdf0e10cSrcweir if( pShape >= pSelShape )
1524cdf0e10cSrcweir {
1525ca62e2c2SSteve Yin // IA2: first fire focus event
1526ca62e2c2SSteve Yin // bChanged = pShape->second->SetState( AccessibleStateType::SELECTED );
1527ca62e2c2SSteve Yin
1528ca62e2c2SSteve Yin //first fire focus event
1529cdf0e10cSrcweir if( bFocused && 1 == nSelShapes )
1530cdf0e10cSrcweir pShape->second->SetState( AccessibleStateType::FOCUSED );
1531cdf0e10cSrcweir else
1532cdf0e10cSrcweir pShape->second->ResetState( AccessibleStateType::FOCUSED );
1533ca62e2c2SSteve Yin
1534ca62e2c2SSteve Yin if(pShape->second->SetState( AccessibleStateType::SELECTED ))
1535ca62e2c2SSteve Yin {
1536ca62e2c2SSteve Yin vecxShapeAdd.push_back(pShape->second);
1537ca62e2c2SSteve Yin }
1538ca62e2c2SSteve Yin ++nCountSelectedShape;
1539cdf0e10cSrcweir }
1540ca62e2c2SSteve Yin /* MT: This still was in DEV300m80, but was removed in IA2 CWS.
1541ca62e2c2SSteve Yin Someone needs to check what should happen here, see original diff CWS oo31ia2 vs. OOO310M11
1542cdf0e10cSrcweir else
1543cdf0e10cSrcweir {
1544cdf0e10cSrcweir bChanged =
1545cdf0e10cSrcweir pShape->second->ResetState( AccessibleStateType::SELECTED );
1546cdf0e10cSrcweir pShape->second->ResetState( AccessibleStateType::FOCUSED );
1547cdf0e10cSrcweir }
1548cdf0e10cSrcweir if( bChanged )
1549cdf0e10cSrcweir {
1550cdf0e10cSrcweir const SwFrm* pParent = SwAccessibleFrame::GetParent(
1551cdf0e10cSrcweir SwAccessibleChild( pShape->first ),
1552cdf0e10cSrcweir GetShell()->IsPreView() );
1553cdf0e10cSrcweir aParents.push_back( pParent );
1554cdf0e10cSrcweir }
1555ca62e2c2SSteve Yin */
1556cdf0e10cSrcweir }
1557cdf0e10cSrcweir
1558cdf0e10cSrcweir --nShapes;
1559cdf0e10cSrcweir ++pShape;
1560cdf0e10cSrcweir }
1561ca62e2c2SSteve Yin
1562440e7076SPavel Janík const unsigned int SELECTION_WITH_NUM = 10;
1563ca62e2c2SSteve Yin if (vecxShapeAdd.size() > SELECTION_WITH_NUM )
1564cdf0e10cSrcweir {
1565ca62e2c2SSteve Yin uno::Reference< XAccessible > xDoc = GetDocumentView( );
1566ca62e2c2SSteve Yin SwAccessibleContext * pCont = static_cast<SwAccessibleContext *>(xDoc.get());
1567ca62e2c2SSteve Yin if (pCont)
1568ca62e2c2SSteve Yin {
1569ca62e2c2SSteve Yin AccessibleEventObject aEvent;
1570ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_WITHIN;
1571ca62e2c2SSteve Yin pCont->FireAccessibleEvent(aEvent);
1572ca62e2c2SSteve Yin }
1573ca62e2c2SSteve Yin }
1574ca62e2c2SSteve Yin else
1575ca62e2c2SSteve Yin {
1576ca62e2c2SSteve Yin short nEventID = AccessibleEventId::SELECTION_CHANGED_ADD;
1577ca62e2c2SSteve Yin if (nCountSelectedShape <= 1 && vecxShapeAdd.size() == 1 )
1578cdf0e10cSrcweir {
1579ca62e2c2SSteve Yin nEventID = AccessibleEventId::SELECTION_CHANGED;
1580ca62e2c2SSteve Yin }
1581ca62e2c2SSteve Yin vi = vecxShapeAdd.begin();
1582ca62e2c2SSteve Yin for (; vi != vecxShapeAdd.end(); ++vi)
1583ca62e2c2SSteve Yin {
1584ca62e2c2SSteve Yin ::accessibility::AccessibleShape *pAccShape = static_cast< ::accessibility::AccessibleShape * >(vi->getBodyPtr());
1585ca62e2c2SSteve Yin if (pAccShape)
1586cdf0e10cSrcweir {
1587ca62e2c2SSteve Yin pAccShape->CommitChange(nEventID, uno::Any(), uno::Any());
1588ca62e2c2SSteve Yin }
1589ca62e2c2SSteve Yin }
1590ca62e2c2SSteve Yin }
1591ca62e2c2SSteve Yin
1592ca62e2c2SSteve Yin vi = vecxShapeAdd.begin();
1593ca62e2c2SSteve Yin for (; vi != vecxShapeAdd.end(); ++vi)
1594ca62e2c2SSteve Yin {
1595ca62e2c2SSteve Yin ::accessibility::AccessibleShape *pAccShape = static_cast< ::accessibility::AccessibleShape * >(vi->getBodyPtr());
1596ca62e2c2SSteve Yin if (pAccShape)
1597ca62e2c2SSteve Yin {
1598ca62e2c2SSteve Yin SdrObject *pObj = GetSdrObjectFromXShape(pAccShape->GetXShape());
1599ca62e2c2SSteve Yin SwFrmFmt *pFrmFmt = pObj ? FindFrmFmt( pObj ) : NULL;
1600ca62e2c2SSteve Yin if (pFrmFmt)
1601ca62e2c2SSteve Yin {
1602ca62e2c2SSteve Yin const SwFmtAnchor& pAnchor = pFrmFmt->GetAnchor();
1603ca62e2c2SSteve Yin if( pAnchor.GetAnchorId() == FLY_AS_CHAR )
1604cdf0e10cSrcweir {
1605ca62e2c2SSteve Yin uno::Reference< XAccessible > xPara = pAccShape->getAccessibleParent();
1606ca62e2c2SSteve Yin if (xPara.is())
1607cdf0e10cSrcweir {
1608ca62e2c2SSteve Yin uno::Reference< XAccessibleContext > xParaContext = xPara->getAccessibleContext();
1609ca62e2c2SSteve Yin if (xParaContext.is() && xParaContext->getAccessibleRole() == AccessibleRole::PARAGRAPH)
1610ca62e2c2SSteve Yin {
1611ca62e2c2SSteve Yin SwAccessibleParagraph* pAccPara = static_cast< SwAccessibleParagraph *>(xPara.get());
1612ca62e2c2SSteve Yin if (pAccPara)
1613ca62e2c2SSteve Yin {
1614ca62e2c2SSteve Yin m_setParaAdd.insert(pAccPara);
1615ca62e2c2SSteve Yin }
1616ca62e2c2SSteve Yin }
1617cdf0e10cSrcweir }
1618cdf0e10cSrcweir }
1619cdf0e10cSrcweir }
1620ca62e2c2SSteve Yin }
1621ca62e2c2SSteve Yin }
1622ca62e2c2SSteve Yin vi = vecxShapeRemove.begin();
1623ca62e2c2SSteve Yin for (; vi != vecxShapeRemove.end(); ++vi)
1624ca62e2c2SSteve Yin {
1625ca62e2c2SSteve Yin ::accessibility::AccessibleShape *pAccShape = static_cast< ::accessibility::AccessibleShape * >(vi->getBodyPtr());
1626ca62e2c2SSteve Yin if (pAccShape)
1627ca62e2c2SSteve Yin {
1628ca62e2c2SSteve Yin uno::Reference< XAccessible > xPara = pAccShape->getAccessibleParent();
1629ca62e2c2SSteve Yin uno::Reference< XAccessibleContext > xParaContext = xPara->getAccessibleContext();
1630ca62e2c2SSteve Yin if (xParaContext.is() && xParaContext->getAccessibleRole() == AccessibleRole::PARAGRAPH)
1631cdf0e10cSrcweir {
1632ca62e2c2SSteve Yin SwAccessibleParagraph* pAccPara = static_cast< SwAccessibleParagraph *>(xPara.get());
1633ca62e2c2SSteve Yin if (m_setParaAdd.count(pAccPara) == 0 )
1634ca62e2c2SSteve Yin {
1635ca62e2c2SSteve Yin m_setParaRemove.insert(pAccPara);
1636ca62e2c2SSteve Yin }
1637cdf0e10cSrcweir }
1638cdf0e10cSrcweir }
1639ca62e2c2SSteve Yin }
1640cdf0e10cSrcweir delete[] pShapes;
1641cdf0e10cSrcweir }
1642cdf0e10cSrcweir }
1643cdf0e10cSrcweir
1644ca62e2c2SSteve Yin //Marge with DoInvalidateShapeSelection
1645ca62e2c2SSteve Yin /*
1646cdf0e10cSrcweir void SwAccessibleMap::DoInvalidateShapeFocus()
1647cdf0e10cSrcweir {
1648cdf0e10cSrcweir const ViewShell *pVSh = GetShell();
1649cdf0e10cSrcweir const SwFEShell *pFESh = pVSh->ISA( SwFEShell ) ?
1650cdf0e10cSrcweir static_cast< const SwFEShell * >( pVSh ) : 0;
1651cdf0e10cSrcweir sal_uInt16 nSelShapes = pFESh ? pFESh->IsObjSelected() : 0;
1652cdf0e10cSrcweir
1653cdf0e10cSrcweir if( nSelShapes != 1 )
1654cdf0e10cSrcweir return;
1655cdf0e10cSrcweir
1656cdf0e10cSrcweir SwAccessibleObjShape_Impl *pShapes = 0;
1657cdf0e10cSrcweir SwAccessibleObjShape_Impl *pSelShape = 0;
1658cdf0e10cSrcweir size_t nShapes = 0;
1659cdf0e10cSrcweir
1660cdf0e10cSrcweir
1661cdf0e10cSrcweir {
1662cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
1663cdf0e10cSrcweir if( mpShapeMap )
1664cdf0e10cSrcweir pShapes = mpShapeMap->Copy( nShapes, pFESh, &pSelShape );
1665cdf0e10cSrcweir }
1666cdf0e10cSrcweir
1667cdf0e10cSrcweir if( pShapes )
1668cdf0e10cSrcweir {
1669cdf0e10cSrcweir Window *pWin = GetShell()->GetWin();
1670cdf0e10cSrcweir sal_Bool bFocused = pWin && pWin->HasFocus();
1671cdf0e10cSrcweir SwAccessibleObjShape_Impl *pShape = pShapes;
1672cdf0e10cSrcweir while( nShapes )
1673cdf0e10cSrcweir {
1674cdf0e10cSrcweir if( pShape->second.isValid() )
1675cdf0e10cSrcweir {
1676cdf0e10cSrcweir if( bFocused && pShape >= pSelShape )
1677cdf0e10cSrcweir pShape->second->SetState( AccessibleStateType::FOCUSED );
1678cdf0e10cSrcweir else
1679cdf0e10cSrcweir pShape->second->ResetState( AccessibleStateType::FOCUSED );
1680cdf0e10cSrcweir }
1681cdf0e10cSrcweir
1682cdf0e10cSrcweir --nShapes;
1683cdf0e10cSrcweir ++pShape;
1684cdf0e10cSrcweir }
1685cdf0e10cSrcweir
1686cdf0e10cSrcweir delete[] pShapes;
1687cdf0e10cSrcweir }
1688cdf0e10cSrcweir }
1689ca62e2c2SSteve Yin */
1690cdf0e10cSrcweir
SwAccessibleMap(ViewShell * pSh)1691cdf0e10cSrcweir SwAccessibleMap::SwAccessibleMap( ViewShell *pSh ) :
1692cdf0e10cSrcweir mpFrmMap( 0 ),
1693cdf0e10cSrcweir mpShapeMap( 0 ),
1694cdf0e10cSrcweir mpShapes( 0 ),
1695cdf0e10cSrcweir mpEvents( 0 ),
1696cdf0e10cSrcweir mpEventMap( 0 ),
1697cdf0e10cSrcweir // --> OD 2005-12-13 #i27301#
1698cdf0e10cSrcweir mpSelectedParas( 0 ),
1699cdf0e10cSrcweir // <--
1700cdf0e10cSrcweir mpVSh( pSh ),
1701cdf0e10cSrcweir mpPreview( 0 ),
1702cdf0e10cSrcweir mnPara( 1 ),
1703cdf0e10cSrcweir mnFootnote( 1 ),
1704cdf0e10cSrcweir mnEndnote( 1 ),
1705ca62e2c2SSteve Yin mbShapeSelected( sal_False ),
1706*90386390SHerbert Dürr mpSeletedFrmMap(NULL)
1707*90386390SHerbert Dürr {
1708cdf0e10cSrcweir pSh->GetLayout()->AddAccessibleShell();
1709cdf0e10cSrcweir }
1710cdf0e10cSrcweir
~SwAccessibleMap()1711cdf0e10cSrcweir SwAccessibleMap::~SwAccessibleMap()
1712cdf0e10cSrcweir {
1713cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
1714cdf0e10cSrcweir {
1715cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
1716cdf0e10cSrcweir if( mpFrmMap )
1717cdf0e10cSrcweir {
1718cdf0e10cSrcweir const SwRootFrm *pRootFrm = GetShell()->GetLayout();
1719cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter = mpFrmMap->find( pRootFrm );
1720cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
1721cdf0e10cSrcweir xAcc = (*aIter).second;
1722cdf0e10cSrcweir if( !xAcc.is() )
1723cdf0e10cSrcweir xAcc = new SwAccessibleDocument( this );
1724cdf0e10cSrcweir }
1725cdf0e10cSrcweir }
1726cdf0e10cSrcweir
1727ca62e2c2SSteve Yin if(xAcc.is())
1728ca62e2c2SSteve Yin {
1729cdf0e10cSrcweir SwAccessibleDocument *pAcc =
1730cdf0e10cSrcweir static_cast< SwAccessibleDocument * >( xAcc.get() );
1731cdf0e10cSrcweir pAcc->Dispose( sal_True );
1732ca62e2c2SSteve Yin }
1733ca62e2c2SSteve Yin if( mpFrmMap )
1734ca62e2c2SSteve Yin {
1735ca62e2c2SSteve Yin SwAccessibleContextMap_Impl::iterator aIter = mpFrmMap->begin();
1736ca62e2c2SSteve Yin while( aIter != mpFrmMap->end() )
1737ca62e2c2SSteve Yin {
1738ca62e2c2SSteve Yin uno::Reference < XAccessible > xTmp = (*aIter).second;
1739ca62e2c2SSteve Yin if( xTmp.is() )
1740ca62e2c2SSteve Yin {
1741ca62e2c2SSteve Yin SwAccessibleContext *pTmp = static_cast< SwAccessibleContext * >( xTmp.get() );
1742ca62e2c2SSteve Yin pTmp->SetMap(NULL);
1743ca62e2c2SSteve Yin }
1744ca62e2c2SSteve Yin ++aIter;
1745ca62e2c2SSteve Yin }
1746ca62e2c2SSteve Yin }
1747cdf0e10cSrcweir {
1748cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
1749cdf0e10cSrcweir #ifdef DBG_UTIL
1750cdf0e10cSrcweir ASSERT( !mpFrmMap || mpFrmMap->empty(),
1751cdf0e10cSrcweir "Frame map should be empty after disposing the root frame" );
1752cdf0e10cSrcweir if( mpFrmMap )
1753cdf0e10cSrcweir {
1754cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter = mpFrmMap->begin();
1755cdf0e10cSrcweir while( aIter != mpFrmMap->end() )
1756cdf0e10cSrcweir {
1757cdf0e10cSrcweir uno::Reference < XAccessible > xTmp = (*aIter).second;
1758cdf0e10cSrcweir if( xTmp.is() )
1759cdf0e10cSrcweir {
1760cdf0e10cSrcweir SwAccessibleContext *pTmp =
1761cdf0e10cSrcweir static_cast< SwAccessibleContext * >( xTmp.get() );
1762cdf0e10cSrcweir (void) pTmp;
1763cdf0e10cSrcweir }
1764cdf0e10cSrcweir ++aIter;
1765cdf0e10cSrcweir }
1766cdf0e10cSrcweir }
1767cdf0e10cSrcweir ASSERT( !mpShapeMap || mpShapeMap->empty(),
1768cdf0e10cSrcweir "Object map should be empty after disposing the root frame" );
1769cdf0e10cSrcweir if( mpShapeMap )
1770cdf0e10cSrcweir {
1771cdf0e10cSrcweir SwAccessibleShapeMap_Impl::iterator aIter = mpShapeMap->begin();
1772cdf0e10cSrcweir while( aIter != mpShapeMap->end() )
1773cdf0e10cSrcweir {
1774cdf0e10cSrcweir uno::Reference < XAccessible > xTmp = (*aIter).second;
1775cdf0e10cSrcweir if( xTmp.is() )
1776cdf0e10cSrcweir {
1777cdf0e10cSrcweir ::accessibility::AccessibleShape *pTmp =
1778cdf0e10cSrcweir static_cast< ::accessibility::AccessibleShape* >( xTmp.get() );
1779cdf0e10cSrcweir (void) pTmp;
1780cdf0e10cSrcweir }
1781cdf0e10cSrcweir ++aIter;
1782cdf0e10cSrcweir }
1783cdf0e10cSrcweir }
1784cdf0e10cSrcweir #endif
1785cdf0e10cSrcweir delete mpFrmMap;
1786cdf0e10cSrcweir mpFrmMap = 0;
1787cdf0e10cSrcweir delete mpShapeMap;
1788cdf0e10cSrcweir mpShapeMap = 0;
1789cdf0e10cSrcweir delete mpShapes;
1790cdf0e10cSrcweir mpShapes = 0;
1791cdf0e10cSrcweir // --> OD 2005-12-13 #i27301#
1792cdf0e10cSrcweir delete mpSelectedParas;
1793cdf0e10cSrcweir mpSelectedParas = 0;
1794cdf0e10cSrcweir // <--
1795cdf0e10cSrcweir }
1796cdf0e10cSrcweir
1797cdf0e10cSrcweir delete mpPreview;
1798cdf0e10cSrcweir mpPreview = NULL;
1799cdf0e10cSrcweir
1800cdf0e10cSrcweir {
1801cdf0e10cSrcweir vos::OGuard aGuard( maEventMutex );
1802cdf0e10cSrcweir #ifdef DBG_UTIL
1803cdf0e10cSrcweir ASSERT( !(mpEvents || mpEventMap), "pending events" );
1804cdf0e10cSrcweir if( mpEvents )
1805cdf0e10cSrcweir {
1806cdf0e10cSrcweir SwAccessibleEventList_Impl::iterator aIter = mpEvents->begin();
1807cdf0e10cSrcweir while( aIter != mpEvents->end() )
1808cdf0e10cSrcweir {
1809cdf0e10cSrcweir ++aIter;
1810cdf0e10cSrcweir }
1811cdf0e10cSrcweir }
1812cdf0e10cSrcweir if( mpEventMap )
1813cdf0e10cSrcweir {
1814cdf0e10cSrcweir SwAccessibleEventMap_Impl::iterator aIter = mpEventMap->begin();
1815cdf0e10cSrcweir while( aIter != mpEventMap->end() )
1816cdf0e10cSrcweir {
1817cdf0e10cSrcweir ++aIter;
1818cdf0e10cSrcweir }
1819cdf0e10cSrcweir }
1820cdf0e10cSrcweir #endif
1821cdf0e10cSrcweir delete mpEventMap;
1822cdf0e10cSrcweir mpEventMap = 0;
1823cdf0e10cSrcweir delete mpEvents;
1824cdf0e10cSrcweir mpEvents = 0;
1825cdf0e10cSrcweir }
1826cdf0e10cSrcweir mpVSh->GetLayout()->RemoveAccessibleShell();
1827*90386390SHerbert Dürr delete mpSeletedFrmMap;
1828*90386390SHerbert Dürr }
1829cdf0e10cSrcweir
_GetDocumentView(sal_Bool bPagePreview)1830cdf0e10cSrcweir uno::Reference< XAccessible > SwAccessibleMap::_GetDocumentView(
1831cdf0e10cSrcweir sal_Bool bPagePreview )
1832cdf0e10cSrcweir {
1833cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
1834cdf0e10cSrcweir sal_Bool bSetVisArea = sal_False;
1835cdf0e10cSrcweir
1836cdf0e10cSrcweir {
1837cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
1838cdf0e10cSrcweir
1839cdf0e10cSrcweir if( !mpFrmMap )
1840cdf0e10cSrcweir {
1841cdf0e10cSrcweir mpFrmMap = new SwAccessibleContextMap_Impl;
1842cdf0e10cSrcweir #ifdef DBG_UTIL
1843cdf0e10cSrcweir mpFrmMap->mbLocked = sal_False;
1844cdf0e10cSrcweir #endif
1845cdf0e10cSrcweir }
1846cdf0e10cSrcweir
1847cdf0e10cSrcweir #ifdef DBG_UTIL
1848cdf0e10cSrcweir ASSERT( !mpFrmMap->mbLocked, "Map is locked" );
1849cdf0e10cSrcweir mpFrmMap->mbLocked = sal_True;
1850cdf0e10cSrcweir #endif
1851cdf0e10cSrcweir
1852cdf0e10cSrcweir const SwRootFrm *pRootFrm = GetShell()->GetLayout();
1853cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter = mpFrmMap->find( pRootFrm );
1854cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
1855cdf0e10cSrcweir xAcc = (*aIter).second;
1856cdf0e10cSrcweir if( xAcc.is() )
1857cdf0e10cSrcweir {
1858cdf0e10cSrcweir bSetVisArea = sal_True; // Set VisArea when map mutex is not
1859cdf0e10cSrcweir // locked
1860cdf0e10cSrcweir }
1861cdf0e10cSrcweir else
1862cdf0e10cSrcweir {
1863cdf0e10cSrcweir if( bPagePreview )
1864cdf0e10cSrcweir xAcc = new SwAccessiblePreview( this );
1865cdf0e10cSrcweir else
1866cdf0e10cSrcweir xAcc = new SwAccessibleDocument( this );
1867cdf0e10cSrcweir
1868cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
1869cdf0e10cSrcweir {
1870cdf0e10cSrcweir (*aIter).second = xAcc;
1871cdf0e10cSrcweir }
1872cdf0e10cSrcweir else
1873cdf0e10cSrcweir {
1874cdf0e10cSrcweir SwAccessibleContextMap_Impl::value_type aEntry( pRootFrm, xAcc );
1875cdf0e10cSrcweir mpFrmMap->insert( aEntry );
1876cdf0e10cSrcweir }
1877cdf0e10cSrcweir }
1878cdf0e10cSrcweir
1879cdf0e10cSrcweir #ifdef DBG_UTIL
1880cdf0e10cSrcweir mpFrmMap->mbLocked = sal_False;
1881cdf0e10cSrcweir #endif
1882cdf0e10cSrcweir }
1883cdf0e10cSrcweir
1884cdf0e10cSrcweir if( bSetVisArea )
1885cdf0e10cSrcweir {
1886cdf0e10cSrcweir SwAccessibleDocumentBase *pAcc =
1887cdf0e10cSrcweir static_cast< SwAccessibleDocumentBase * >( xAcc.get() );
1888cdf0e10cSrcweir pAcc->SetVisArea();
1889cdf0e10cSrcweir }
1890cdf0e10cSrcweir
1891cdf0e10cSrcweir return xAcc;
1892cdf0e10cSrcweir }
1893cdf0e10cSrcweir
GetDocumentView()1894cdf0e10cSrcweir uno::Reference< XAccessible > SwAccessibleMap::GetDocumentView( )
1895cdf0e10cSrcweir {
1896cdf0e10cSrcweir return _GetDocumentView( sal_False );
1897cdf0e10cSrcweir }
1898cdf0e10cSrcweir
1899cdf0e10cSrcweir // OD 14.01.2003 #103492# - complete re-factoring of method due to new page/print
1900cdf0e10cSrcweir // preview functionality.
GetDocumentPreview(const std::vector<PrevwPage * > & _rPrevwPages,const Fraction & _rScale,const SwPageFrm * _pSelectedPageFrm,const Size & _rPrevwWinSize)1901cdf0e10cSrcweir uno::Reference<XAccessible> SwAccessibleMap::GetDocumentPreview(
1902cdf0e10cSrcweir const std::vector<PrevwPage*>& _rPrevwPages,
1903cdf0e10cSrcweir const Fraction& _rScale,
1904cdf0e10cSrcweir const SwPageFrm* _pSelectedPageFrm,
1905cdf0e10cSrcweir const Size& _rPrevwWinSize )
1906cdf0e10cSrcweir {
1907cdf0e10cSrcweir // create & update preview data object
1908cdf0e10cSrcweir if( mpPreview == NULL )
1909cdf0e10cSrcweir mpPreview = new SwAccPreviewData();
1910cdf0e10cSrcweir mpPreview->Update( *this, _rPrevwPages, _rScale, _pSelectedPageFrm, _rPrevwWinSize );
1911cdf0e10cSrcweir
1912cdf0e10cSrcweir uno::Reference<XAccessible> xAcc = _GetDocumentView( sal_True );
1913cdf0e10cSrcweir return xAcc;
1914cdf0e10cSrcweir }
1915cdf0e10cSrcweir
GetContext(const SwFrm * pFrm,sal_Bool bCreate)1916cdf0e10cSrcweir uno::Reference< XAccessible> SwAccessibleMap::GetContext( const SwFrm *pFrm,
1917cdf0e10cSrcweir sal_Bool bCreate )
1918cdf0e10cSrcweir {
1919cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
1920cdf0e10cSrcweir uno::Reference < XAccessible > xOldCursorAcc;
1921cdf0e10cSrcweir sal_Bool bOldShapeSelected = sal_False;
1922cdf0e10cSrcweir
1923cdf0e10cSrcweir {
1924cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
1925cdf0e10cSrcweir
1926cdf0e10cSrcweir if( !mpFrmMap && bCreate )
1927cdf0e10cSrcweir mpFrmMap = new SwAccessibleContextMap_Impl;
1928cdf0e10cSrcweir if( mpFrmMap )
1929cdf0e10cSrcweir {
1930cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter = mpFrmMap->find( pFrm );
1931cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
1932cdf0e10cSrcweir xAcc = (*aIter).second;
1933cdf0e10cSrcweir
1934cdf0e10cSrcweir if( !xAcc.is() && bCreate )
1935cdf0e10cSrcweir {
1936cdf0e10cSrcweir SwAccessibleContext *pAcc = 0;
1937cdf0e10cSrcweir switch( pFrm->GetType() )
1938cdf0e10cSrcweir {
1939cdf0e10cSrcweir case FRM_TXT:
1940cdf0e10cSrcweir mnPara++;
1941cdf0e10cSrcweir pAcc = new SwAccessibleParagraph( *this,
1942cdf0e10cSrcweir static_cast< const SwTxtFrm& >( *pFrm ) );
1943cdf0e10cSrcweir break;
1944cdf0e10cSrcweir case FRM_HEADER:
1945cdf0e10cSrcweir pAcc = new SwAccessibleHeaderFooter( this,
1946cdf0e10cSrcweir static_cast< const SwHeaderFrm *>( pFrm ) );
1947cdf0e10cSrcweir break;
1948cdf0e10cSrcweir case FRM_FOOTER:
1949cdf0e10cSrcweir pAcc = new SwAccessibleHeaderFooter( this,
1950cdf0e10cSrcweir static_cast< const SwFooterFrm *>( pFrm ) );
1951cdf0e10cSrcweir break;
1952cdf0e10cSrcweir case FRM_FTN:
1953cdf0e10cSrcweir {
1954cdf0e10cSrcweir const SwFtnFrm *pFtnFrm =
1955cdf0e10cSrcweir static_cast < const SwFtnFrm * >( pFrm );
1956cdf0e10cSrcweir sal_Bool bIsEndnote =
1957cdf0e10cSrcweir SwAccessibleFootnote::IsEndnote( pFtnFrm );
1958cdf0e10cSrcweir pAcc = new SwAccessibleFootnote( this, bIsEndnote,
1959ca62e2c2SSteve Yin /*(bIsEndnote ? mnEndnote++ : mnFootnote++),*/
1960cdf0e10cSrcweir pFtnFrm );
1961cdf0e10cSrcweir }
1962cdf0e10cSrcweir break;
1963cdf0e10cSrcweir case FRM_FLY:
1964cdf0e10cSrcweir {
1965cdf0e10cSrcweir const SwFlyFrm *pFlyFrm =
1966cdf0e10cSrcweir static_cast < const SwFlyFrm * >( pFrm );
1967cdf0e10cSrcweir switch( SwAccessibleFrameBase::GetNodeType( pFlyFrm ) )
1968cdf0e10cSrcweir {
1969cdf0e10cSrcweir case ND_GRFNODE:
1970cdf0e10cSrcweir pAcc = new SwAccessibleGraphic( this, pFlyFrm );
1971cdf0e10cSrcweir break;
1972cdf0e10cSrcweir case ND_OLENODE:
1973cdf0e10cSrcweir pAcc = new SwAccessibleEmbeddedObject( this, pFlyFrm );
1974cdf0e10cSrcweir break;
1975cdf0e10cSrcweir default:
1976cdf0e10cSrcweir pAcc = new SwAccessibleTextFrame( this, pFlyFrm );
1977cdf0e10cSrcweir break;
1978cdf0e10cSrcweir }
1979cdf0e10cSrcweir }
1980cdf0e10cSrcweir break;
1981cdf0e10cSrcweir case FRM_CELL:
1982cdf0e10cSrcweir pAcc = new SwAccessibleCell( this,
1983cdf0e10cSrcweir static_cast< const SwCellFrm *>( pFrm ) );
1984cdf0e10cSrcweir break;
1985cdf0e10cSrcweir case FRM_TAB:
1986cdf0e10cSrcweir pAcc = new SwAccessibleTable( this,
1987cdf0e10cSrcweir static_cast< const SwTabFrm *>( pFrm ) );
1988cdf0e10cSrcweir break;
1989cdf0e10cSrcweir case FRM_PAGE:
1990cdf0e10cSrcweir DBG_ASSERT( GetShell()->IsPreView(),
1991cdf0e10cSrcweir "accessible page frames only in PagePreview" );
1992cdf0e10cSrcweir pAcc = new SwAccessiblePage( this, pFrm );
1993cdf0e10cSrcweir break;
1994cdf0e10cSrcweir }
1995cdf0e10cSrcweir xAcc = pAcc;
1996cdf0e10cSrcweir
1997cdf0e10cSrcweir ASSERT( xAcc.is(), "unknown frame type" );
1998cdf0e10cSrcweir if( xAcc.is() )
1999cdf0e10cSrcweir {
2000cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2001cdf0e10cSrcweir {
2002cdf0e10cSrcweir (*aIter).second = xAcc;
2003cdf0e10cSrcweir }
2004cdf0e10cSrcweir else
2005cdf0e10cSrcweir {
2006cdf0e10cSrcweir SwAccessibleContextMap_Impl::value_type aEntry( pFrm, xAcc );
2007cdf0e10cSrcweir mpFrmMap->insert( aEntry );
2008cdf0e10cSrcweir }
2009cdf0e10cSrcweir
2010cdf0e10cSrcweir if( pAcc->HasCursor() &&
2011cdf0e10cSrcweir !AreInSameTable( mxCursorContext, pFrm ) )
2012cdf0e10cSrcweir {
2013cdf0e10cSrcweir // If the new context has the focus, and if we know
2014cdf0e10cSrcweir // another context that had the focus, then the focus
2015cdf0e10cSrcweir // just moves from the old context to the new one. We
2016cdf0e10cSrcweir // have to send a focus event and a caret event for
2017cdf0e10cSrcweir // the old context then. We have to to that know,
2018cdf0e10cSrcweir // because after we have left this method, anyone might
2019cdf0e10cSrcweir // call getStates for the new context and will get a
2020cdf0e10cSrcweir // focused state then. Sending the focus changes event
2021cdf0e10cSrcweir // after that seems to be strange. However, we cannot
2022cdf0e10cSrcweir // send a focus event fo the new context now, because
2023cdf0e10cSrcweir // noone except us knows it. In any case, we remeber
2024cdf0e10cSrcweir // the new context as the one that has the focus
2025cdf0e10cSrcweir // currently.
2026cdf0e10cSrcweir
2027cdf0e10cSrcweir xOldCursorAcc = mxCursorContext;
2028cdf0e10cSrcweir mxCursorContext = xAcc;
2029cdf0e10cSrcweir
2030cdf0e10cSrcweir bOldShapeSelected = mbShapeSelected;
2031cdf0e10cSrcweir mbShapeSelected = sal_False;
2032cdf0e10cSrcweir }
2033cdf0e10cSrcweir }
2034cdf0e10cSrcweir }
2035cdf0e10cSrcweir }
2036cdf0e10cSrcweir }
2037cdf0e10cSrcweir
2038cdf0e10cSrcweir // Invalidate focus for old object when map is not locked
2039cdf0e10cSrcweir if( xOldCursorAcc.is() )
2040cdf0e10cSrcweir InvalidateCursorPosition( xOldCursorAcc );
2041cdf0e10cSrcweir if( bOldShapeSelected )
2042cdf0e10cSrcweir InvalidateShapeSelection();
2043cdf0e10cSrcweir
2044cdf0e10cSrcweir return xAcc;
2045cdf0e10cSrcweir }
2046cdf0e10cSrcweir
GetContextImpl(const SwFrm * pFrm,sal_Bool bCreate)2047cdf0e10cSrcweir ::vos::ORef < SwAccessibleContext > SwAccessibleMap::GetContextImpl(
2048cdf0e10cSrcweir const SwFrm *pFrm,
2049cdf0e10cSrcweir sal_Bool bCreate )
2050cdf0e10cSrcweir {
2051cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( GetContext( pFrm, bCreate ) );
2052cdf0e10cSrcweir
2053cdf0e10cSrcweir ::vos::ORef < SwAccessibleContext > xAccImpl(
2054cdf0e10cSrcweir static_cast< SwAccessibleContext * >( xAcc.get() ) );
2055cdf0e10cSrcweir
2056cdf0e10cSrcweir return xAccImpl;
2057cdf0e10cSrcweir }
2058cdf0e10cSrcweir
GetContext(const SdrObject * pObj,SwAccessibleContext * pParentImpl,sal_Bool bCreate)2059cdf0e10cSrcweir uno::Reference< XAccessible> SwAccessibleMap::GetContext(
2060cdf0e10cSrcweir const SdrObject *pObj,
2061cdf0e10cSrcweir SwAccessibleContext *pParentImpl,
2062cdf0e10cSrcweir sal_Bool bCreate )
2063cdf0e10cSrcweir {
2064cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
2065cdf0e10cSrcweir uno::Reference < XAccessible > xOldCursorAcc;
2066cdf0e10cSrcweir
2067cdf0e10cSrcweir {
2068cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2069cdf0e10cSrcweir
2070cdf0e10cSrcweir if( !mpShapeMap && bCreate )
2071cdf0e10cSrcweir mpShapeMap = new SwAccessibleShapeMap_Impl( this );
2072cdf0e10cSrcweir if( mpShapeMap )
2073cdf0e10cSrcweir {
2074cdf0e10cSrcweir SwAccessibleShapeMap_Impl::iterator aIter =
2075cdf0e10cSrcweir mpShapeMap->find( pObj );
2076cdf0e10cSrcweir if( aIter != mpShapeMap->end() )
2077cdf0e10cSrcweir xAcc = (*aIter).second;
2078cdf0e10cSrcweir
2079cdf0e10cSrcweir if( !xAcc.is() && bCreate )
2080cdf0e10cSrcweir {
2081cdf0e10cSrcweir ::accessibility::AccessibleShape *pAcc = 0;
2082cdf0e10cSrcweir uno::Reference < drawing::XShape > xShape(
2083cdf0e10cSrcweir const_cast< SdrObject * >( pObj )->getUnoShape(),
2084cdf0e10cSrcweir uno::UNO_QUERY );
2085cdf0e10cSrcweir if( xShape.is() )
2086cdf0e10cSrcweir {
2087cdf0e10cSrcweir ::accessibility::ShapeTypeHandler& rShapeTypeHandler =
2088cdf0e10cSrcweir ::accessibility::ShapeTypeHandler::Instance();
2089cdf0e10cSrcweir uno::Reference < XAccessible > xParent( pParentImpl );
2090cdf0e10cSrcweir ::accessibility::AccessibleShapeInfo aShapeInfo(
2091cdf0e10cSrcweir xShape, xParent, this );
2092cdf0e10cSrcweir
2093cdf0e10cSrcweir pAcc = rShapeTypeHandler.CreateAccessibleObject(
2094cdf0e10cSrcweir aShapeInfo, mpShapeMap->GetInfo() );
2095cdf0e10cSrcweir }
2096cdf0e10cSrcweir xAcc = pAcc;
2097cdf0e10cSrcweir
2098cdf0e10cSrcweir ASSERT( xAcc.is(), "unknown shape type" );
2099cdf0e10cSrcweir if( xAcc.is() )
2100cdf0e10cSrcweir {
2101cdf0e10cSrcweir pAcc->Init();
2102cdf0e10cSrcweir if( aIter != mpShapeMap->end() )
2103cdf0e10cSrcweir {
2104cdf0e10cSrcweir (*aIter).second = xAcc;
2105cdf0e10cSrcweir }
2106cdf0e10cSrcweir else
2107cdf0e10cSrcweir {
2108cdf0e10cSrcweir SwAccessibleShapeMap_Impl::value_type aEntry( pObj,
2109cdf0e10cSrcweir xAcc );
2110cdf0e10cSrcweir mpShapeMap->insert( aEntry );
2111cdf0e10cSrcweir }
2112cdf0e10cSrcweir // TODO: focus!!!
2113cdf0e10cSrcweir }
2114ca62e2c2SSteve Yin if (xAcc.is())
2115ca62e2c2SSteve Yin AddGroupContext(pObj, xAcc);
2116cdf0e10cSrcweir }
2117cdf0e10cSrcweir }
2118cdf0e10cSrcweir }
2119cdf0e10cSrcweir
2120cdf0e10cSrcweir // Invalidate focus for old object when map is not locked
2121cdf0e10cSrcweir if( xOldCursorAcc.is() )
2122cdf0e10cSrcweir InvalidateCursorPosition( xOldCursorAcc );
2123cdf0e10cSrcweir
2124cdf0e10cSrcweir return xAcc;
2125cdf0e10cSrcweir }
IsInSameLevel(const SdrObject * pObj,const SwFEShell * pFESh)2126ca62e2c2SSteve Yin sal_Bool SwAccessibleMap::IsInSameLevel(const SdrObject* pObj, const SwFEShell* pFESh)
2127ca62e2c2SSteve Yin {
2128ca62e2c2SSteve Yin if (pFESh)
2129ca62e2c2SSteve Yin return pFESh->IsObjSameLevelWithMarked(pObj);
2130ca62e2c2SSteve Yin return sal_False;
2131ca62e2c2SSteve Yin }
AddShapeContext(const SdrObject * pObj,uno::Reference<XAccessible> xAccShape)2132ca62e2c2SSteve Yin void SwAccessibleMap::AddShapeContext(const SdrObject *pObj, uno::Reference < XAccessible > xAccShape)
2133ca62e2c2SSteve Yin {
2134ca62e2c2SSteve Yin vos::OGuard aGuard( maMutex );
2135ca62e2c2SSteve Yin
2136ca62e2c2SSteve Yin if( mpShapeMap )
2137ca62e2c2SSteve Yin {
2138ca62e2c2SSteve Yin SwAccessibleShapeMap_Impl::value_type aEntry( pObj, xAccShape );
2139ca62e2c2SSteve Yin mpShapeMap->insert( aEntry );
2140ca62e2c2SSteve Yin }
2141ca62e2c2SSteve Yin
2142ca62e2c2SSteve Yin }
2143ca62e2c2SSteve Yin
2144ca62e2c2SSteve Yin //Added by yanjun for sym2_6407
RemoveGroupContext(const SdrObject * pParentObj,::com::sun::star::uno::Reference<::com::sun::star::accessibility::XAccessible> xAccParent)2145ca62e2c2SSteve Yin void SwAccessibleMap::RemoveGroupContext(const SdrObject *pParentObj, ::com::sun::star::uno::Reference < ::com::sun::star::accessibility::XAccessible > xAccParent)
2146ca62e2c2SSteve Yin {
2147ca62e2c2SSteve Yin vos::OGuard aGuard( maMutex );
2148ca62e2c2SSteve Yin if (mpShapeMap && pParentObj && pParentObj->IsGroupObject() && xAccParent.is())
2149ca62e2c2SSteve Yin {
2150ca62e2c2SSteve Yin uno::Reference < XAccessibleContext > xContext = xAccParent->getAccessibleContext();
2151ca62e2c2SSteve Yin if (xContext.is())
2152ca62e2c2SSteve Yin {
2153ca62e2c2SSteve Yin for (sal_Int32 i = 0; i < xContext->getAccessibleChildCount(); ++i)
2154ca62e2c2SSteve Yin {
2155ca62e2c2SSteve Yin uno::Reference < XAccessible > xChild = xContext->getAccessibleChild(i);
2156ca62e2c2SSteve Yin if (xChild.is())
2157ca62e2c2SSteve Yin {
2158ca62e2c2SSteve Yin uno::Reference < XAccessibleContext > xChildContext = xChild->getAccessibleContext();
2159ca62e2c2SSteve Yin if (xChildContext.is())
2160ca62e2c2SSteve Yin {
2161ca62e2c2SSteve Yin if (xChildContext->getAccessibleRole() == AccessibleRole::SHAPE)
2162ca62e2c2SSteve Yin {
2163ca62e2c2SSteve Yin ::accessibility::AccessibleShape* pAccShape = static_cast < ::accessibility::AccessibleShape* >( xChild.get());
2164ca62e2c2SSteve Yin uno::Reference < drawing::XShape > xShape = pAccShape->GetXShape();
2165ca62e2c2SSteve Yin if (xShape.is())
2166ca62e2c2SSteve Yin {
2167ca62e2c2SSteve Yin SdrObject* pObj = GetSdrObjectFromXShape(xShape);
2168ca62e2c2SSteve Yin if (pObj)
2169ca62e2c2SSteve Yin RemoveContext(pObj);
2170ca62e2c2SSteve Yin }
2171ca62e2c2SSteve Yin }
2172ca62e2c2SSteve Yin }
2173ca62e2c2SSteve Yin }
2174ca62e2c2SSteve Yin }
2175ca62e2c2SSteve Yin }
2176ca62e2c2SSteve Yin }
2177ca62e2c2SSteve Yin }
2178ca62e2c2SSteve Yin //End
2179ca62e2c2SSteve Yin
2180ca62e2c2SSteve Yin
AddGroupContext(const SdrObject * pParentObj,uno::Reference<XAccessible> xAccParent)2181ca62e2c2SSteve Yin void SwAccessibleMap::AddGroupContext(const SdrObject *pParentObj, uno::Reference < XAccessible > xAccParent)
2182ca62e2c2SSteve Yin {
2183ca62e2c2SSteve Yin vos::OGuard aGuard( maMutex );
2184ca62e2c2SSteve Yin if( mpShapeMap )
2185ca62e2c2SSteve Yin {
2186ca62e2c2SSteve Yin //here get all the sub list.
2187ca62e2c2SSteve Yin if (pParentObj->IsGroupObject())
2188ca62e2c2SSteve Yin {
2189ca62e2c2SSteve Yin if (xAccParent.is())
2190ca62e2c2SSteve Yin {
2191ca62e2c2SSteve Yin uno::Reference < XAccessibleContext > xContext = xAccParent->getAccessibleContext();
2192ca62e2c2SSteve Yin if (xContext.is())
2193ca62e2c2SSteve Yin {
2194ca62e2c2SSteve Yin sal_Int32 nChildren = xContext->getAccessibleChildCount();
2195ca62e2c2SSteve Yin for(sal_Int32 i = 0; i<nChildren; i++)
2196ca62e2c2SSteve Yin {
2197ca62e2c2SSteve Yin uno::Reference < XAccessible > xChild = xContext->getAccessibleChild(i);
2198ca62e2c2SSteve Yin if (xChild.is())
2199ca62e2c2SSteve Yin {
2200ca62e2c2SSteve Yin uno::Reference < XAccessibleContext > xChildContext = xChild->getAccessibleContext();
2201ca62e2c2SSteve Yin if (xChildContext.is())
2202ca62e2c2SSteve Yin {
2203ca62e2c2SSteve Yin short nRole = xChildContext->getAccessibleRole();
2204ca62e2c2SSteve Yin if (nRole == AccessibleRole::SHAPE)
2205ca62e2c2SSteve Yin {
2206ca62e2c2SSteve Yin ::accessibility::AccessibleShape* pAccShape = static_cast < ::accessibility::AccessibleShape* >( xChild.get());
2207ca62e2c2SSteve Yin uno::Reference < drawing::XShape > xShape = pAccShape->GetXShape();
2208ca62e2c2SSteve Yin if (xShape.is())
2209ca62e2c2SSteve Yin {
2210ca62e2c2SSteve Yin SdrObject* pObj = GetSdrObjectFromXShape(xShape);
2211ca62e2c2SSteve Yin AddShapeContext(pObj, xChild);
2212ca62e2c2SSteve Yin AddGroupContext(pObj,xChild);
2213ca62e2c2SSteve Yin }
2214ca62e2c2SSteve Yin }
2215ca62e2c2SSteve Yin }
2216ca62e2c2SSteve Yin }
2217ca62e2c2SSteve Yin }
2218ca62e2c2SSteve Yin }
2219ca62e2c2SSteve Yin }
2220ca62e2c2SSteve Yin }
2221ca62e2c2SSteve Yin }
2222ca62e2c2SSteve Yin }
2223cdf0e10cSrcweir
GetContextImpl(const SdrObject * pObj,SwAccessibleContext * pParentImpl,sal_Bool bCreate)2224cdf0e10cSrcweir ::vos::ORef < ::accessibility::AccessibleShape > SwAccessibleMap::GetContextImpl(
2225cdf0e10cSrcweir const SdrObject *pObj,
2226cdf0e10cSrcweir SwAccessibleContext *pParentImpl,
2227cdf0e10cSrcweir sal_Bool bCreate )
2228cdf0e10cSrcweir {
2229cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( GetContext( pObj, pParentImpl, bCreate ) );
2230cdf0e10cSrcweir
2231cdf0e10cSrcweir ::vos::ORef < ::accessibility::AccessibleShape > xAccImpl(
2232cdf0e10cSrcweir static_cast< ::accessibility::AccessibleShape* >( xAcc.get() ) );
2233cdf0e10cSrcweir
2234cdf0e10cSrcweir return xAccImpl;
2235cdf0e10cSrcweir }
2236cdf0e10cSrcweir
2237cdf0e10cSrcweir
RemoveContext(const SwFrm * pFrm)2238cdf0e10cSrcweir void SwAccessibleMap::RemoveContext( const SwFrm *pFrm )
2239cdf0e10cSrcweir {
2240cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2241cdf0e10cSrcweir
2242cdf0e10cSrcweir if( mpFrmMap )
2243cdf0e10cSrcweir {
2244cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2245cdf0e10cSrcweir mpFrmMap->find( pFrm );
2246cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2247cdf0e10cSrcweir {
2248cdf0e10cSrcweir mpFrmMap->erase( aIter );
2249cdf0e10cSrcweir
2250cdf0e10cSrcweir // Remove reference to old caret object. Though mxCursorContext
2251cdf0e10cSrcweir // is a weak reference and cleared automatically, clearing it
2252cdf0e10cSrcweir // directly makes sure to not keep a defunctional object.
2253cdf0e10cSrcweir uno::Reference < XAccessible > xOldAcc( mxCursorContext );
2254cdf0e10cSrcweir if( xOldAcc.is() )
2255cdf0e10cSrcweir {
2256cdf0e10cSrcweir SwAccessibleContext *pOldAccImpl =
2257cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xOldAcc.get() );
2258cdf0e10cSrcweir ASSERT( pOldAccImpl->GetFrm(), "old caret context is disposed" );
2259cdf0e10cSrcweir if( pOldAccImpl->GetFrm() == pFrm )
2260cdf0e10cSrcweir {
2261cdf0e10cSrcweir xOldAcc.clear(); // get an empty ref
2262cdf0e10cSrcweir mxCursorContext = xOldAcc;
2263cdf0e10cSrcweir }
2264cdf0e10cSrcweir }
2265cdf0e10cSrcweir
2266cdf0e10cSrcweir if( mpFrmMap->empty() )
2267cdf0e10cSrcweir {
2268cdf0e10cSrcweir delete mpFrmMap;
2269cdf0e10cSrcweir mpFrmMap = 0;
2270cdf0e10cSrcweir }
2271cdf0e10cSrcweir }
2272cdf0e10cSrcweir }
2273cdf0e10cSrcweir }
2274cdf0e10cSrcweir
RemoveContext(const SdrObject * pObj)2275cdf0e10cSrcweir void SwAccessibleMap::RemoveContext( const SdrObject *pObj )
2276cdf0e10cSrcweir {
2277cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2278cdf0e10cSrcweir
2279cdf0e10cSrcweir if( mpShapeMap )
2280cdf0e10cSrcweir {
2281cdf0e10cSrcweir SwAccessibleShapeMap_Impl::iterator aIter =
2282cdf0e10cSrcweir mpShapeMap->find( pObj );
2283cdf0e10cSrcweir if( aIter != mpShapeMap->end() )
2284cdf0e10cSrcweir {
2285ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
2286cdf0e10cSrcweir mpShapeMap->erase( aIter );
2287ca62e2c2SSteve Yin RemoveGroupContext(pObj, xAcc);
2288cdf0e10cSrcweir // The shape selection flag is not cleared, but one might do
2289cdf0e10cSrcweir // so but has to make sure that the removed context is the one
2290cdf0e10cSrcweir // that is selected.
2291ca62e2c2SSteve Yin
2292ca62e2c2SSteve Yin if( mpShapeMap && mpShapeMap->empty() )
2293cdf0e10cSrcweir {
2294cdf0e10cSrcweir delete mpShapeMap;
2295cdf0e10cSrcweir mpShapeMap = 0;
2296cdf0e10cSrcweir }
2297cdf0e10cSrcweir }
2298cdf0e10cSrcweir }
2299cdf0e10cSrcweir }
2300cdf0e10cSrcweir
2301cdf0e10cSrcweir
Dispose(const SwFrm * pFrm,const SdrObject * pObj,Window * pWindow,sal_Bool bRecursive)2302cdf0e10cSrcweir void SwAccessibleMap::Dispose( const SwFrm *pFrm,
2303cdf0e10cSrcweir const SdrObject *pObj,
2304cdf0e10cSrcweir Window* pWindow,
2305cdf0e10cSrcweir sal_Bool bRecursive )
2306cdf0e10cSrcweir {
2307cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( pFrm, pObj, pWindow );
2308cdf0e10cSrcweir
2309cdf0e10cSrcweir // Indeed, the following assert checks the frame's accessible flag,
2310cdf0e10cSrcweir // because that's the one that is evaluated in the layout. The frame
2311cdf0e10cSrcweir // might not be accessible anyway. That's the case for cell frames that
2312cdf0e10cSrcweir // contain further cells.
2313cdf0e10cSrcweir ASSERT( !aFrmOrObj.GetSwFrm() || aFrmOrObj.GetSwFrm()->IsAccessibleFrm(),
2314cdf0e10cSrcweir "non accessible frame should be disposed" );
2315cdf0e10cSrcweir
2316cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
2317cdf0e10cSrcweir {
2318cdf0e10cSrcweir ::vos::ORef< SwAccessibleContext > xAccImpl;
2319cdf0e10cSrcweir ::vos::ORef< SwAccessibleContext > xParentAccImpl;
2320cdf0e10cSrcweir ::vos::ORef< ::accessibility::AccessibleShape > xShapeAccImpl;
2321cdf0e10cSrcweir // get accessible context for frame
2322cdf0e10cSrcweir {
2323cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2324cdf0e10cSrcweir
2325cdf0e10cSrcweir // First of all look for an accessible context for a frame
2326cdf0e10cSrcweir if( aFrmOrObj.GetSwFrm() && mpFrmMap )
2327cdf0e10cSrcweir {
2328cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2329cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
2330cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2331cdf0e10cSrcweir {
2332cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
2333cdf0e10cSrcweir xAccImpl =
2334cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2335cdf0e10cSrcweir }
2336cdf0e10cSrcweir }
2337cdf0e10cSrcweir if( !xAccImpl.isValid() && mpFrmMap )
2338cdf0e10cSrcweir {
2339cdf0e10cSrcweir // If there is none, look if the parent is accessible.
2340cdf0e10cSrcweir const SwFrm *pParent =
2341cdf0e10cSrcweir SwAccessibleFrame::GetParent( aFrmOrObj,
2342cdf0e10cSrcweir GetShell()->IsPreView());
2343cdf0e10cSrcweir
2344cdf0e10cSrcweir if( pParent )
2345cdf0e10cSrcweir {
2346cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2347cdf0e10cSrcweir mpFrmMap->find( pParent );
2348cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2349cdf0e10cSrcweir {
2350cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
2351cdf0e10cSrcweir xParentAccImpl =
2352cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2353cdf0e10cSrcweir }
2354cdf0e10cSrcweir }
2355cdf0e10cSrcweir }
2356cdf0e10cSrcweir if( !xParentAccImpl.isValid() && !aFrmOrObj.GetSwFrm() &&
2357cdf0e10cSrcweir mpShapeMap )
2358cdf0e10cSrcweir {
2359cdf0e10cSrcweir SwAccessibleShapeMap_Impl::iterator aIter =
2360cdf0e10cSrcweir mpShapeMap->find( aFrmOrObj.GetDrawObject() );
2361cdf0e10cSrcweir if( aIter != mpShapeMap->end() )
2362cdf0e10cSrcweir {
2363cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
2364cdf0e10cSrcweir xShapeAccImpl =
2365cdf0e10cSrcweir static_cast< ::accessibility::AccessibleShape *>( xAcc.get() );
2366cdf0e10cSrcweir }
2367cdf0e10cSrcweir }
2368cdf0e10cSrcweir if( pObj && GetShell()->ActionPend() &&
2369cdf0e10cSrcweir (xParentAccImpl.isValid() || xShapeAccImpl.isValid()) )
2370cdf0e10cSrcweir {
2371cdf0e10cSrcweir // Keep a reference to the XShape to avoid that it
2372cdf0e10cSrcweir // is deleted with a SwFrmFmt::Modify.
2373cdf0e10cSrcweir uno::Reference < drawing::XShape > xShape(
2374cdf0e10cSrcweir const_cast< SdrObject * >( pObj )->getUnoShape(),
2375cdf0e10cSrcweir uno::UNO_QUERY );
2376cdf0e10cSrcweir if( xShape.is() )
2377cdf0e10cSrcweir {
2378cdf0e10cSrcweir if( !mpShapes )
2379cdf0e10cSrcweir mpShapes = new SwShapeList_Impl;
2380cdf0e10cSrcweir mpShapes->push_back( xShape );
2381cdf0e10cSrcweir }
2382cdf0e10cSrcweir }
2383cdf0e10cSrcweir }
2384cdf0e10cSrcweir
2385cdf0e10cSrcweir // remove events stored for the frame
2386cdf0e10cSrcweir {
2387cdf0e10cSrcweir vos::OGuard aGuard( maEventMutex );
2388cdf0e10cSrcweir if( mpEvents )
2389cdf0e10cSrcweir {
2390cdf0e10cSrcweir SwAccessibleEventMap_Impl::iterator aIter =
2391cdf0e10cSrcweir mpEventMap->find( aFrmOrObj );
2392cdf0e10cSrcweir if( aIter != mpEventMap->end() )
2393cdf0e10cSrcweir {
2394cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent(
2395cdf0e10cSrcweir SwAccessibleEvent_Impl::DISPOSE, aFrmOrObj );
2396cdf0e10cSrcweir AppendEvent( aEvent );
2397cdf0e10cSrcweir }
2398cdf0e10cSrcweir }
2399cdf0e10cSrcweir }
2400cdf0e10cSrcweir
2401cdf0e10cSrcweir // If the frame is accessible and there is a context for it, dispose
2402cdf0e10cSrcweir // the frame. If the frame is no context for it but disposing should
2403cdf0e10cSrcweir // take place recursive, the frame's children have to be disposed
2404cdf0e10cSrcweir // anyway, so we have to create the context then.
2405cdf0e10cSrcweir if( xAccImpl.isValid() )
2406cdf0e10cSrcweir {
2407cdf0e10cSrcweir xAccImpl->Dispose( bRecursive );
2408cdf0e10cSrcweir }
2409cdf0e10cSrcweir else if( xParentAccImpl.isValid() )
2410cdf0e10cSrcweir {
2411cdf0e10cSrcweir // If the frame is a cell frame, the table must be notified.
2412cdf0e10cSrcweir // If we are in an action, a table model change event will
2413cdf0e10cSrcweir // be broadcasted at the end of the action to give the table
2414cdf0e10cSrcweir // a chance to generate a single table change event.
2415cdf0e10cSrcweir
2416cdf0e10cSrcweir xParentAccImpl->DisposeChild( aFrmOrObj, bRecursive );
2417cdf0e10cSrcweir }
2418cdf0e10cSrcweir else if( xShapeAccImpl.isValid() )
2419cdf0e10cSrcweir {
2420cdf0e10cSrcweir RemoveContext( aFrmOrObj.GetDrawObject() );
2421cdf0e10cSrcweir xShapeAccImpl->dispose();
2422cdf0e10cSrcweir }
2423cdf0e10cSrcweir
2424cdf0e10cSrcweir if( mpPreview && pFrm && pFrm->IsPageFrm() )
2425cdf0e10cSrcweir mpPreview->DisposePage( static_cast< const SwPageFrm *>( pFrm ) );
2426cdf0e10cSrcweir }
2427cdf0e10cSrcweir }
2428cdf0e10cSrcweir
InvalidatePosOrSize(const SwFrm * pFrm,const SdrObject * pObj,Window * pWindow,const SwRect & rOldBox)2429cdf0e10cSrcweir void SwAccessibleMap::InvalidatePosOrSize( const SwFrm *pFrm,
2430cdf0e10cSrcweir const SdrObject *pObj,
2431cdf0e10cSrcweir Window* pWindow,
2432cdf0e10cSrcweir const SwRect& rOldBox )
2433cdf0e10cSrcweir {
2434cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( pFrm, pObj, pWindow );
2435cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
2436cdf0e10cSrcweir {
2437cdf0e10cSrcweir ::vos::ORef< SwAccessibleContext > xAccImpl;
2438cdf0e10cSrcweir ::vos::ORef< SwAccessibleContext > xParentAccImpl;
2439*90386390SHerbert Dürr const SwFrm *pParent =NULL;
2440*90386390SHerbert Dürr {
2441cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2442cdf0e10cSrcweir
2443cdf0e10cSrcweir if( mpFrmMap )
2444cdf0e10cSrcweir {
2445cdf0e10cSrcweir if( aFrmOrObj.GetSwFrm() )
2446cdf0e10cSrcweir {
2447cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2448cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
2449cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2450cdf0e10cSrcweir {
2451cdf0e10cSrcweir // If there is an accesible object already it is
2452cdf0e10cSrcweir // notified directly.
2453cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
2454cdf0e10cSrcweir xAccImpl =
2455cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2456cdf0e10cSrcweir }
2457cdf0e10cSrcweir }
2458cdf0e10cSrcweir if( !xAccImpl.isValid() )
2459cdf0e10cSrcweir {
2460cdf0e10cSrcweir // Otherwise we look if the parent is accessible.
2461cdf0e10cSrcweir // If not, there is nothing to do.
2462*90386390SHerbert Dürr pParent = SwAccessibleFrame::GetParent( aFrmOrObj,
2463cdf0e10cSrcweir GetShell()->IsPreView());
2464cdf0e10cSrcweir
2465cdf0e10cSrcweir if( pParent )
2466cdf0e10cSrcweir {
2467cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2468cdf0e10cSrcweir mpFrmMap->find( pParent );
2469cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2470cdf0e10cSrcweir {
2471cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
2472cdf0e10cSrcweir xParentAccImpl =
2473cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2474cdf0e10cSrcweir }
2475cdf0e10cSrcweir }
2476cdf0e10cSrcweir }
2477cdf0e10cSrcweir }
2478cdf0e10cSrcweir }
2479cdf0e10cSrcweir
2480cdf0e10cSrcweir if( xAccImpl.isValid() )
2481cdf0e10cSrcweir {
2482cdf0e10cSrcweir if( GetShell()->ActionPend() )
2483cdf0e10cSrcweir {
2484cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent(
2485cdf0e10cSrcweir SwAccessibleEvent_Impl::POS_CHANGED, xAccImpl.getBodyPtr(),
2486cdf0e10cSrcweir aFrmOrObj, rOldBox );
2487cdf0e10cSrcweir AppendEvent( aEvent );
2488cdf0e10cSrcweir }
2489cdf0e10cSrcweir else
2490cdf0e10cSrcweir {
2491cdf0e10cSrcweir FireEvents();
2492cdf0e10cSrcweir xAccImpl->InvalidatePosOrSize( rOldBox );
2493cdf0e10cSrcweir }
2494cdf0e10cSrcweir }
2495cdf0e10cSrcweir else if( xParentAccImpl.isValid() )
2496cdf0e10cSrcweir {
2497cdf0e10cSrcweir if( GetShell()->ActionPend() )
2498cdf0e10cSrcweir {
2499cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent(
2500cdf0e10cSrcweir SwAccessibleEvent_Impl::CHILD_POS_CHANGED,
2501cdf0e10cSrcweir xParentAccImpl.getBodyPtr(), aFrmOrObj, rOldBox );
2502cdf0e10cSrcweir AppendEvent( aEvent );
2503cdf0e10cSrcweir }
2504cdf0e10cSrcweir else
2505cdf0e10cSrcweir {
2506cdf0e10cSrcweir FireEvents();
2507cdf0e10cSrcweir xParentAccImpl->InvalidateChildPosOrSize( aFrmOrObj,
2508cdf0e10cSrcweir rOldBox );
2509cdf0e10cSrcweir }
2510cdf0e10cSrcweir }
2511ca62e2c2SSteve Yin else if(pParent)
2512ca62e2c2SSteve Yin {
2513ca62e2c2SSteve Yin /*
2514ca62e2c2SSteve Yin For child graphic and it's parent paragraph,if split 2 graphic to 2 paragraph,
2515ca62e2c2SSteve Yin will delete one graphic swfrm and new create 1 graphic swfrm ,
2516ca62e2c2SSteve Yin then the new paragraph and the new graphic SwFrm will add .
2517ca62e2c2SSteve Yin but when add graphic SwFrm ,the accessible of the new Paragraph is not created yet.
2518ca62e2c2SSteve Yin so the new graphic accessible 'parent is NULL,
2519ca62e2c2SSteve Yin so run here: save the parent's SwFrm not the accessible object parent,
2520ca62e2c2SSteve Yin */
2521ca62e2c2SSteve Yin sal_Bool bIsValidFrm = sal_False;
2522ca62e2c2SSteve Yin sal_Bool bIsTxtParent = sal_False;
2523ca62e2c2SSteve Yin if (aFrmOrObj.GetSwFrm())
2524ca62e2c2SSteve Yin {
2525ca62e2c2SSteve Yin int nType = pFrm->GetType();
2526ca62e2c2SSteve Yin if ( FRM_FLY == nType )
2527ca62e2c2SSteve Yin {
2528ca62e2c2SSteve Yin bIsValidFrm =sal_True;
2529ca62e2c2SSteve Yin }
2530ca62e2c2SSteve Yin }
2531ca62e2c2SSteve Yin else if(pObj)
2532ca62e2c2SSteve Yin {
2533ca62e2c2SSteve Yin int nType = pParent->GetType();
2534ca62e2c2SSteve Yin if (FRM_TXT == nType)
2535ca62e2c2SSteve Yin {
2536ca62e2c2SSteve Yin bIsTxtParent =sal_True;
2537ca62e2c2SSteve Yin }
2538ca62e2c2SSteve Yin }
2539ca62e2c2SSteve Yin // sal_Bool bIsVisibleChildrenOnly =aFrmOrObj.IsVisibleChildrenOnly() ;
2540ca62e2c2SSteve Yin // sal_Bool bIsBoundAsChar =aFrmOrObj.IsBoundAsChar() ;//bIsVisibleChildrenOnly && bIsBoundAsChar &&
2541ca62e2c2SSteve Yin if((bIsValidFrm || bIsTxtParent) )
2542ca62e2c2SSteve Yin {
2543ca62e2c2SSteve Yin if( GetShell()->ActionPend() )
2544ca62e2c2SSteve Yin {
2545ca62e2c2SSteve Yin SwAccessibleEvent_Impl aEvent(
2546ca62e2c2SSteve Yin SwAccessibleEvent_Impl::CHILD_POS_CHANGED,
2547ca62e2c2SSteve Yin pParent, aFrmOrObj, rOldBox );
2548ca62e2c2SSteve Yin AppendEvent( aEvent );
2549ca62e2c2SSteve Yin }
2550ca62e2c2SSteve Yin else
2551ca62e2c2SSteve Yin {
2552ca62e2c2SSteve Yin OSL_ENSURE(false,"");
2553ca62e2c2SSteve Yin }
2554ca62e2c2SSteve Yin }
2555ca62e2c2SSteve Yin }
2556cdf0e10cSrcweir }
2557cdf0e10cSrcweir }
2558cdf0e10cSrcweir
InvalidateContent(const SwFrm * pFrm)2559cdf0e10cSrcweir void SwAccessibleMap::InvalidateContent( const SwFrm *pFrm )
2560cdf0e10cSrcweir {
2561cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( pFrm );
2562cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
2563cdf0e10cSrcweir {
2564cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
2565cdf0e10cSrcweir {
2566cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2567cdf0e10cSrcweir
2568cdf0e10cSrcweir if( mpFrmMap )
2569cdf0e10cSrcweir {
2570cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2571cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
2572cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2573cdf0e10cSrcweir xAcc = (*aIter).second;
2574cdf0e10cSrcweir }
2575cdf0e10cSrcweir }
2576cdf0e10cSrcweir
2577cdf0e10cSrcweir if( xAcc.is() )
2578cdf0e10cSrcweir {
2579cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
2580cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2581cdf0e10cSrcweir if( GetShell()->ActionPend() )
2582cdf0e10cSrcweir {
2583cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent(
2584cdf0e10cSrcweir SwAccessibleEvent_Impl::INVALID_CONTENT, pAccImpl,
2585cdf0e10cSrcweir aFrmOrObj );
2586cdf0e10cSrcweir AppendEvent( aEvent );
2587cdf0e10cSrcweir }
2588cdf0e10cSrcweir else
2589cdf0e10cSrcweir {
2590cdf0e10cSrcweir FireEvents();
2591cdf0e10cSrcweir pAccImpl->InvalidateContent();
2592cdf0e10cSrcweir }
2593cdf0e10cSrcweir }
2594cdf0e10cSrcweir }
2595cdf0e10cSrcweir }
2596cdf0e10cSrcweir
2597cdf0e10cSrcweir // --> OD 2009-01-06 #i88069#
InvalidateAttr(const SwTxtFrm & rTxtFrm)2598cdf0e10cSrcweir void SwAccessibleMap::InvalidateAttr( const SwTxtFrm& rTxtFrm )
2599cdf0e10cSrcweir {
2600cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( &rTxtFrm );
2601cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
2602cdf0e10cSrcweir {
2603cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
2604cdf0e10cSrcweir {
2605cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2606cdf0e10cSrcweir
2607cdf0e10cSrcweir if( mpFrmMap )
2608cdf0e10cSrcweir {
2609cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2610cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
2611cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2612cdf0e10cSrcweir xAcc = (*aIter).second;
2613cdf0e10cSrcweir }
2614cdf0e10cSrcweir }
2615cdf0e10cSrcweir
2616cdf0e10cSrcweir if( xAcc.is() )
2617cdf0e10cSrcweir {
2618cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
2619cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2620cdf0e10cSrcweir if( GetShell()->ActionPend() )
2621cdf0e10cSrcweir {
2622cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent( SwAccessibleEvent_Impl::INVALID_ATTR,
2623cdf0e10cSrcweir pAccImpl, aFrmOrObj );
2624cdf0e10cSrcweir aEvent.SetStates( ACC_STATE_TEXT_ATTRIBUTE_CHANGED );
2625cdf0e10cSrcweir AppendEvent( aEvent );
2626cdf0e10cSrcweir }
2627cdf0e10cSrcweir else
2628cdf0e10cSrcweir {
2629cdf0e10cSrcweir FireEvents();
2630cdf0e10cSrcweir pAccImpl->InvalidateAttr();
2631cdf0e10cSrcweir }
2632cdf0e10cSrcweir }
2633cdf0e10cSrcweir }
2634cdf0e10cSrcweir }
2635cdf0e10cSrcweir // <--
2636cdf0e10cSrcweir
InvalidateCursorPosition(const SwFrm * pFrm)2637cdf0e10cSrcweir void SwAccessibleMap::InvalidateCursorPosition( const SwFrm *pFrm )
2638cdf0e10cSrcweir {
2639cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( pFrm );
2640cdf0e10cSrcweir sal_Bool bShapeSelected = sal_False;
2641cdf0e10cSrcweir const ViewShell *pVSh = GetShell();
2642cdf0e10cSrcweir if( pVSh->ISA( SwCrsrShell ) )
2643cdf0e10cSrcweir {
2644cdf0e10cSrcweir const SwCrsrShell *pCSh = static_cast< const SwCrsrShell * >( pVSh );
2645cdf0e10cSrcweir if( pCSh->IsTableMode() )
2646cdf0e10cSrcweir {
2647cdf0e10cSrcweir while( aFrmOrObj.GetSwFrm() && !aFrmOrObj.GetSwFrm()->IsCellFrm() )
2648cdf0e10cSrcweir aFrmOrObj = aFrmOrObj.GetSwFrm()->GetUpper();
2649cdf0e10cSrcweir }
2650cdf0e10cSrcweir else if( pVSh->ISA( SwFEShell ) )
2651cdf0e10cSrcweir {
2652cdf0e10cSrcweir sal_uInt16 nObjCount;
2653cdf0e10cSrcweir const SwFEShell *pFESh = static_cast< const SwFEShell * >( pVSh );
2654cdf0e10cSrcweir const SwFrm *pFlyFrm = pFESh->GetCurrFlyFrm();
2655cdf0e10cSrcweir if( pFlyFrm )
2656cdf0e10cSrcweir {
2657cdf0e10cSrcweir ASSERT( !pFrm || pFrm->FindFlyFrm() == pFlyFrm,
2658cdf0e10cSrcweir "cursor is not contained in fly frame" );
2659cdf0e10cSrcweir aFrmOrObj = pFlyFrm;
2660cdf0e10cSrcweir }
2661cdf0e10cSrcweir else if( (nObjCount = pFESh->IsObjSelected()) > 0 )
2662cdf0e10cSrcweir {
2663cdf0e10cSrcweir bShapeSelected = sal_True;
2664cdf0e10cSrcweir aFrmOrObj = static_cast<const SwFrm *>( 0 );
2665cdf0e10cSrcweir }
2666cdf0e10cSrcweir }
2667cdf0e10cSrcweir }
2668cdf0e10cSrcweir
2669cdf0e10cSrcweir ASSERT( bShapeSelected || aFrmOrObj.IsAccessible(GetShell()->IsPreView()),
2670cdf0e10cSrcweir "frame is not accessible" );
2671cdf0e10cSrcweir
2672cdf0e10cSrcweir uno::Reference < XAccessible > xOldAcc;
2673cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
2674cdf0e10cSrcweir sal_Bool bOldShapeSelected = sal_False;
2675cdf0e10cSrcweir
2676cdf0e10cSrcweir {
2677cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2678cdf0e10cSrcweir
2679cdf0e10cSrcweir xOldAcc = mxCursorContext;
2680cdf0e10cSrcweir mxCursorContext = xAcc; // clear reference
2681cdf0e10cSrcweir
2682cdf0e10cSrcweir bOldShapeSelected = mbShapeSelected;
2683cdf0e10cSrcweir mbShapeSelected = bShapeSelected;
2684cdf0e10cSrcweir
2685cdf0e10cSrcweir if( aFrmOrObj.GetSwFrm() && mpFrmMap )
2686cdf0e10cSrcweir {
2687cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
2688cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
2689cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
2690cdf0e10cSrcweir xAcc = (*aIter).second;
2691ca62e2c2SSteve Yin else
2692ca62e2c2SSteve Yin {
2693ca62e2c2SSteve Yin SwRect rcEmpty;
2694ca62e2c2SSteve Yin const SwTabFrm* pTabFrm = aFrmOrObj.GetSwFrm()->FindTabFrm();
2695ca62e2c2SSteve Yin if (pTabFrm)
2696ca62e2c2SSteve Yin {
2697ca62e2c2SSteve Yin InvalidatePosOrSize(pTabFrm,0,0,rcEmpty);
2698ca62e2c2SSteve Yin }
2699ca62e2c2SSteve Yin else
2700ca62e2c2SSteve Yin {
2701ca62e2c2SSteve Yin InvalidatePosOrSize(aFrmOrObj.GetSwFrm(),0,0,rcEmpty);
2702ca62e2c2SSteve Yin }
2703ca62e2c2SSteve Yin
2704ca62e2c2SSteve Yin
2705ca62e2c2SSteve Yin aIter =
2706ca62e2c2SSteve Yin mpFrmMap->find( aFrmOrObj.GetSwFrm() );
2707ca62e2c2SSteve Yin if( aIter != mpFrmMap->end() )
2708ca62e2c2SSteve Yin {
2709ca62e2c2SSteve Yin xAcc = (*aIter).second;
2710ca62e2c2SSteve Yin }
2711ca62e2c2SSteve Yin }
2712cdf0e10cSrcweir
2713cdf0e10cSrcweir // For cells, some extra thoughts are necessary,
2714cdf0e10cSrcweir // because invalidating the cursor for one cell
2715cdf0e10cSrcweir // invalidates the cursor for all cells of the same
2716cdf0e10cSrcweir // table. For this reason, we don't want to
2717cdf0e10cSrcweir // invalidate the cursor for the old cursor object
2718cdf0e10cSrcweir // and the new one if they are within the same table,
2719cdf0e10cSrcweir // because this would result in doing the work twice.
2720cdf0e10cSrcweir // Moreover, we have to make sure to invalidate the
2721cdf0e10cSrcweir // cursor even if the current cell has no accessible object.
2722cdf0e10cSrcweir // If the old cursor objects exists and is in the same
2723cdf0e10cSrcweir // table, its the best choice, because using it avoids
2724cdf0e10cSrcweir // an unnessarary cursor invalidation cycle when creating
2725cdf0e10cSrcweir // a new object for the current cell.
2726cdf0e10cSrcweir if( aFrmOrObj.GetSwFrm()->IsCellFrm() )
2727cdf0e10cSrcweir {
2728cdf0e10cSrcweir if( xOldAcc.is() &&
2729cdf0e10cSrcweir AreInSameTable( xOldAcc, aFrmOrObj.GetSwFrm() ) )
2730cdf0e10cSrcweir {
2731cdf0e10cSrcweir if( xAcc.is() )
2732cdf0e10cSrcweir xOldAcc = xAcc; // avoid extra invalidation
2733cdf0e10cSrcweir else
2734cdf0e10cSrcweir xAcc = xOldAcc; // make sure ate least one
2735cdf0e10cSrcweir }
2736cdf0e10cSrcweir if( !xAcc.is() )
2737cdf0e10cSrcweir xAcc = GetContext( aFrmOrObj.GetSwFrm(), sal_True );
2738cdf0e10cSrcweir }
2739cdf0e10cSrcweir }
2740ca62e2c2SSteve Yin else if (bShapeSelected)
2741ca62e2c2SSteve Yin {
2742ca62e2c2SSteve Yin const SwFEShell *pFESh = pVSh ? static_cast< const SwFEShell * >( pVSh ) : NULL ;
2743ca62e2c2SSteve Yin if(pFESh)
2744ca62e2c2SSteve Yin {
2745ca62e2c2SSteve Yin const SdrMarkList *pMarkList = pFESh->GetMarkList();
2746ca62e2c2SSteve Yin if (pMarkList != NULL && pMarkList->GetMarkCount() == 1)
2747ca62e2c2SSteve Yin {
2748ca62e2c2SSteve Yin SdrObject *pObj = pMarkList->GetMark( 0 )->GetMarkedSdrObj();
2749ca62e2c2SSteve Yin ::vos::ORef < ::accessibility::AccessibleShape > pAccShapeImpl = GetContextImpl(pObj,NULL,sal_False);
2750ca62e2c2SSteve Yin if (!pAccShapeImpl.isValid())
2751ca62e2c2SSteve Yin {
2752ca62e2c2SSteve Yin while (pObj && pObj->GetUpGroup())
2753ca62e2c2SSteve Yin {
2754ca62e2c2SSteve Yin pObj = pObj->GetUpGroup();
2755ca62e2c2SSteve Yin }
2756ca62e2c2SSteve Yin if (pObj != NULL)
2757ca62e2c2SSteve Yin {
2758ca62e2c2SSteve Yin const SwFrm *pParent = SwAccessibleFrame::GetParent( SwAccessibleChild(pObj), GetShell()->IsPreView() );
2759ca62e2c2SSteve Yin if( pParent )
2760ca62e2c2SSteve Yin {
2761ca62e2c2SSteve Yin ::vos::ORef< SwAccessibleContext > xParentAccImpl = GetContextImpl(pParent,sal_False);
2762ca62e2c2SSteve Yin if (!xParentAccImpl.isValid())
2763ca62e2c2SSteve Yin {
2764ca62e2c2SSteve Yin const SwTabFrm* pTabFrm = pParent->FindTabFrm();
2765ca62e2c2SSteve Yin if (pTabFrm)
2766ca62e2c2SSteve Yin {
2767ca62e2c2SSteve Yin //The Table should not add in acc.because the "pParent" is not add to acc .
2768ca62e2c2SSteve Yin uno::Reference< XAccessible> xAccParentTab = GetContext(pTabFrm,sal_True);//Should Create.
2769ca62e2c2SSteve Yin
2770ca62e2c2SSteve Yin const SwFrm *pParentRoot = SwAccessibleFrame::GetParent( SwAccessibleChild(pTabFrm), GetShell()->IsPreView() );
2771ca62e2c2SSteve Yin if (pParentRoot)
2772ca62e2c2SSteve Yin {
2773ca62e2c2SSteve Yin ::vos::ORef< SwAccessibleContext > xParentAccImplRoot = GetContextImpl(pParentRoot,sal_False);
2774ca62e2c2SSteve Yin if(xParentAccImplRoot.isValid())
2775ca62e2c2SSteve Yin {
2776ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2777ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::CHILD;
2778ca62e2c2SSteve Yin aEvent.NewValue <<= xAccParentTab;
2779ca62e2c2SSteve Yin xParentAccImplRoot->FireAccessibleEvent( aEvent );
2780ca62e2c2SSteve Yin }
2781ca62e2c2SSteve Yin }
2782ca62e2c2SSteve Yin
2783ca62e2c2SSteve Yin //Get "pParent" acc again.
2784ca62e2c2SSteve Yin xParentAccImpl = GetContextImpl(pParent,sal_False);
2785ca62e2c2SSteve Yin }
2786ca62e2c2SSteve Yin else
2787ca62e2c2SSteve Yin {
2788ca62e2c2SSteve Yin //directly create this acc para .
2789ca62e2c2SSteve Yin xParentAccImpl = GetContextImpl(pParent,sal_True);//Should Create.
2790ca62e2c2SSteve Yin
2791ca62e2c2SSteve Yin const SwFrm *pParentRoot = SwAccessibleFrame::GetParent( SwAccessibleChild(pParent), GetShell()->IsPreView() );
2792ca62e2c2SSteve Yin
2793ca62e2c2SSteve Yin ::vos::ORef< SwAccessibleContext > xParentAccImplRoot = GetContextImpl(pParentRoot,sal_False);
2794ca62e2c2SSteve Yin if(xParentAccImplRoot.isValid())
2795ca62e2c2SSteve Yin {
2796ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2797ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::CHILD;
2798ca62e2c2SSteve Yin aEvent.NewValue <<= uno::Reference< XAccessible>(xParentAccImpl.getBodyPtr());
2799ca62e2c2SSteve Yin xParentAccImplRoot->FireAccessibleEvent( aEvent );
2800ca62e2c2SSteve Yin }
2801ca62e2c2SSteve Yin }
2802ca62e2c2SSteve Yin }
2803ca62e2c2SSteve Yin if (xParentAccImpl.isValid())
2804ca62e2c2SSteve Yin {
2805ca62e2c2SSteve Yin uno::Reference< XAccessible> xAccShape =
2806ca62e2c2SSteve Yin GetContext(pObj,xParentAccImpl.getBodyPtr(),sal_True);
2807ca62e2c2SSteve Yin
2808ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2809ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::CHILD;
2810ca62e2c2SSteve Yin aEvent.NewValue <<= xAccShape;
2811ca62e2c2SSteve Yin xParentAccImpl->FireAccessibleEvent( aEvent );
2812ca62e2c2SSteve Yin }
2813ca62e2c2SSteve Yin }
2814ca62e2c2SSteve Yin }
2815ca62e2c2SSteve Yin }
2816ca62e2c2SSteve Yin }
2817ca62e2c2SSteve Yin }
2818ca62e2c2SSteve Yin }
2819cdf0e10cSrcweir }
2820cdf0e10cSrcweir
2821ca62e2c2SSteve Yin m_setParaAdd.clear();
2822ca62e2c2SSteve Yin m_setParaRemove.clear();
2823cdf0e10cSrcweir if( xOldAcc.is() && xOldAcc != xAcc )
2824cdf0e10cSrcweir InvalidateCursorPosition( xOldAcc );
2825cdf0e10cSrcweir if( bOldShapeSelected || bShapeSelected )
2826cdf0e10cSrcweir InvalidateShapeSelection();
2827cdf0e10cSrcweir if( xAcc.is() )
2828cdf0e10cSrcweir InvalidateCursorPosition( xAcc );
2829ca62e2c2SSteve Yin
2830ca62e2c2SSteve Yin InvalidateShapeInParaSelection();
2831ca62e2c2SSteve Yin
2832ca62e2c2SSteve Yin SET_PARA::iterator si = m_setParaRemove.begin();
2833ca62e2c2SSteve Yin for (; si != m_setParaRemove.end() ; ++si)
2834ca62e2c2SSteve Yin {
2835ca62e2c2SSteve Yin SwAccessibleParagraph* pAccPara = *si;
2836ca62e2c2SSteve Yin if(pAccPara && pAccPara->getSelectedAccessibleChildCount() == 0 && pAccPara->getSelectedText().getLength() == 0)
2837ca62e2c2SSteve Yin {
2838ca62e2c2SSteve Yin if(pAccPara->SetSelectedState(sal_False))
2839ca62e2c2SSteve Yin {
2840ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2841ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_REMOVE;
2842ca62e2c2SSteve Yin pAccPara->FireAccessibleEvent( aEvent );
2843ca62e2c2SSteve Yin }
2844ca62e2c2SSteve Yin }
2845ca62e2c2SSteve Yin }
2846ca62e2c2SSteve Yin si = m_setParaAdd.begin();
2847ca62e2c2SSteve Yin for (; si != m_setParaAdd.end() ; ++si)
2848ca62e2c2SSteve Yin {
2849ca62e2c2SSteve Yin SwAccessibleParagraph* pAccPara = *si;
2850ca62e2c2SSteve Yin if(pAccPara && pAccPara->SetSelectedState(sal_True))
2851ca62e2c2SSteve Yin {
2852ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2853ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::SELECTION_CHANGED;
2854ca62e2c2SSteve Yin pAccPara->FireAccessibleEvent( aEvent );
2855ca62e2c2SSteve Yin }
2856ca62e2c2SSteve Yin }
2857ca62e2c2SSteve Yin }
2858ca62e2c2SSteve Yin
2859ca62e2c2SSteve Yin //Notify the page change event to bridge.
FirePageChangeEvent(sal_uInt16 nOldPage,sal_uInt16 nNewPage)2860ca62e2c2SSteve Yin void SwAccessibleMap::FirePageChangeEvent(sal_uInt16 nOldPage, sal_uInt16 nNewPage)
2861ca62e2c2SSteve Yin {
2862ca62e2c2SSteve Yin uno::Reference<XAccessible> xAcc = GetDocumentView( );
2863ca62e2c2SSteve Yin if ( xAcc.is() )
2864ca62e2c2SSteve Yin {
2865ca62e2c2SSteve Yin SwAccessibleDocumentBase *pAcc =
2866ca62e2c2SSteve Yin static_cast< SwAccessibleDocumentBase * >( xAcc.get() );
2867ca62e2c2SSteve Yin if (pAcc)
2868ca62e2c2SSteve Yin {
2869ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2870ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::PAGE_CHANGED;
2871ca62e2c2SSteve Yin aEvent.OldValue <<= nOldPage;
2872ca62e2c2SSteve Yin aEvent.NewValue <<= nNewPage;
2873ca62e2c2SSteve Yin pAcc->FireAccessibleEvent( aEvent );
2874ca62e2c2SSteve Yin }
2875ca62e2c2SSteve Yin }
2876ca62e2c2SSteve Yin }
2877ca62e2c2SSteve Yin
FireSectionChangeEvent(sal_uInt16 nOldSection,sal_uInt16 nNewSection)2878ca62e2c2SSteve Yin void SwAccessibleMap::FireSectionChangeEvent(sal_uInt16 nOldSection, sal_uInt16 nNewSection)
2879ca62e2c2SSteve Yin {
2880ca62e2c2SSteve Yin uno::Reference<XAccessible> xAcc = GetDocumentView( );
2881ca62e2c2SSteve Yin if ( xAcc.is() )
2882ca62e2c2SSteve Yin {
2883ca62e2c2SSteve Yin SwAccessibleDocumentBase *pAcc =
2884ca62e2c2SSteve Yin static_cast< SwAccessibleDocumentBase * >( xAcc.get() );
2885ca62e2c2SSteve Yin if (pAcc)
2886ca62e2c2SSteve Yin {
2887ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2888ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::SECTION_CHANGED;
2889ca62e2c2SSteve Yin aEvent.OldValue <<= nOldSection;
2890ca62e2c2SSteve Yin aEvent.NewValue <<= nNewSection;
2891ca62e2c2SSteve Yin pAcc->FireAccessibleEvent( aEvent );
2892ca62e2c2SSteve Yin
2893ca62e2c2SSteve Yin }
2894ca62e2c2SSteve Yin }
2895ca62e2c2SSteve Yin }
FireColumnChangeEvent(sal_uInt16 nOldColumn,sal_uInt16 nNewColumn)2896ca62e2c2SSteve Yin void SwAccessibleMap::FireColumnChangeEvent(sal_uInt16 nOldColumn, sal_uInt16 nNewColumn)
2897ca62e2c2SSteve Yin {
2898ca62e2c2SSteve Yin uno::Reference<XAccessible> xAcc = GetDocumentView( );
2899ca62e2c2SSteve Yin if ( xAcc.is() )
2900ca62e2c2SSteve Yin {
2901ca62e2c2SSteve Yin SwAccessibleDocumentBase *pAcc =
2902ca62e2c2SSteve Yin static_cast< SwAccessibleDocumentBase * >( xAcc.get() );
2903ca62e2c2SSteve Yin if (pAcc)
2904ca62e2c2SSteve Yin {
2905ca62e2c2SSteve Yin AccessibleEventObject aEvent;
2906ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::COLUMN_CHANGED;
2907ca62e2c2SSteve Yin aEvent.OldValue <<= nOldColumn;
2908ca62e2c2SSteve Yin aEvent.NewValue <<= nNewColumn;
2909ca62e2c2SSteve Yin pAcc->FireAccessibleEvent( aEvent );
2910ca62e2c2SSteve Yin
2911ca62e2c2SSteve Yin }
2912ca62e2c2SSteve Yin }
2913cdf0e10cSrcweir }
2914cdf0e10cSrcweir
InvalidateFocus()2915cdf0e10cSrcweir void SwAccessibleMap::InvalidateFocus()
2916cdf0e10cSrcweir {
2917ca62e2c2SSteve Yin if(GetShell()->IsPreView())
2918ca62e2c2SSteve Yin {
2919ca62e2c2SSteve Yin uno::Reference<XAccessible> xAcc = _GetDocumentView( sal_True );
2920ca62e2c2SSteve Yin if (xAcc.get())
2921ca62e2c2SSteve Yin {
2922ca62e2c2SSteve Yin SwAccessiblePreview *pAccPreview = static_cast<SwAccessiblePreview *>(xAcc.get());
2923ca62e2c2SSteve Yin if (pAccPreview)
2924ca62e2c2SSteve Yin {
2925ca62e2c2SSteve Yin pAccPreview->InvalidateFocus();
2926ca62e2c2SSteve Yin return ;
2927ca62e2c2SSteve Yin }
2928ca62e2c2SSteve Yin }
2929ca62e2c2SSteve Yin }
2930cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
2931cdf0e10cSrcweir sal_Bool bShapeSelected;
2932cdf0e10cSrcweir {
2933cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2934cdf0e10cSrcweir
2935cdf0e10cSrcweir xAcc = mxCursorContext;
2936cdf0e10cSrcweir bShapeSelected = mbShapeSelected;
2937cdf0e10cSrcweir }
2938cdf0e10cSrcweir
2939cdf0e10cSrcweir if( xAcc.is() )
2940cdf0e10cSrcweir {
2941cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
2942cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2943cdf0e10cSrcweir pAccImpl->InvalidateFocus();
2944cdf0e10cSrcweir }
2945ca62e2c2SSteve Yin else
2946cdf0e10cSrcweir {
2947ca62e2c2SSteve Yin DoInvalidateShapeSelection(sal_True);
2948cdf0e10cSrcweir }
2949cdf0e10cSrcweir }
2950cdf0e10cSrcweir
SetCursorContext(const::vos::ORef<SwAccessibleContext> & rCursorContext)2951cdf0e10cSrcweir void SwAccessibleMap::SetCursorContext(
2952cdf0e10cSrcweir const ::vos::ORef < SwAccessibleContext >& rCursorContext )
2953cdf0e10cSrcweir {
2954cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
2955cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( rCursorContext.getBodyPtr() );
2956cdf0e10cSrcweir mxCursorContext = xAcc;
2957cdf0e10cSrcweir }
2958cdf0e10cSrcweir
2959cdf0e10cSrcweir // --> OD 2005-12-12 #i27301# - use new type definition for <_nStates>
InvalidateStates(tAccessibleStates _nStates,const SwFrm * _pFrm)2960cdf0e10cSrcweir void SwAccessibleMap::InvalidateStates( tAccessibleStates _nStates,
2961cdf0e10cSrcweir const SwFrm* _pFrm )
2962cdf0e10cSrcweir {
2963cdf0e10cSrcweir // Start with the frame or the first upper that is accessible
2964cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( _pFrm );
2965cdf0e10cSrcweir while( aFrmOrObj.GetSwFrm() &&
2966cdf0e10cSrcweir !aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
2967cdf0e10cSrcweir aFrmOrObj = aFrmOrObj.GetSwFrm()->GetUpper();
2968cdf0e10cSrcweir if( !aFrmOrObj.GetSwFrm() )
2969cdf0e10cSrcweir aFrmOrObj = GetShell()->GetLayout();
2970cdf0e10cSrcweir
2971cdf0e10cSrcweir uno::Reference< XAccessible > xAcc( GetContext( aFrmOrObj.GetSwFrm(), sal_True ) );
2972cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
2973cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
2974cdf0e10cSrcweir if( GetShell()->ActionPend() )
2975cdf0e10cSrcweir {
2976cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent( SwAccessibleEvent_Impl::CARET_OR_STATES,
2977cdf0e10cSrcweir pAccImpl,
2978cdf0e10cSrcweir SwAccessibleChild(pAccImpl->GetFrm()),
2979cdf0e10cSrcweir _nStates );
2980cdf0e10cSrcweir AppendEvent( aEvent );
2981cdf0e10cSrcweir }
2982cdf0e10cSrcweir else
2983cdf0e10cSrcweir {
2984cdf0e10cSrcweir FireEvents();
2985cdf0e10cSrcweir pAccImpl->InvalidateStates( _nStates );
2986cdf0e10cSrcweir }
2987cdf0e10cSrcweir }
2988cdf0e10cSrcweir // <--
2989cdf0e10cSrcweir
_InvalidateRelationSet(const SwFrm * pFrm,sal_Bool bFrom)2990cdf0e10cSrcweir void SwAccessibleMap::_InvalidateRelationSet( const SwFrm* pFrm,
2991cdf0e10cSrcweir sal_Bool bFrom )
2992cdf0e10cSrcweir {
2993cdf0e10cSrcweir // first, see if this frame is accessible, and if so, get the respective
2994cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( pFrm );
2995cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
2996cdf0e10cSrcweir {
2997cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
2998cdf0e10cSrcweir {
2999cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3000cdf0e10cSrcweir
3001cdf0e10cSrcweir if( mpFrmMap )
3002cdf0e10cSrcweir {
3003cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
3004cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
3005cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
3006cdf0e10cSrcweir {
3007cdf0e10cSrcweir xAcc = (*aIter).second;
3008cdf0e10cSrcweir }
3009cdf0e10cSrcweir }
3010cdf0e10cSrcweir }
3011cdf0e10cSrcweir
3012cdf0e10cSrcweir // deliver event directly, or queue event
3013cdf0e10cSrcweir if( xAcc.is() )
3014cdf0e10cSrcweir {
3015cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
3016cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
3017cdf0e10cSrcweir if( GetShell()->ActionPend() )
3018cdf0e10cSrcweir {
3019cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent( SwAccessibleEvent_Impl::CARET_OR_STATES,
3020cdf0e10cSrcweir pAccImpl, SwAccessibleChild(pFrm),
3021cdf0e10cSrcweir ( bFrom
3022cdf0e10cSrcweir ? ACC_STATE_RELATION_FROM
3023cdf0e10cSrcweir : ACC_STATE_RELATION_TO ) );
3024cdf0e10cSrcweir AppendEvent( aEvent );
3025cdf0e10cSrcweir }
3026cdf0e10cSrcweir else
3027cdf0e10cSrcweir {
3028cdf0e10cSrcweir FireEvents();
3029cdf0e10cSrcweir pAccImpl->InvalidateRelation( bFrom
3030cdf0e10cSrcweir ? AccessibleEventId::CONTENT_FLOWS_FROM_RELATION_CHANGED
3031cdf0e10cSrcweir : AccessibleEventId::CONTENT_FLOWS_TO_RELATION_CHANGED );
3032cdf0e10cSrcweir }
3033cdf0e10cSrcweir }
3034cdf0e10cSrcweir }
3035cdf0e10cSrcweir }
3036cdf0e10cSrcweir
InvalidateRelationSet(const SwFrm * pMaster,const SwFrm * pFollow)3037cdf0e10cSrcweir void SwAccessibleMap::InvalidateRelationSet( const SwFrm* pMaster,
3038cdf0e10cSrcweir const SwFrm* pFollow )
3039cdf0e10cSrcweir {
3040cdf0e10cSrcweir _InvalidateRelationSet( pMaster, sal_False );
3041cdf0e10cSrcweir _InvalidateRelationSet( pFollow, sal_True );
3042cdf0e10cSrcweir }
3043cdf0e10cSrcweir
3044cdf0e10cSrcweir /** invalidation CONTENT_FLOW_FROM/_TO relation of a paragraph
3045cdf0e10cSrcweir
3046cdf0e10cSrcweir OD 2005-12-01 #i27138#
3047cdf0e10cSrcweir
3048cdf0e10cSrcweir @author OD
3049cdf0e10cSrcweir */
InvalidateParaFlowRelation(const SwTxtFrm & _rTxtFrm,const bool _bFrom)3050cdf0e10cSrcweir void SwAccessibleMap::InvalidateParaFlowRelation( const SwTxtFrm& _rTxtFrm,
3051cdf0e10cSrcweir const bool _bFrom )
3052cdf0e10cSrcweir {
3053cdf0e10cSrcweir _InvalidateRelationSet( &_rTxtFrm, _bFrom );
3054cdf0e10cSrcweir }
3055cdf0e10cSrcweir
3056cdf0e10cSrcweir /** invalidation of text selection of a paragraph
3057cdf0e10cSrcweir
3058cdf0e10cSrcweir OD 2005-12-12 #i27301#
3059cdf0e10cSrcweir
3060cdf0e10cSrcweir @author OD
3061cdf0e10cSrcweir */
InvalidateParaTextSelection(const SwTxtFrm & _rTxtFrm)3062cdf0e10cSrcweir void SwAccessibleMap::InvalidateParaTextSelection( const SwTxtFrm& _rTxtFrm )
3063cdf0e10cSrcweir {
3064cdf0e10cSrcweir // first, see if this frame is accessible, and if so, get the respective
3065cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( &_rTxtFrm );
3066cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
3067cdf0e10cSrcweir {
3068cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
3069cdf0e10cSrcweir {
3070cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3071cdf0e10cSrcweir
3072cdf0e10cSrcweir if( mpFrmMap )
3073cdf0e10cSrcweir {
3074cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
3075cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
3076cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
3077cdf0e10cSrcweir {
3078cdf0e10cSrcweir xAcc = (*aIter).second;
3079cdf0e10cSrcweir }
3080cdf0e10cSrcweir }
3081cdf0e10cSrcweir }
3082cdf0e10cSrcweir
3083cdf0e10cSrcweir // deliver event directly, or queue event
3084cdf0e10cSrcweir if( xAcc.is() )
3085cdf0e10cSrcweir {
3086cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
3087cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
3088cdf0e10cSrcweir if( GetShell()->ActionPend() )
3089cdf0e10cSrcweir {
3090cdf0e10cSrcweir SwAccessibleEvent_Impl aEvent(
3091cdf0e10cSrcweir SwAccessibleEvent_Impl::CARET_OR_STATES,
3092cdf0e10cSrcweir pAccImpl,
3093cdf0e10cSrcweir SwAccessibleChild( &_rTxtFrm ),
3094cdf0e10cSrcweir ACC_STATE_TEXT_SELECTION_CHANGED );
3095cdf0e10cSrcweir AppendEvent( aEvent );
3096cdf0e10cSrcweir }
3097cdf0e10cSrcweir else
3098cdf0e10cSrcweir {
3099cdf0e10cSrcweir FireEvents();
3100cdf0e10cSrcweir pAccImpl->InvalidateTextSelection();
3101cdf0e10cSrcweir }
3102cdf0e10cSrcweir }
3103cdf0e10cSrcweir }
3104cdf0e10cSrcweir }
3105cdf0e10cSrcweir
GetChildIndex(const SwFrm & rParentFrm,Window & rChild) const3106cdf0e10cSrcweir sal_Int32 SwAccessibleMap::GetChildIndex( const SwFrm& rParentFrm,
3107cdf0e10cSrcweir Window& rChild ) const
3108cdf0e10cSrcweir {
3109cdf0e10cSrcweir sal_Int32 nIndex( -1 );
3110cdf0e10cSrcweir
3111cdf0e10cSrcweir SwAccessibleChild aFrmOrObj( &rParentFrm );
3112cdf0e10cSrcweir if( aFrmOrObj.IsAccessible( GetShell()->IsPreView() ) )
3113cdf0e10cSrcweir {
3114cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
3115cdf0e10cSrcweir {
3116cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3117cdf0e10cSrcweir
3118cdf0e10cSrcweir if( mpFrmMap )
3119cdf0e10cSrcweir {
3120cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
3121cdf0e10cSrcweir mpFrmMap->find( aFrmOrObj.GetSwFrm() );
3122cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
3123cdf0e10cSrcweir {
3124cdf0e10cSrcweir xAcc = (*aIter).second;
3125cdf0e10cSrcweir }
3126cdf0e10cSrcweir }
3127cdf0e10cSrcweir }
3128cdf0e10cSrcweir
3129cdf0e10cSrcweir if( xAcc.is() )
3130cdf0e10cSrcweir {
3131cdf0e10cSrcweir SwAccessibleContext *pAccImpl =
3132cdf0e10cSrcweir static_cast< SwAccessibleContext *>( xAcc.get() );
3133cdf0e10cSrcweir
3134cdf0e10cSrcweir nIndex = pAccImpl->GetChildIndex( const_cast<SwAccessibleMap&>(*this),
3135cdf0e10cSrcweir SwAccessibleChild( &rChild ) );
3136cdf0e10cSrcweir }
3137cdf0e10cSrcweir }
3138cdf0e10cSrcweir
3139cdf0e10cSrcweir return nIndex;
3140cdf0e10cSrcweir }
3141cdf0e10cSrcweir
3142cdf0e10cSrcweir
3143cdf0e10cSrcweir // OD 15.01.2003 #103492# - complete re-factoring of method due to new page/print
3144cdf0e10cSrcweir // preview functionality.
UpdatePreview(const std::vector<PrevwPage * > & _rPrevwPages,const Fraction & _rScale,const SwPageFrm * _pSelectedPageFrm,const Size & _rPrevwWinSize)3145cdf0e10cSrcweir void SwAccessibleMap::UpdatePreview( const std::vector<PrevwPage*>& _rPrevwPages,
3146cdf0e10cSrcweir const Fraction& _rScale,
3147cdf0e10cSrcweir const SwPageFrm* _pSelectedPageFrm,
3148cdf0e10cSrcweir const Size& _rPrevwWinSize )
3149cdf0e10cSrcweir {
3150cdf0e10cSrcweir DBG_ASSERT( GetShell()->IsPreView(), "no preview?" );
3151cdf0e10cSrcweir DBG_ASSERT( mpPreview != NULL, "no preview data?" );
3152cdf0e10cSrcweir
3153cdf0e10cSrcweir // OD 15.01.2003 #103492# - adjustments for changed method signature
3154cdf0e10cSrcweir mpPreview->Update( *this, _rPrevwPages, _rScale, _pSelectedPageFrm, _rPrevwWinSize );
3155cdf0e10cSrcweir
3156cdf0e10cSrcweir // propagate change of VisArea through the document's
3157cdf0e10cSrcweir // accessibility tree; this will also send appropriate scroll
3158cdf0e10cSrcweir // events
3159cdf0e10cSrcweir SwAccessibleContext* pDoc =
3160cdf0e10cSrcweir GetContextImpl( GetShell()->GetLayout() ).getBodyPtr();
3161cdf0e10cSrcweir static_cast<SwAccessibleDocumentBase*>( pDoc )->SetVisArea();
3162cdf0e10cSrcweir
3163cdf0e10cSrcweir uno::Reference < XAccessible > xOldAcc;
3164cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
3165cdf0e10cSrcweir {
3166cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3167cdf0e10cSrcweir
3168cdf0e10cSrcweir xOldAcc = mxCursorContext;
3169cdf0e10cSrcweir
3170cdf0e10cSrcweir const SwPageFrm *pSelPage = mpPreview->GetSelPage();
3171cdf0e10cSrcweir if( pSelPage && mpFrmMap )
3172cdf0e10cSrcweir {
3173cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
3174cdf0e10cSrcweir mpFrmMap->find( pSelPage );
3175cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
3176cdf0e10cSrcweir xAcc = (*aIter).second;
3177cdf0e10cSrcweir }
3178cdf0e10cSrcweir }
3179cdf0e10cSrcweir
3180cdf0e10cSrcweir if( xOldAcc.is() && xOldAcc != xAcc )
3181cdf0e10cSrcweir InvalidateCursorPosition( xOldAcc );
3182cdf0e10cSrcweir if( xAcc.is() )
3183cdf0e10cSrcweir InvalidateCursorPosition( xAcc );
3184cdf0e10cSrcweir }
3185cdf0e10cSrcweir
InvalidatePreViewSelection(sal_uInt16 nSelPage)3186cdf0e10cSrcweir void SwAccessibleMap::InvalidatePreViewSelection( sal_uInt16 nSelPage )
3187cdf0e10cSrcweir {
3188cdf0e10cSrcweir DBG_ASSERT( GetShell()->IsPreView(), "no preview?" );
3189cdf0e10cSrcweir DBG_ASSERT( mpPreview != NULL, "no preview data?" );
3190cdf0e10cSrcweir
3191cdf0e10cSrcweir // OD 16.01.2003 #103492# - changed metthod call due to method signature change.
3192cdf0e10cSrcweir mpPreview->InvalidateSelection( GetShell()->GetLayout()->GetPageByPageNum( nSelPage ) );
3193cdf0e10cSrcweir
3194cdf0e10cSrcweir uno::Reference < XAccessible > xOldAcc;
3195cdf0e10cSrcweir uno::Reference < XAccessible > xAcc;
3196cdf0e10cSrcweir {
3197cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3198cdf0e10cSrcweir
3199cdf0e10cSrcweir xOldAcc = mxCursorContext;
3200cdf0e10cSrcweir
3201cdf0e10cSrcweir const SwPageFrm *pSelPage = mpPreview->GetSelPage();
3202cdf0e10cSrcweir if( pSelPage && mpFrmMap )
3203cdf0e10cSrcweir {
3204cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aIter =
3205cdf0e10cSrcweir mpFrmMap->find( pSelPage );
3206cdf0e10cSrcweir if( aIter != mpFrmMap->end() )
3207cdf0e10cSrcweir xAcc = (*aIter).second;
3208cdf0e10cSrcweir }
3209cdf0e10cSrcweir }
3210cdf0e10cSrcweir
3211cdf0e10cSrcweir if( xOldAcc.is() && xOldAcc != xAcc )
3212cdf0e10cSrcweir InvalidateCursorPosition( xOldAcc );
3213cdf0e10cSrcweir if( xAcc.is() )
3214cdf0e10cSrcweir InvalidateCursorPosition( xAcc );
3215cdf0e10cSrcweir }
3216cdf0e10cSrcweir
3217cdf0e10cSrcweir
IsPageSelected(const SwPageFrm * pPageFrm) const3218cdf0e10cSrcweir sal_Bool SwAccessibleMap::IsPageSelected( const SwPageFrm *pPageFrm ) const
3219cdf0e10cSrcweir {
3220cdf0e10cSrcweir return mpPreview && mpPreview->GetSelPage() == pPageFrm;
3221cdf0e10cSrcweir }
3222cdf0e10cSrcweir
3223cdf0e10cSrcweir
FireEvents()3224cdf0e10cSrcweir void SwAccessibleMap::FireEvents()
3225cdf0e10cSrcweir {
3226cdf0e10cSrcweir {
3227cdf0e10cSrcweir vos::OGuard aGuard( maEventMutex );
3228cdf0e10cSrcweir if( mpEvents )
3229cdf0e10cSrcweir {
3230cdf0e10cSrcweir mpEvents->SetFiring();
3231ca62e2c2SSteve Yin mpEvents->MoveInvalidXAccToEnd();
3232cdf0e10cSrcweir SwAccessibleEventList_Impl::iterator aIter = mpEvents->begin();
3233cdf0e10cSrcweir while( aIter != mpEvents->end() )
3234cdf0e10cSrcweir {
3235cdf0e10cSrcweir FireEvent( *aIter );
3236cdf0e10cSrcweir ++aIter;
3237cdf0e10cSrcweir }
3238cdf0e10cSrcweir
3239cdf0e10cSrcweir delete mpEventMap;
3240cdf0e10cSrcweir mpEventMap = 0;
3241cdf0e10cSrcweir
3242cdf0e10cSrcweir delete mpEvents;
3243cdf0e10cSrcweir mpEvents = 0;
3244cdf0e10cSrcweir }
3245cdf0e10cSrcweir }
3246cdf0e10cSrcweir {
3247cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3248cdf0e10cSrcweir if( mpShapes )
3249cdf0e10cSrcweir {
3250cdf0e10cSrcweir delete mpShapes;
3251cdf0e10cSrcweir mpShapes = 0;
3252cdf0e10cSrcweir }
3253cdf0e10cSrcweir }
3254cdf0e10cSrcweir
3255cdf0e10cSrcweir }
3256cdf0e10cSrcweir
IsValid() const3257cdf0e10cSrcweir sal_Bool SwAccessibleMap::IsValid() const
3258cdf0e10cSrcweir {
3259cdf0e10cSrcweir return sal_True;
3260cdf0e10cSrcweir }
3261cdf0e10cSrcweir
GetVisibleArea() const3262cdf0e10cSrcweir Rectangle SwAccessibleMap::GetVisibleArea() const
3263cdf0e10cSrcweir {
3264cdf0e10cSrcweir MapMode aSrc( MAP_TWIP );
3265cdf0e10cSrcweir MapMode aDest( MAP_100TH_MM );
3266cdf0e10cSrcweir return OutputDevice::LogicToLogic( GetVisArea().SVRect(), aSrc, aDest );
3267cdf0e10cSrcweir }
3268cdf0e10cSrcweir
3269cdf0e10cSrcweir // Convert a MM100 value realtive to the document root into a pixel value
3270cdf0e10cSrcweir // realtive to the screen!
LogicToPixel(const Point & rPoint) const3271cdf0e10cSrcweir Point SwAccessibleMap::LogicToPixel( const Point& rPoint ) const
3272cdf0e10cSrcweir {
3273cdf0e10cSrcweir MapMode aSrc( MAP_100TH_MM );
3274cdf0e10cSrcweir MapMode aDest( MAP_TWIP );
3275cdf0e10cSrcweir
3276cdf0e10cSrcweir Point aPoint = rPoint;
3277cdf0e10cSrcweir
3278cdf0e10cSrcweir aPoint = OutputDevice::LogicToLogic( aPoint, aSrc, aDest );
3279cdf0e10cSrcweir Window *pWin = GetShell()->GetWin();
3280cdf0e10cSrcweir if( pWin )
3281cdf0e10cSrcweir {
3282cdf0e10cSrcweir // OD 16.01.2003 #103492# - get mapping mode for LogicToPixel conversion
3283cdf0e10cSrcweir MapMode aMapMode;
3284cdf0e10cSrcweir GetMapMode( aPoint, aMapMode );
3285cdf0e10cSrcweir aPoint = pWin->LogicToPixel( aPoint, aMapMode );
3286cdf0e10cSrcweir aPoint = pWin->OutputToAbsoluteScreenPixel( aPoint );
3287cdf0e10cSrcweir }
3288cdf0e10cSrcweir
3289cdf0e10cSrcweir return aPoint;
3290cdf0e10cSrcweir }
3291cdf0e10cSrcweir
LogicToPixel(const Size & rSize) const3292cdf0e10cSrcweir Size SwAccessibleMap::LogicToPixel( const Size& rSize ) const
3293cdf0e10cSrcweir {
3294cdf0e10cSrcweir MapMode aSrc( MAP_100TH_MM );
3295cdf0e10cSrcweir MapMode aDest( MAP_TWIP );
3296cdf0e10cSrcweir Size aSize( OutputDevice::LogicToLogic( rSize, aSrc, aDest ) );
3297cdf0e10cSrcweir if( GetShell()->GetWin() )
3298cdf0e10cSrcweir {
3299cdf0e10cSrcweir // OD 16.01.2003 #103492# - get mapping mode for LogicToPixel conversion
3300cdf0e10cSrcweir MapMode aMapMode;
3301cdf0e10cSrcweir GetMapMode( Point(0,0), aMapMode );
3302cdf0e10cSrcweir aSize = GetShell()->GetWin()->LogicToPixel( aSize, aMapMode );
3303cdf0e10cSrcweir }
3304cdf0e10cSrcweir
3305cdf0e10cSrcweir return aSize;
3306cdf0e10cSrcweir }
3307cdf0e10cSrcweir
PixelToLogic(const Point & rPoint) const3308cdf0e10cSrcweir Point SwAccessibleMap::PixelToLogic( const Point& rPoint ) const
3309cdf0e10cSrcweir {
3310cdf0e10cSrcweir Point aPoint;
3311cdf0e10cSrcweir Window *pWin = GetShell()->GetWin();
3312cdf0e10cSrcweir if( pWin )
3313cdf0e10cSrcweir {
3314cdf0e10cSrcweir aPoint = pWin->ScreenToOutputPixel( rPoint );
3315cdf0e10cSrcweir // OD 16.01.2003 #103492# - get mapping mode for PixelToLogic conversion
3316cdf0e10cSrcweir MapMode aMapMode;
3317cdf0e10cSrcweir GetMapMode( aPoint, aMapMode );
3318cdf0e10cSrcweir aPoint = pWin->PixelToLogic( aPoint, aMapMode );
3319cdf0e10cSrcweir MapMode aSrc( MAP_TWIP );
3320cdf0e10cSrcweir MapMode aDest( MAP_100TH_MM );
3321cdf0e10cSrcweir aPoint = OutputDevice::LogicToLogic( aPoint, aSrc, aDest );
3322cdf0e10cSrcweir }
3323cdf0e10cSrcweir
3324cdf0e10cSrcweir return aPoint;
3325cdf0e10cSrcweir }
3326cdf0e10cSrcweir
PixelToLogic(const Size & rSize) const3327cdf0e10cSrcweir Size SwAccessibleMap::PixelToLogic( const Size& rSize ) const
3328cdf0e10cSrcweir {
3329cdf0e10cSrcweir Size aSize;
3330cdf0e10cSrcweir if( GetShell()->GetWin() )
3331cdf0e10cSrcweir {
3332cdf0e10cSrcweir // OD 16.01.2003 #103492# - get mapping mode for PixelToLogic conversion
3333cdf0e10cSrcweir MapMode aMapMode;
3334cdf0e10cSrcweir GetMapMode( Point(0,0), aMapMode );
3335cdf0e10cSrcweir aSize = GetShell()->GetWin()->PixelToLogic( rSize, aMapMode );
3336cdf0e10cSrcweir MapMode aSrc( MAP_TWIP );
3337cdf0e10cSrcweir MapMode aDest( MAP_100TH_MM );
3338cdf0e10cSrcweir aSize = OutputDevice::LogicToLogic( aSize, aSrc, aDest );
3339cdf0e10cSrcweir }
3340cdf0e10cSrcweir
3341cdf0e10cSrcweir return aSize;
3342cdf0e10cSrcweir }
3343cdf0e10cSrcweir
ReplaceChild(::accessibility::AccessibleShape * pCurrentChild,const uno::Reference<drawing::XShape> & _rxShape,const long,const::accessibility::AccessibleShapeTreeInfo &)3344cdf0e10cSrcweir sal_Bool SwAccessibleMap::ReplaceChild (
3345cdf0e10cSrcweir ::accessibility::AccessibleShape* pCurrentChild,
3346cdf0e10cSrcweir const uno::Reference< drawing::XShape >& _rxShape,
3347cdf0e10cSrcweir const long /*_nIndex*/,
3348cdf0e10cSrcweir const ::accessibility::AccessibleShapeTreeInfo& /*_rShapeTreeInfo*/
3349cdf0e10cSrcweir ) throw (uno::RuntimeException)
3350cdf0e10cSrcweir {
3351cdf0e10cSrcweir const SdrObject *pObj = 0;
3352cdf0e10cSrcweir {
3353cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3354cdf0e10cSrcweir if( mpShapeMap )
3355cdf0e10cSrcweir {
3356cdf0e10cSrcweir SwAccessibleShapeMap_Impl::const_iterator aIter = mpShapeMap->begin();
3357cdf0e10cSrcweir SwAccessibleShapeMap_Impl::const_iterator aEndIter = mpShapeMap->end();
3358cdf0e10cSrcweir while( aIter != aEndIter && !pObj )
3359cdf0e10cSrcweir {
3360cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).second );
3361cdf0e10cSrcweir ::accessibility::AccessibleShape *pAccShape =
3362cdf0e10cSrcweir static_cast < ::accessibility::AccessibleShape* >( xAcc.get() );
3363cdf0e10cSrcweir if( pAccShape == pCurrentChild )
3364cdf0e10cSrcweir {
3365cdf0e10cSrcweir pObj = (*aIter).first;
3366cdf0e10cSrcweir }
3367cdf0e10cSrcweir ++aIter;
3368cdf0e10cSrcweir }
3369cdf0e10cSrcweir }
3370cdf0e10cSrcweir }
3371cdf0e10cSrcweir if( !pObj )
3372cdf0e10cSrcweir return sal_False;
3373cdf0e10cSrcweir
3374cdf0e10cSrcweir uno::Reference < drawing::XShape > xShape( _rxShape ); //keep reference to shape, because
3375cdf0e10cSrcweir // we might be the only one that
3376cdf0e10cSrcweir // hold it.
3377cdf0e10cSrcweir // Also get keep parent.
3378cdf0e10cSrcweir uno::Reference < XAccessible > xParent( pCurrentChild->getAccessibleParent() );
3379cdf0e10cSrcweir pCurrentChild = 0; // well be realease by dispose
3380cdf0e10cSrcweir Dispose( 0, pObj, 0 );
3381cdf0e10cSrcweir
3382cdf0e10cSrcweir {
3383cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3384cdf0e10cSrcweir
3385cdf0e10cSrcweir if( !mpShapeMap )
3386cdf0e10cSrcweir mpShapeMap = new SwAccessibleShapeMap_Impl( this );
3387cdf0e10cSrcweir
3388cdf0e10cSrcweir // create the new child
3389cdf0e10cSrcweir ::accessibility::ShapeTypeHandler& rShapeTypeHandler =
3390cdf0e10cSrcweir ::accessibility::ShapeTypeHandler::Instance();
3391cdf0e10cSrcweir ::accessibility::AccessibleShapeInfo aShapeInfo(
3392cdf0e10cSrcweir xShape, xParent, this );
3393cdf0e10cSrcweir ::accessibility::AccessibleShape* pReplacement =
3394cdf0e10cSrcweir rShapeTypeHandler.CreateAccessibleObject (
3395cdf0e10cSrcweir aShapeInfo, mpShapeMap->GetInfo() );
3396cdf0e10cSrcweir
3397cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( pReplacement );
3398cdf0e10cSrcweir if( xAcc.is() )
3399cdf0e10cSrcweir {
3400cdf0e10cSrcweir pReplacement->Init();
3401cdf0e10cSrcweir
3402cdf0e10cSrcweir SwAccessibleShapeMap_Impl::iterator aIter =
3403cdf0e10cSrcweir mpShapeMap->find( pObj );
3404cdf0e10cSrcweir if( aIter != mpShapeMap->end() )
3405cdf0e10cSrcweir {
3406cdf0e10cSrcweir (*aIter).second = xAcc;
3407cdf0e10cSrcweir }
3408cdf0e10cSrcweir else
3409cdf0e10cSrcweir {
3410cdf0e10cSrcweir SwAccessibleShapeMap_Impl::value_type aEntry( pObj, xAcc );
3411cdf0e10cSrcweir mpShapeMap->insert( aEntry );
3412cdf0e10cSrcweir }
3413cdf0e10cSrcweir }
3414cdf0e10cSrcweir }
3415cdf0e10cSrcweir
3416cdf0e10cSrcweir SwRect aEmptyRect;
3417cdf0e10cSrcweir InvalidatePosOrSize( 0, pObj, 0, aEmptyRect );
3418cdf0e10cSrcweir
3419cdf0e10cSrcweir return sal_True;
3420cdf0e10cSrcweir }
3421cdf0e10cSrcweir
3422ca62e2c2SSteve Yin //Get the accessible control shape from the model object, here model object is with XPropertySet type
GetAccControlShapeFromModel(::com::sun::star::beans::XPropertySet * pSet)3423ca62e2c2SSteve Yin ::accessibility::AccessibleControlShape * SwAccessibleMap::GetAccControlShapeFromModel(::com::sun::star::beans::XPropertySet* pSet) throw (::com::sun::star::uno::RuntimeException)
3424ca62e2c2SSteve Yin {
3425ca62e2c2SSteve Yin if( mpShapeMap )
3426ca62e2c2SSteve Yin {
3427ca62e2c2SSteve Yin SwAccessibleShapeMap_Impl::const_iterator aIter = mpShapeMap->begin();
3428ca62e2c2SSteve Yin SwAccessibleShapeMap_Impl::const_iterator aEndIter = mpShapeMap->end();
3429ca62e2c2SSteve Yin while( aIter != aEndIter)
3430ca62e2c2SSteve Yin {
3431ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( (*aIter).second );
3432ca62e2c2SSteve Yin ::accessibility::AccessibleShape *pAccShape =
3433ca62e2c2SSteve Yin static_cast < ::accessibility::AccessibleShape* >( xAcc.get() );
3434ca62e2c2SSteve Yin if(pAccShape && ::accessibility::ShapeTypeHandler::Instance().GetTypeId (pAccShape->GetXShape()) == ::accessibility::DRAWING_CONTROL)
3435ca62e2c2SSteve Yin {
3436ca62e2c2SSteve Yin ::accessibility::AccessibleControlShape *pCtlAccShape = static_cast < ::accessibility::AccessibleControlShape* >(pAccShape);
3437ca62e2c2SSteve Yin if (pCtlAccShape && pCtlAccShape->GetControlModel() == pSet)
3438ca62e2c2SSteve Yin return pCtlAccShape;
3439ca62e2c2SSteve Yin }
3440ca62e2c2SSteve Yin ++aIter;
3441ca62e2c2SSteve Yin }
3442ca62e2c2SSteve Yin }
3443ca62e2c2SSteve Yin return NULL;
3444ca62e2c2SSteve Yin }
3445ca62e2c2SSteve Yin
3446ca62e2c2SSteve Yin ::com::sun::star::uno::Reference< XAccessible >
GetAccessibleCaption(const::com::sun::star::uno::Reference<::com::sun::star::drawing::XShape> & xShape)3447ca62e2c2SSteve Yin SwAccessibleMap::GetAccessibleCaption (const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& xShape)
3448ca62e2c2SSteve Yin throw (::com::sun::star::uno::RuntimeException)
3449ca62e2c2SSteve Yin {
3450ca62e2c2SSteve Yin SdrObject* captionedObject = GetSdrObjectFromXShape(xShape);
3451ca62e2c2SSteve Yin
3452ca62e2c2SSteve Yin SwDrawContact *pContact = (SwDrawContact*)GetUserCall( captionedObject );
3453ca62e2c2SSteve Yin ASSERT( RES_DRAWFRMFMT == pContact->GetFmt()->Which(),
3454ca62e2c2SSteve Yin "fail" );
3455ca62e2c2SSteve Yin if( !pContact )
3456ca62e2c2SSteve Yin return 0;
3457ca62e2c2SSteve Yin
3458ca62e2c2SSteve Yin SwDrawFrmFmt *pCaptionedFmt = (SwDrawFrmFmt *)pContact->GetFmt();
3459ca62e2c2SSteve Yin if( !pCaptionedFmt )
3460ca62e2c2SSteve Yin return 0;
3461ca62e2c2SSteve Yin
3462ca62e2c2SSteve Yin SwFlyFrm* pFrm = NULL;
3463ca62e2c2SSteve Yin if (pCaptionedFmt->HasCaption())
3464ca62e2c2SSteve Yin {
3465ca62e2c2SSteve Yin const SwFrmFmt *pCaptionFrmFmt = pCaptionedFmt->GetCaptionFmt();
3466ca62e2c2SSteve Yin SwClientIter aIter (*(SwModify*)pCaptionFrmFmt);
3467ca62e2c2SSteve Yin pFrm = (SwFlyFrm*)aIter.First( TYPE ( SwFlyFrm ));
3468ca62e2c2SSteve Yin }
3469ca62e2c2SSteve Yin if (!pFrm)
3470ca62e2c2SSteve Yin return 0;
3471ca62e2c2SSteve Yin //SwFrmFmt* pFrm = pCaptionedFmt->GetCaptionFmt();
3472ca62e2c2SSteve Yin uno::Reference < XAccessible > xAcc( GetContext((SwFrm*)pFrm,sal_True) );
3473ca62e2c2SSteve Yin //Reference < XAccessibleShape > xAccShape( xAcc, UNO_QUERY );
3474ca62e2c2SSteve Yin
3475ca62e2c2SSteve Yin uno::Reference< XAccessibleContext > xAccContext = xAcc->getAccessibleContext();
3476ca62e2c2SSteve Yin if( xAccContext.is() )
3477ca62e2c2SSteve Yin { //get the parent of caption frame, which is paragaph
3478ca62e2c2SSteve Yin uno::Reference< XAccessible > xAccParent = xAccContext->getAccessibleParent();
3479ca62e2c2SSteve Yin if(xAccParent.is())
3480ca62e2c2SSteve Yin {
3481ca62e2c2SSteve Yin //get the great parent of caption frame which is text frame.
3482ca62e2c2SSteve Yin uno::Reference< XAccessibleContext > xAccParentContext = xAccParent->getAccessibleContext();
3483ca62e2c2SSteve Yin uno::Reference< XAccessible > xAccGreatParent = xAccParentContext->getAccessibleParent();
3484ca62e2c2SSteve Yin if(xAccGreatParent.is())
3485ca62e2c2SSteve Yin {
3486ca62e2c2SSteve Yin AccessibleEventObject aEvent;
3487ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::CHILD;
3488ca62e2c2SSteve Yin aEvent.NewValue <<= xAccParent;
3489ca62e2c2SSteve Yin ( static_cast< SwAccessibleContext * >(xAccGreatParent.get()) )->FireAccessibleEvent( aEvent );
3490ca62e2c2SSteve Yin
3491ca62e2c2SSteve Yin }
3492ca62e2c2SSteve Yin
3493ca62e2c2SSteve Yin AccessibleEventObject aEvent;
3494ca62e2c2SSteve Yin aEvent.EventId = AccessibleEventId::CHILD;
3495ca62e2c2SSteve Yin aEvent.NewValue <<= xAcc;
3496ca62e2c2SSteve Yin ( static_cast< SwAccessibleContext * >(xAccParent.get()) )->FireAccessibleEvent( aEvent );
3497ca62e2c2SSteve Yin }
3498ca62e2c2SSteve Yin }
3499ca62e2c2SSteve Yin
3500ca62e2c2SSteve Yin if(xAcc.get())
3501ca62e2c2SSteve Yin return xAcc;
3502ca62e2c2SSteve Yin else
3503ca62e2c2SSteve Yin return NULL;
3504ca62e2c2SSteve Yin
3505ca62e2c2SSteve Yin }
PixelToCore(const Point & rPoint) const3506cdf0e10cSrcweir Point SwAccessibleMap::PixelToCore( const Point& rPoint ) const
3507cdf0e10cSrcweir {
3508cdf0e10cSrcweir Point aPoint;
3509cdf0e10cSrcweir if( GetShell()->GetWin() )
3510cdf0e10cSrcweir {
3511cdf0e10cSrcweir // OD 15.01.2003 #103492# - replace <PreviewAdjust(..)> by <GetMapMode(..)>
3512cdf0e10cSrcweir MapMode aMapMode;
3513cdf0e10cSrcweir GetMapMode( rPoint, aMapMode );
3514cdf0e10cSrcweir aPoint = GetShell()->GetWin()->PixelToLogic( rPoint, aMapMode );
3515cdf0e10cSrcweir }
3516cdf0e10cSrcweir return aPoint;
3517cdf0e10cSrcweir }
3518cdf0e10cSrcweir
lcl_CorrectCoarseValue(long aCoarseValue,long aFineValue,long aRefValue,bool bToLower)3519cdf0e10cSrcweir static inline long lcl_CorrectCoarseValue(long aCoarseValue, long aFineValue,
3520cdf0e10cSrcweir long aRefValue, bool bToLower)
3521cdf0e10cSrcweir {
3522cdf0e10cSrcweir long aResult = aCoarseValue;
3523cdf0e10cSrcweir
3524cdf0e10cSrcweir if (bToLower)
3525cdf0e10cSrcweir {
3526cdf0e10cSrcweir if (aFineValue < aRefValue)
3527cdf0e10cSrcweir aResult -= 1;
3528cdf0e10cSrcweir }
3529cdf0e10cSrcweir else
3530cdf0e10cSrcweir {
3531cdf0e10cSrcweir if (aFineValue > aRefValue)
3532cdf0e10cSrcweir aResult += 1;
3533cdf0e10cSrcweir }
3534cdf0e10cSrcweir
3535cdf0e10cSrcweir return aResult;
3536cdf0e10cSrcweir }
3537cdf0e10cSrcweir
lcl_CorrectRectangle(Rectangle & rRect,const Rectangle & rSource,const Rectangle & rInGrid)3538cdf0e10cSrcweir static inline void lcl_CorrectRectangle(Rectangle & rRect,
3539cdf0e10cSrcweir const Rectangle & rSource,
3540cdf0e10cSrcweir const Rectangle & rInGrid)
3541cdf0e10cSrcweir {
3542cdf0e10cSrcweir rRect.nLeft = lcl_CorrectCoarseValue(rRect.nLeft, rSource.nLeft,
3543cdf0e10cSrcweir rInGrid.nLeft, false);
3544cdf0e10cSrcweir rRect.nTop = lcl_CorrectCoarseValue(rRect.nTop, rSource.nTop,
3545cdf0e10cSrcweir rInGrid.nTop, false);
3546cdf0e10cSrcweir rRect.nRight = lcl_CorrectCoarseValue(rRect.nRight, rSource.nRight,
3547cdf0e10cSrcweir rInGrid.nRight, true);
3548cdf0e10cSrcweir rRect.nBottom = lcl_CorrectCoarseValue(rRect.nBottom, rSource.nBottom,
3549cdf0e10cSrcweir rInGrid.nBottom, true);
3550cdf0e10cSrcweir }
3551cdf0e10cSrcweir
CoreToPixel(const Rectangle & rRect) const3552cdf0e10cSrcweir Rectangle SwAccessibleMap::CoreToPixel( const Rectangle& rRect ) const
3553cdf0e10cSrcweir {
3554cdf0e10cSrcweir Rectangle aRect;
3555cdf0e10cSrcweir if( GetShell()->GetWin() )
3556cdf0e10cSrcweir {
3557cdf0e10cSrcweir // OD 15.01.2003 #103492# - replace <PreviewAdjust(..)> by <GetMapMode(..)>
3558cdf0e10cSrcweir MapMode aMapMode;
3559cdf0e10cSrcweir GetMapMode( rRect.TopLeft(), aMapMode );
3560cdf0e10cSrcweir aRect = GetShell()->GetWin()->LogicToPixel( rRect, aMapMode );
3561cdf0e10cSrcweir
3562cdf0e10cSrcweir Rectangle aTmpRect = GetShell()->GetWin()->PixelToLogic( aRect, aMapMode );
3563cdf0e10cSrcweir lcl_CorrectRectangle(aRect, rRect, aTmpRect);
3564cdf0e10cSrcweir }
3565cdf0e10cSrcweir
3566cdf0e10cSrcweir return aRect;
3567cdf0e10cSrcweir }
3568cdf0e10cSrcweir
3569cdf0e10cSrcweir /** get mapping mode for LogicToPixel and PixelToLogic conversions
3570cdf0e10cSrcweir
3571cdf0e10cSrcweir OD 15.01.2003 #103492#
3572cdf0e10cSrcweir Replacement method <PreviewAdjust(..)> by new method <GetMapMode>.
3573cdf0e10cSrcweir Method returns mapping mode of current output device and adjusts it,
3574cdf0e10cSrcweir if the shell is in page/print preview.
3575cdf0e10cSrcweir Necessary, because <PreviewAdjust(..)> changes mapping mode at current
3576cdf0e10cSrcweir output device for mapping logic document positions to page preview window
3577cdf0e10cSrcweir positions and vice versa and doesn't take care to recover its changes.
3578cdf0e10cSrcweir
3579cdf0e10cSrcweir @author OD
3580cdf0e10cSrcweir */
GetMapMode(const Point & _rPoint,MapMode & _orMapMode) const3581cdf0e10cSrcweir void SwAccessibleMap::GetMapMode( const Point& _rPoint,
3582cdf0e10cSrcweir MapMode& _orMapMode ) const
3583cdf0e10cSrcweir {
3584cdf0e10cSrcweir MapMode aMapMode = GetShell()->GetWin()->GetMapMode();
3585cdf0e10cSrcweir if( GetShell()->IsPreView() )
3586cdf0e10cSrcweir {
3587cdf0e10cSrcweir DBG_ASSERT( mpPreview != NULL, "need preview data" );
3588cdf0e10cSrcweir
3589cdf0e10cSrcweir mpPreview->AdjustMapMode( aMapMode, _rPoint );
3590cdf0e10cSrcweir }
3591cdf0e10cSrcweir _orMapMode = aMapMode;
3592cdf0e10cSrcweir }
3593cdf0e10cSrcweir
3594cdf0e10cSrcweir /** get size of a dedicated preview page
3595cdf0e10cSrcweir
3596cdf0e10cSrcweir OD 15.01.2003 #103492#
3597cdf0e10cSrcweir
3598cdf0e10cSrcweir @author OD
3599cdf0e10cSrcweir */
GetPreViewPageSize(sal_uInt16 _nPrevwPageNum) const3600cdf0e10cSrcweir Size SwAccessibleMap::GetPreViewPageSize( sal_uInt16 _nPrevwPageNum ) const
3601cdf0e10cSrcweir {
3602cdf0e10cSrcweir DBG_ASSERT( mpVSh->IsPreView(), "no page preview accessible." );
3603cdf0e10cSrcweir DBG_ASSERT( mpVSh->IsPreView() && ( mpPreview != NULL ),
3604cdf0e10cSrcweir "missing accessible preview data at page preview" );
3605cdf0e10cSrcweir if ( mpVSh->IsPreView() && ( mpPreview != NULL ) )
3606cdf0e10cSrcweir {
3607cdf0e10cSrcweir return mpVSh->PagePreviewLayout()->GetPrevwPageSizeByPageNum( _nPrevwPageNum );
3608cdf0e10cSrcweir }
3609cdf0e10cSrcweir else
3610cdf0e10cSrcweir {
3611cdf0e10cSrcweir return Size( 0, 0 );
3612cdf0e10cSrcweir }
3613cdf0e10cSrcweir }
3614cdf0e10cSrcweir
3615cdf0e10cSrcweir /** method to build up a new data structure of the accessible pararaphs,
3616cdf0e10cSrcweir which have a selection
3617cdf0e10cSrcweir
3618cdf0e10cSrcweir OD 2005-12-13 #i27301#
3619cdf0e10cSrcweir Important note: method has to used inside a mutual exclusive section
3620cdf0e10cSrcweir
3621cdf0e10cSrcweir @author OD
3622cdf0e10cSrcweir */
_BuildSelectedParas()3623cdf0e10cSrcweir SwAccessibleSelectedParas_Impl* SwAccessibleMap::_BuildSelectedParas()
3624cdf0e10cSrcweir {
3625cdf0e10cSrcweir // no accessible contexts, no selection
3626cdf0e10cSrcweir if ( !mpFrmMap )
3627cdf0e10cSrcweir {
3628cdf0e10cSrcweir return 0L;
3629cdf0e10cSrcweir }
3630cdf0e10cSrcweir
3631cdf0e10cSrcweir // get cursor as an instance of its base class <SwPaM>
3632cdf0e10cSrcweir SwPaM* pCrsr( 0L );
3633cdf0e10cSrcweir {
3634cdf0e10cSrcweir SwCrsrShell* pCrsrShell = dynamic_cast<SwCrsrShell*>(GetShell());
3635cdf0e10cSrcweir if ( pCrsrShell )
3636cdf0e10cSrcweir {
3637cdf0e10cSrcweir SwFEShell* pFEShell = dynamic_cast<SwFEShell*>(pCrsrShell);
3638cdf0e10cSrcweir if ( !pFEShell ||
3639cdf0e10cSrcweir ( !pFEShell->IsFrmSelected() &&
3640cdf0e10cSrcweir pFEShell->IsObjSelected() == 0 ) )
3641cdf0e10cSrcweir {
3642cdf0e10cSrcweir // get cursor without updating an existing table cursor.
3643cdf0e10cSrcweir pCrsr = pCrsrShell->GetCrsr( sal_False );
3644cdf0e10cSrcweir }
3645cdf0e10cSrcweir }
3646cdf0e10cSrcweir }
3647cdf0e10cSrcweir // no cursor, no selection
3648cdf0e10cSrcweir if ( !pCrsr )
3649cdf0e10cSrcweir {
3650cdf0e10cSrcweir return 0L;
3651cdf0e10cSrcweir }
3652cdf0e10cSrcweir
3653cdf0e10cSrcweir SwAccessibleSelectedParas_Impl* pRetSelectedParas( 0L );
3654cdf0e10cSrcweir
3655cdf0e10cSrcweir // loop on all cursors
3656cdf0e10cSrcweir SwPaM* pRingStart = pCrsr;
3657cdf0e10cSrcweir do {
3658cdf0e10cSrcweir
3659cdf0e10cSrcweir // for a selection the cursor has to have a mark.
3660cdf0e10cSrcweir // for savety reasons assure that point and mark are in text nodes
3661cdf0e10cSrcweir if ( pCrsr->HasMark() &&
3662cdf0e10cSrcweir pCrsr->GetPoint()->nNode.GetNode().IsTxtNode() &&
3663cdf0e10cSrcweir pCrsr->GetMark()->nNode.GetNode().IsTxtNode() )
3664cdf0e10cSrcweir {
3665cdf0e10cSrcweir SwPosition* pStartPos = pCrsr->Start();
3666cdf0e10cSrcweir SwPosition* pEndPos = pCrsr->End();
3667cdf0e10cSrcweir // loop on all text nodes inside the selection
3668cdf0e10cSrcweir SwNodeIndex aIdx( pStartPos->nNode );
3669cdf0e10cSrcweir for ( ; aIdx.GetIndex() <= pEndPos->nNode.GetIndex(); ++aIdx )
3670cdf0e10cSrcweir {
3671cdf0e10cSrcweir SwTxtNode* pTxtNode( aIdx.GetNode().GetTxtNode() );
3672cdf0e10cSrcweir if ( pTxtNode )
3673cdf0e10cSrcweir {
3674cdf0e10cSrcweir // loop on all text frames registered at the text node.
3675cdf0e10cSrcweir SwIterator<SwTxtFrm,SwTxtNode> aIter( *pTxtNode );
3676cdf0e10cSrcweir for( SwTxtFrm* pTxtFrm = aIter.First(); pTxtFrm; pTxtFrm = aIter.Next() )
3677cdf0e10cSrcweir {
3678cdf0e10cSrcweir uno::WeakReference < XAccessible > xWeakAcc;
3679cdf0e10cSrcweir SwAccessibleContextMap_Impl::iterator aMapIter =
3680cdf0e10cSrcweir mpFrmMap->find( pTxtFrm );
3681cdf0e10cSrcweir if( aMapIter != mpFrmMap->end() )
3682cdf0e10cSrcweir {
3683cdf0e10cSrcweir xWeakAcc = (*aMapIter).second;
3684cdf0e10cSrcweir SwAccessibleParaSelection aDataEntry(
3685cdf0e10cSrcweir pTxtNode == &(pStartPos->nNode.GetNode())
3686cdf0e10cSrcweir ? pStartPos->nContent.GetIndex()
3687cdf0e10cSrcweir : 0,
3688cdf0e10cSrcweir pTxtNode == &(pEndPos->nNode.GetNode())
3689cdf0e10cSrcweir ? pEndPos->nContent.GetIndex()
3690cdf0e10cSrcweir : STRING_LEN );
3691cdf0e10cSrcweir SwAccessibleSelectedParas_Impl::value_type
3692cdf0e10cSrcweir aEntry( xWeakAcc, aDataEntry );
3693cdf0e10cSrcweir if ( !pRetSelectedParas )
3694cdf0e10cSrcweir {
3695cdf0e10cSrcweir pRetSelectedParas =
3696cdf0e10cSrcweir new SwAccessibleSelectedParas_Impl;
3697cdf0e10cSrcweir }
3698cdf0e10cSrcweir pRetSelectedParas->insert( aEntry );
3699cdf0e10cSrcweir }
3700cdf0e10cSrcweir }
3701cdf0e10cSrcweir }
3702cdf0e10cSrcweir }
3703cdf0e10cSrcweir }
3704cdf0e10cSrcweir
3705cdf0e10cSrcweir // prepare next turn: get next cursor in ring
3706cdf0e10cSrcweir pCrsr = static_cast<SwPaM*>( pCrsr->GetNext() );
3707cdf0e10cSrcweir } while ( pCrsr != pRingStart );
3708cdf0e10cSrcweir
3709cdf0e10cSrcweir return pRetSelectedParas;
3710cdf0e10cSrcweir }
3711cdf0e10cSrcweir
3712cdf0e10cSrcweir /** invalidation of text selection of all paragraphs
3713cdf0e10cSrcweir
3714cdf0e10cSrcweir OD 2005-12-13 #i27301#
3715cdf0e10cSrcweir
3716cdf0e10cSrcweir @author OD
3717cdf0e10cSrcweir */
InvalidateTextSelectionOfAllParas()3718cdf0e10cSrcweir void SwAccessibleMap::InvalidateTextSelectionOfAllParas()
3719cdf0e10cSrcweir {
3720cdf0e10cSrcweir vos::OGuard aGuard( maMutex );
3721cdf0e10cSrcweir
3722cdf0e10cSrcweir // keep previously known selected paragraphs
3723cdf0e10cSrcweir SwAccessibleSelectedParas_Impl* pPrevSelectedParas( mpSelectedParas );
3724cdf0e10cSrcweir
3725cdf0e10cSrcweir // determine currently selected paragraphs
3726cdf0e10cSrcweir mpSelectedParas = _BuildSelectedParas();
3727cdf0e10cSrcweir
3728cdf0e10cSrcweir // compare currently selected paragraphs with the previously selected
3729cdf0e10cSrcweir // paragraphs and submit corresponding TEXT_SELECTION_CHANGED events.
3730cdf0e10cSrcweir // first, search for new and changed selections.
3731cdf0e10cSrcweir // on the run remove selections from previously known ones, if they are
3732cdf0e10cSrcweir // also in the current ones.
3733cdf0e10cSrcweir if ( mpSelectedParas )
3734cdf0e10cSrcweir {
3735cdf0e10cSrcweir SwAccessibleSelectedParas_Impl::iterator aIter = mpSelectedParas->begin();
3736cdf0e10cSrcweir for ( ; aIter != mpSelectedParas->end(); ++aIter )
3737cdf0e10cSrcweir {
3738cdf0e10cSrcweir bool bSubmitEvent( false );
3739cdf0e10cSrcweir if ( !pPrevSelectedParas )
3740cdf0e10cSrcweir {
3741cdf0e10cSrcweir // new selection
3742cdf0e10cSrcweir bSubmitEvent = true;
3743cdf0e10cSrcweir }
3744cdf0e10cSrcweir else
3745cdf0e10cSrcweir {
3746cdf0e10cSrcweir SwAccessibleSelectedParas_Impl::iterator aPrevSelected =
3747cdf0e10cSrcweir pPrevSelectedParas->find( (*aIter).first );
3748cdf0e10cSrcweir if ( aPrevSelected != pPrevSelectedParas->end() )
3749cdf0e10cSrcweir {
3750cdf0e10cSrcweir // check, if selection has changed
3751cdf0e10cSrcweir if ( (*aIter).second.nStartOfSelection !=
3752cdf0e10cSrcweir (*aPrevSelected).second.nStartOfSelection ||
3753cdf0e10cSrcweir (*aIter).second.nEndOfSelection !=
3754cdf0e10cSrcweir (*aPrevSelected).second.nEndOfSelection )
3755cdf0e10cSrcweir {
3756cdf0e10cSrcweir // changed selection
3757cdf0e10cSrcweir bSubmitEvent = true;
3758cdf0e10cSrcweir }
3759cdf0e10cSrcweir pPrevSelectedParas->erase( aPrevSelected );
3760cdf0e10cSrcweir }
3761cdf0e10cSrcweir else
3762cdf0e10cSrcweir {
3763cdf0e10cSrcweir // new selection
3764cdf0e10cSrcweir bSubmitEvent = true;
3765cdf0e10cSrcweir }
3766cdf0e10cSrcweir }
3767cdf0e10cSrcweir
3768cdf0e10cSrcweir if ( bSubmitEvent )
3769cdf0e10cSrcweir {
3770cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).first );
3771cdf0e10cSrcweir if ( xAcc.is() )
3772cdf0e10cSrcweir {
3773cdf0e10cSrcweir ::vos::ORef < SwAccessibleContext > xAccImpl(
3774cdf0e10cSrcweir static_cast<SwAccessibleContext*>( xAcc.get() ) );
3775cdf0e10cSrcweir if ( xAccImpl.isValid() && xAccImpl->GetFrm() )
3776cdf0e10cSrcweir {
3777cdf0e10cSrcweir const SwTxtFrm* pTxtFrm(
3778cdf0e10cSrcweir dynamic_cast<const SwTxtFrm*>(xAccImpl->GetFrm()) );
3779cdf0e10cSrcweir ASSERT( pTxtFrm,
3780cdf0e10cSrcweir "<SwAccessibleMap::_SubmitTextSelectionChangedEvents()> - unexcepted type of frame" );
3781cdf0e10cSrcweir if ( pTxtFrm )
3782cdf0e10cSrcweir {
3783cdf0e10cSrcweir InvalidateParaTextSelection( *pTxtFrm );
3784cdf0e10cSrcweir }
3785cdf0e10cSrcweir }
3786cdf0e10cSrcweir }
3787cdf0e10cSrcweir }
3788cdf0e10cSrcweir }
3789cdf0e10cSrcweir }
3790cdf0e10cSrcweir
3791cdf0e10cSrcweir // second, handle previous selections - after the first step the data
3792cdf0e10cSrcweir // structure of the previously known only contains the 'old' selections
3793cdf0e10cSrcweir if ( pPrevSelectedParas )
3794cdf0e10cSrcweir {
3795cdf0e10cSrcweir SwAccessibleSelectedParas_Impl::iterator aIter = pPrevSelectedParas->begin();
3796cdf0e10cSrcweir for ( ; aIter != pPrevSelectedParas->end(); ++aIter )
3797cdf0e10cSrcweir {
3798cdf0e10cSrcweir uno::Reference < XAccessible > xAcc( (*aIter).first );
3799cdf0e10cSrcweir if ( xAcc.is() )
3800cdf0e10cSrcweir {
3801cdf0e10cSrcweir ::vos::ORef < SwAccessibleContext > xAccImpl(
3802cdf0e10cSrcweir static_cast<SwAccessibleContext*>( xAcc.get() ) );
3803cdf0e10cSrcweir if ( xAccImpl.isValid() && xAccImpl->GetFrm() )
3804cdf0e10cSrcweir {
3805cdf0e10cSrcweir const SwTxtFrm* pTxtFrm(
3806cdf0e10cSrcweir dynamic_cast<const SwTxtFrm*>(xAccImpl->GetFrm()) );
3807cdf0e10cSrcweir ASSERT( pTxtFrm,
3808cdf0e10cSrcweir "<SwAccessibleMap::_SubmitTextSelectionChangedEvents()> - unexcepted type of frame" );
3809cdf0e10cSrcweir if ( pTxtFrm )
3810cdf0e10cSrcweir {
3811cdf0e10cSrcweir InvalidateParaTextSelection( *pTxtFrm );
3812cdf0e10cSrcweir }
3813cdf0e10cSrcweir }
3814cdf0e10cSrcweir }
3815cdf0e10cSrcweir }
3816cdf0e10cSrcweir
3817cdf0e10cSrcweir delete pPrevSelectedParas;
3818cdf0e10cSrcweir }
3819cdf0e10cSrcweir }
3820cdf0e10cSrcweir
GetVisArea() const3821cdf0e10cSrcweir const SwRect& SwAccessibleMap::GetVisArea() const
3822cdf0e10cSrcweir {
3823cdf0e10cSrcweir DBG_ASSERT( !GetShell()->IsPreView() || (mpPreview != NULL),
3824cdf0e10cSrcweir "preview without preview data?" );
3825cdf0e10cSrcweir
3826cdf0e10cSrcweir return GetShell()->IsPreView()
3827cdf0e10cSrcweir ? mpPreview->GetVisArea()
3828cdf0e10cSrcweir : GetShell()->VisArea();
3829cdf0e10cSrcweir }
3830cdf0e10cSrcweir
IsDocumentSelAll()3831ca62e2c2SSteve Yin sal_Bool SwAccessibleMap::IsDocumentSelAll()
3832ca62e2c2SSteve Yin {
3833ca62e2c2SSteve Yin return GetShell()->GetDoc()->IsPrepareSelAll();
3834ca62e2c2SSteve Yin }
3835ca62e2c2SSteve Yin
3836