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