xref: /trunk/main/editeng/source/uno/unoedprx.cxx (revision 1ba24eae) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_editeng.hxx"
26 
27 //------------------------------------------------------------------------
28 //
29 // Global header
30 //
31 //------------------------------------------------------------------------
32 
33 #include <limits.h>
34 #include <vector>
35 #include <algorithm>
36 #include <vos/mutex.hxx>
37 #include <vcl/window.hxx>
38 #include <vcl/svapp.hxx>
39 #include <com/sun/star/uno/Any.hxx>
40 #include <com/sun/star/uno/Reference.hxx>
41 
42 //------------------------------------------------------------------------
43 //
44 // Project-local header
45 //
46 //------------------------------------------------------------------------
47 #include "editeng/unoedprx.hxx"
48 #include <editeng/unotext.hxx>
49 #include <editeng/unoedhlp.hxx>
50 #include <editeng/editdata.hxx>
51 #include <editeng/editeng.hxx>
52 #include <editeng/editview.hxx>
53 #include <editeng/AccessibleStringWrap.hxx>
54 #include <editeng/outliner.hxx>
55 
56 using namespace ::com::sun::star;
57 
58 
59 class SvxAccessibleTextIndex
60 {
61 public:
62     SvxAccessibleTextIndex() :
63         mnPara(0),
64         mnIndex(0),
65         mnEEIndex(0),
66         mnFieldOffset(0),
67         mnFieldLen(0),
68         mbInField(sal_False),
69         mnBulletOffset(0),
70         mnBulletLen(0),
71         mbInBullet(sal_False) {};
72     ~SvxAccessibleTextIndex() {};
73 
74     // Get/Set current paragraph
75     void SetParagraph( sal_uInt32 nPara )
76     {
77         mnPara = nPara;
78     }
79     sal_uInt32 GetParagraph() const { return mnPara; }
80 
81     /** Set the index in the UAA semantic
82 
83         @param nIndex
84      	The index from the UA API (fields and bullets are expanded)
85 
86         @param rTF
87         The text forwarder to use in the calculations
88      */
89     void SetIndex( sal_Int32 nIndex, const SvxTextForwarder& rTF );
90     void SetIndex( sal_uInt16 nPara, sal_Int32 nIndex, const SvxTextForwarder& rTF ) { SetParagraph(nPara); SetIndex(nIndex, rTF); }
91     sal_Int32 GetIndex() const { return mnIndex; }
92 
93     /** Set the index in the edit engine semantic
94 
95     	Update the object state to reflect the given index position in
96     	EditEngine/Outliner index values
97 
98         @param nEEIndex
99      	The index from the edit engine (fields span exactly one index increment)
100 
101         @param rTF
102         The text forwarder to use in the calculations
103      */
104     void SetEEIndex( sal_uInt16 nEEIndex, const SvxTextForwarder& rTF );
105     void SetEEIndex( sal_uInt16 nPara, sal_uInt16 nEEIndex, const SvxTextForwarder& rTF ) { SetParagraph(nPara); SetEEIndex(nEEIndex, rTF); }
106     sal_uInt16 GetEEIndex() const;
107 
108     void SetFieldOffset( sal_Int32 nOffset, sal_Int32 nLen ) { mnFieldOffset = nOffset; mnFieldLen = nLen; }
109     sal_Int32 GetFieldOffset() const { return mnFieldOffset; }
110     sal_Int32 GetFieldLen() const { return mnFieldLen; }
111     void AreInField( sal_Bool bInField = sal_True ) { mbInField = bInField; }
112     sal_Bool InField() const { return mbInField; }
113 
114     void SetBulletOffset( sal_Int32 nOffset, sal_Int32 nLen ) { mnBulletOffset = nOffset; mnBulletLen = nLen; }
115     sal_Int32 GetBulletOffset() const { return mnBulletOffset; }
116     sal_Int32 GetBulletLen() const { return mnBulletLen; }
117     void AreInBullet( sal_Bool bInBullet = sal_True ) { mbInBullet = bInBullet; }
118     sal_Bool InBullet() const { return mbInBullet; }
119 
120     /// returns false if the current index contains non-editable text (e.g. bullets)
121     sal_Bool IsEditable() const;
122 
123     /// returns false if the given range is non-editable (e.g. contains bullets or _parts_ of fields)
124     sal_Bool IsEditableRange( const SvxAccessibleTextIndex& rEnd ) const;
125 
126 private:
127     sal_uInt32 	  mnPara;
128     sal_Int32 mnIndex;
129     sal_Int32 mnEEIndex;
130     sal_Int32 mnFieldOffset;
131     sal_Int32 mnFieldLen;
132     sal_Bool  mbInField;
133     sal_Int32 mnBulletOffset;
134     sal_Int32 mnBulletLen;
135     sal_Bool  mbInBullet;
136 };
137 
138 ESelection MakeEESelection( const SvxAccessibleTextIndex& rStart, const SvxAccessibleTextIndex& rEnd )
139 {
140     // deal with field special case: to really get a field contained
141     // within a selection, the start index must be before or on the
142     // field, the end index after it.
143 
144     // The SvxAccessibleTextIndex.GetEEIndex method gives the index on
145     // the field, as long the input index is on the field. Thus,
146     // correction necessary for the end index
147 
148     // Therefore, for _ranges_, if part of the field is touched, all
149     // of the field must be selected
150     if( rStart.GetParagraph() <= rEnd.GetParagraph() ||
151         (rStart.GetParagraph() == rEnd.GetParagraph() &&
152          rStart.GetEEIndex() <= rEnd.GetEEIndex()) )
153     {
154         if( rEnd.InField() && rEnd.GetFieldOffset() )
155             return ESelection( rStart.GetParagraph(), rStart.GetEEIndex(),
156                                rEnd.GetParagraph(), rEnd.GetEEIndex()+1 );
157     }
158     else if( rStart.GetParagraph() > rEnd.GetParagraph() ||
159              (rStart.GetParagraph() == rEnd.GetParagraph() &&
160               rStart.GetEEIndex() > rEnd.GetEEIndex()) )
161     {
162         if( rStart.InField() && rStart.GetFieldOffset()  )
163             return ESelection( rStart.GetParagraph(), rStart.GetEEIndex()+1,
164                                rEnd.GetParagraph(), rEnd.GetEEIndex() );
165     }
166 
167     return ESelection( rStart.GetParagraph(), rStart.GetEEIndex(),
168                        rEnd.GetParagraph(), rEnd.GetEEIndex() );
169 }
170 
171 ESelection MakeEESelection( const SvxAccessibleTextIndex& rIndex )
172 {
173     return ESelection( rIndex.GetParagraph(), rIndex.GetEEIndex(),
174                        rIndex.GetParagraph(), rIndex.GetEEIndex() + 1 );
175 }
176 
177 sal_uInt16 SvxAccessibleTextIndex::GetEEIndex() const
178 {
179     DBG_ASSERT(mnEEIndex >= 0 && mnEEIndex <= USHRT_MAX,
180                "SvxAccessibleTextIndex::GetEEIndex: index value overflow");
181 
182     return static_cast< sal_uInt16 > (mnEEIndex);
183 }
184 
185 void SvxAccessibleTextIndex::SetEEIndex( sal_uInt16 nEEIndex, const SvxTextForwarder& rTF )
186 {
187     // reset
188     mnFieldOffset = 0;
189     mbInField = sal_False;
190     mnFieldLen = 0;
191     mnBulletOffset = 0;
192     mbInBullet = sal_False;
193     mnBulletLen = 0;
194 
195     // set known values
196     mnEEIndex = nEEIndex;
197 
198     // calculate unknowns
199     sal_uInt16					nCurrField, nFieldCount = rTF.GetFieldCount( GetParagraph() );
200 
201     mnIndex = nEEIndex;
202 
203     EBulletInfo aBulletInfo = rTF.GetBulletInfo( GetParagraph() );
204 
205     // any text bullets?
206     if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
207         aBulletInfo.bVisible &&
208         aBulletInfo.nType != SVX_NUM_BITMAP )
209     {
210         mnIndex += aBulletInfo.aText.Len();
211     }
212 
213     for( nCurrField=0; nCurrField < nFieldCount; ++nCurrField )
214     {
215         EFieldInfo aFieldInfo( rTF.GetFieldInfo( GetParagraph(), nCurrField ) );
216 
217         if( aFieldInfo.aPosition.nIndex > nEEIndex )
218             break;
219 
220         if( aFieldInfo.aPosition.nIndex == nEEIndex )
221         {
222             AreInField();
223             break;
224         }
225 
226         // #106010#
227         mnIndex += ::std::max(aFieldInfo.aCurrentText.Len()-1, 0);
228     }
229 }
230 
231 void SvxAccessibleTextIndex::SetIndex( sal_Int32 nIndex, const SvxTextForwarder& rTF )
232 {
233     // reset
234     mnFieldOffset = 0;
235     mbInField = sal_False;
236     mnFieldLen = 0;
237     mnBulletOffset = 0;
238     mbInBullet = sal_False;
239     mnBulletLen = 0;
240 
241     // set known values
242     mnIndex = nIndex;
243 
244     // calculate unknowns
245     sal_uInt16					nCurrField, nFieldCount = rTF.GetFieldCount( GetParagraph() );
246 
247     DBG_ASSERT(nIndex >= 0 && nIndex <= USHRT_MAX,
248                "SvxAccessibleTextIndex::SetIndex: index value overflow");
249 
250     mnEEIndex = nIndex;
251 
252     EBulletInfo aBulletInfo = rTF.GetBulletInfo( GetParagraph() );
253 
254     // any text bullets?
255     if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
256         aBulletInfo.bVisible &&
257         aBulletInfo.nType != SVX_NUM_BITMAP )
258     {
259         sal_Int32 nBulletLen = aBulletInfo.aText.Len();
260 
261         if( nIndex < nBulletLen )
262         {
263             AreInBullet();
264             SetBulletOffset( nIndex, nBulletLen );
265             mnEEIndex = 0;
266             return;
267         }
268 
269         mnEEIndex = mnEEIndex - nBulletLen;
270     }
271 
272     for( nCurrField=0; nCurrField < nFieldCount; ++nCurrField )
273     {
274         EFieldInfo aFieldInfo( rTF.GetFieldInfo( GetParagraph(), nCurrField ) );
275 
276         // we're before a field
277         if( aFieldInfo.aPosition.nIndex > mnEEIndex )
278             break;
279 
280         // #106010#
281         mnEEIndex -= ::std::max(aFieldInfo.aCurrentText.Len()-1, 0);
282 
283         // we're within a field
284         if( aFieldInfo.aPosition.nIndex >= mnEEIndex )
285         {
286             AreInField();
287             SetFieldOffset( ::std::max(aFieldInfo.aCurrentText.Len()-1, 0) - (aFieldInfo.aPosition.nIndex - mnEEIndex),
288                             aFieldInfo.aCurrentText.Len() );
289             mnEEIndex = aFieldInfo.aPosition.nIndex ;
290             break;
291         }
292     }
293 }
294 
295 sal_Bool SvxAccessibleTextIndex::IsEditable() const
296 {
297     if( InBullet() || InField() )
298         return sal_False;
299 
300     return sal_True;
301 }
302 
303 sal_Bool SvxAccessibleTextIndex::IsEditableRange( const SvxAccessibleTextIndex& rEnd ) const
304 {
305     if( GetIndex() > rEnd.GetIndex() )
306         return rEnd.IsEditableRange( *this );
307 
308     if( InBullet() || rEnd.InBullet() )
309         return sal_False;
310 
311     if( InField() && GetFieldOffset() )
312         return sal_False; // within field
313 
314     if( rEnd.InField() && rEnd.GetFieldOffset() >= rEnd.GetFieldLen() - 1 )
315         return sal_False; // within field
316 
317     return sal_True;
318 }
319 
320 //---------------------------------------------------------------------------------
321 
322 SvxEditSourceAdapter::SvxEditSourceAdapter() : mbEditSourceValid( sal_False )
323 {
324 }
325 
326 SvxEditSourceAdapter::~SvxEditSourceAdapter()
327 {
328 }
329 
330 SvxEditSource* SvxEditSourceAdapter::Clone() const
331 {
332     if( mbEditSourceValid && mpAdaptee.get() )
333     {
334         ::std::auto_ptr< SvxEditSource > pClonedAdaptee( mpAdaptee->Clone() );
335 
336         if( pClonedAdaptee.get() )
337         {
338             SvxEditSourceAdapter* pClone = new SvxEditSourceAdapter();
339 
340             if( pClone )
341             {
342                 pClone->SetEditSource( pClonedAdaptee );
343                 return pClone;
344             }
345         }
346     }
347 
348     return NULL;
349 }
350 
351 SvxAccessibleTextAdapter* SvxEditSourceAdapter::GetTextForwarderAdapter()
352 {
353     if( mbEditSourceValid && mpAdaptee.get() )
354     {
355         SvxTextForwarder* pTextForwarder = mpAdaptee->GetTextForwarder();
356 
357         if( pTextForwarder )
358         {
359             maTextAdapter.SetForwarder(*pTextForwarder);
360 
361             return &maTextAdapter;
362         }
363     }
364 
365     return NULL;
366 }
367 
368 SvxTextForwarder* SvxEditSourceAdapter::GetTextForwarder()
369 {
370     return GetTextForwarderAdapter();
371 }
372 
373 SvxViewForwarder* SvxEditSourceAdapter::GetViewForwarder()
374 {
375     if( mbEditSourceValid && mpAdaptee.get() )
376         return mpAdaptee->GetViewForwarder();
377 
378     return NULL;
379 }
380 
381 SvxAccessibleTextEditViewAdapter* SvxEditSourceAdapter::GetEditViewForwarderAdapter( sal_Bool bCreate )
382 {
383     if( mbEditSourceValid && mpAdaptee.get() )
384     {
385         SvxEditViewForwarder* pEditViewForwarder = mpAdaptee->GetEditViewForwarder(bCreate);
386 
387         if( pEditViewForwarder )
388         {
389             SvxAccessibleTextAdapter* pTextAdapter = GetTextForwarderAdapter();
390 
391             if( pTextAdapter )
392             {
393                 maEditViewAdapter.SetForwarder(*pEditViewForwarder, *pTextAdapter);
394 
395                 return &maEditViewAdapter;
396             }
397         }
398     }
399 
400     return NULL;
401 }
402 
403 SvxEditViewForwarder* SvxEditSourceAdapter::GetEditViewForwarder( sal_Bool bCreate )
404 {
405     return GetEditViewForwarderAdapter( bCreate );
406 }
407 
408 void SvxEditSourceAdapter::UpdateData()
409 {
410     if( mbEditSourceValid && mpAdaptee.get() )
411         mpAdaptee->UpdateData();
412 }
413 
414 SfxBroadcaster& SvxEditSourceAdapter::GetBroadcaster() const
415 {
416     if( mbEditSourceValid && mpAdaptee.get() )
417         return mpAdaptee->GetBroadcaster();
418 
419     return maDummyBroadcaster;
420 }
421 
422 void SvxEditSourceAdapter::SetEditSource( ::std::auto_ptr< SvxEditSource > pAdaptee )
423 {
424     if( pAdaptee.get() )
425     {
426         mpAdaptee = pAdaptee;
427         mbEditSourceValid = sal_True;
428     }
429     else
430     {
431         // do a lazy delete (prevents us from deleting the broadcaster
432         // from within a broadcast in
433         // AccessibleTextHelper_Impl::Notify)
434         mbEditSourceValid = sal_False;
435     }
436 }
437 
438 sal_Bool SvxEditSourceAdapter::IsValid() const
439 {
440     return mbEditSourceValid;
441 }
442 
443 
444 //--------------------------------------------------------------------------------------
445 
446 SvxAccessibleTextAdapter::SvxAccessibleTextAdapter() : mrTextForwarder( NULL )
447 {
448 }
449 
450 SvxAccessibleTextAdapter::~SvxAccessibleTextAdapter()
451 {
452 }
453 
454 sal_uInt32 SvxAccessibleTextAdapter::GetParagraphCount() const
455 {
456     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
457 
458     return mrTextForwarder->GetParagraphCount();
459 }
460 
461 sal_uInt16 SvxAccessibleTextAdapter::GetTextLen( sal_uInt32 nParagraph ) const
462 {
463     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
464 
465     SvxAccessibleTextIndex aIndex;
466     aIndex.SetEEIndex( nParagraph, mrTextForwarder->GetTextLen( nParagraph ), *this );
467 
468     return static_cast< sal_uInt16 >(aIndex.GetIndex());
469 }
470 
471 String SvxAccessibleTextAdapter::GetText( const ESelection& rSel ) const
472 {
473     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
474 
475     SvxAccessibleTextIndex aStartIndex;
476     SvxAccessibleTextIndex aEndIndex;
477 
478     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
479     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
480 
481     // normalize selection
482     if( rSel.nStartPara > rSel.nEndPara ||
483         (rSel.nStartPara == rSel.nEndPara && rSel.nStartPos > rSel.nEndPos) )
484     {
485         ::std::swap( aStartIndex, aEndIndex );
486     }
487 
488     String sStr = mrTextForwarder->GetText( MakeEESelection(aStartIndex, aEndIndex) );
489 
490     // trim field text, if necessary
491     if( aStartIndex.InField() )
492     {
493         DBG_ASSERT(aStartIndex.GetFieldOffset() >= 0 &&
494                    aStartIndex.GetFieldOffset() <= USHRT_MAX,
495                    "SvxAccessibleTextIndex::GetText: index value overflow");
496 
497         sStr.Erase(0, static_cast< sal_uInt16 > (aStartIndex.GetFieldOffset()) );
498     }
499     if( aEndIndex.InField() && aEndIndex.GetFieldOffset() )
500     {
501         DBG_ASSERT(sStr.Len() - (aEndIndex.GetFieldLen() - aEndIndex.GetFieldOffset()) >= 0 &&
502                    sStr.Len() - (aEndIndex.GetFieldLen() - aEndIndex.GetFieldOffset()) <= USHRT_MAX,
503                    "SvxAccessibleTextIndex::GetText: index value overflow");
504 
505         sStr = sStr.Copy(0, static_cast< sal_uInt16 > (sStr.Len() - (aEndIndex.GetFieldLen() - aEndIndex.GetFieldOffset())) );
506     }
507 
508     EBulletInfo aBulletInfo1 = GetBulletInfo( aStartIndex.GetParagraph() );
509     EBulletInfo aBulletInfo2 = GetBulletInfo( aEndIndex.GetParagraph() );
510 
511     if( aEndIndex.InBullet() )
512     {
513         // append trailing bullet
514         sStr += aBulletInfo2.aText;;
515 
516         DBG_ASSERT(sStr.Len() - (aEndIndex.GetBulletLen() - aEndIndex.GetBulletOffset()) >= 0 &&
517                    sStr.Len() - (aEndIndex.GetBulletLen() - aEndIndex.GetBulletOffset()) <= USHRT_MAX,
518                    "SvxAccessibleTextIndex::GetText: index value overflow");
519 
520         sStr = sStr.Copy(0, static_cast< sal_uInt16 > (sStr.Len() - (aEndIndex.GetBulletLen() - aEndIndex.GetBulletOffset())) );
521     }
522     else if( aStartIndex.GetParagraph() != aEndIndex.GetParagraph() &&
523              HaveTextBullet( aEndIndex.GetParagraph() ) )
524     {
525         String sBullet = aBulletInfo2.aText;
526 
527         DBG_ASSERT(sBullet.Len() - (aEndIndex.GetBulletLen() - aEndIndex.GetBulletOffset()) >= 0 &&
528                    sBullet.Len() - (aEndIndex.GetBulletLen() - aEndIndex.GetBulletOffset()) <= USHRT_MAX,
529                    "SvxAccessibleTextIndex::GetText: index value overflow");
530 
531         sBullet = sBullet.Copy(0, static_cast< sal_uInt16 > (sBullet.Len() - (aEndIndex.GetBulletLen() - aEndIndex.GetBulletOffset())) );
532 
533         // insert bullet
534         sStr.Insert( sBullet,
535                      static_cast< sal_uInt16 > (GetTextLen(aStartIndex.GetParagraph()) - aStartIndex.GetIndex()) );
536     }
537 
538     return sStr;
539 }
540 
541 SfxItemSet SvxAccessibleTextAdapter::GetAttribs( const ESelection& rSel, sal_Bool bOnlyHardAttrib ) const
542 {
543     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
544 
545     SvxAccessibleTextIndex aStartIndex;
546     SvxAccessibleTextIndex aEndIndex;
547 
548     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
549     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
550 
551     return mrTextForwarder->GetAttribs( MakeEESelection(aStartIndex, aEndIndex),
552                                         bOnlyHardAttrib );
553 }
554 
555 SfxItemSet SvxAccessibleTextAdapter::GetParaAttribs( sal_uInt32 nPara ) const
556 {
557     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
558 
559     return mrTextForwarder->GetParaAttribs( nPara );
560 }
561 
562 void SvxAccessibleTextAdapter::SetParaAttribs( sal_uInt32 nPara, const SfxItemSet& rSet )
563 {
564     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
565 
566     mrTextForwarder->SetParaAttribs( nPara, rSet );
567 }
568 
569 void SvxAccessibleTextAdapter::RemoveAttribs( const ESelection& , sal_Bool , sal_uInt16 )
570 {
571     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
572 }
573 
574 void SvxAccessibleTextAdapter::GetPortions( sal_uInt32 nPara, SvUShorts& rList ) const
575 {
576     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
577 
578     mrTextForwarder->GetPortions( nPara, rList );
579 }
580 
581 sal_uInt16 SvxAccessibleTextAdapter::GetItemState( const ESelection& rSel, sal_uInt16 nWhich ) const
582 {
583     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
584 
585     SvxAccessibleTextIndex aStartIndex;
586     SvxAccessibleTextIndex aEndIndex;
587 
588     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
589     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
590 
591     return mrTextForwarder->GetItemState( MakeEESelection(aStartIndex, aEndIndex),
592                                           nWhich );
593 }
594 
595 sal_uInt16 SvxAccessibleTextAdapter::GetItemState( sal_uInt32 nPara, sal_uInt16 nWhich ) const
596 {
597     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
598 
599     return mrTextForwarder->GetItemState( nPara, nWhich );
600 }
601 
602 void SvxAccessibleTextAdapter::QuickInsertText( const String& rText, const ESelection& rSel )
603 {
604     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
605 
606     SvxAccessibleTextIndex aStartIndex;
607     SvxAccessibleTextIndex aEndIndex;
608 
609     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
610     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
611 
612     mrTextForwarder->QuickInsertText( rText,
613                                       MakeEESelection(aStartIndex, aEndIndex) );
614 }
615 
616 void SvxAccessibleTextAdapter::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
617 {
618     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
619 
620     SvxAccessibleTextIndex aStartIndex;
621     SvxAccessibleTextIndex aEndIndex;
622 
623     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
624     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
625 
626     mrTextForwarder->QuickInsertField( rFld,
627                                        MakeEESelection(aStartIndex, aEndIndex) );
628 }
629 
630 void SvxAccessibleTextAdapter::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
631 {
632     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
633 
634     SvxAccessibleTextIndex aStartIndex;
635     SvxAccessibleTextIndex aEndIndex;
636 
637     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
638     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
639 
640     mrTextForwarder->QuickSetAttribs( rSet,
641                                       MakeEESelection(aStartIndex, aEndIndex) );
642 }
643 
644 void SvxAccessibleTextAdapter::QuickInsertLineBreak( const ESelection& rSel )
645 {
646     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
647 
648     SvxAccessibleTextIndex aStartIndex;
649     SvxAccessibleTextIndex aEndIndex;
650 
651     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
652     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
653 
654     mrTextForwarder->QuickInsertLineBreak( MakeEESelection(aStartIndex, aEndIndex) );
655 }
656 
657 SfxItemPool* SvxAccessibleTextAdapter::GetPool() const
658 {
659     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
660 
661     return mrTextForwarder->GetPool();
662 }
663 
664 XubString SvxAccessibleTextAdapter::CalcFieldValue( const SvxFieldItem& rField, sal_uInt32 nPara, sal_uInt16 nPos, Color*& rpTxtColor, Color*& rpFldColor )
665 {
666     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
667 
668     return mrTextForwarder->CalcFieldValue( rField, nPara, nPos, rpTxtColor, rpFldColor );
669 }
670 
671 void SvxAccessibleTextAdapter::FieldClicked( const SvxFieldItem& rField, sal_uInt32 nPara, xub_StrLen nPos )
672 {
673     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
674 
675     mrTextForwarder->FieldClicked( rField, nPara, nPos );
676 }
677 
678 sal_Int32 SvxAccessibleTextAdapter::CalcLogicalIndex( sal_uInt32 nPara, sal_uInt16 nEEIndex )
679 {
680     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
681 
682     SvxAccessibleTextIndex aIndex;
683     aIndex.SetEEIndex(nPara, nEEIndex, *mrTextForwarder);
684     return aIndex.GetIndex();
685 }
686 
687 sal_uInt16 SvxAccessibleTextAdapter::CalcEditEngineIndex( sal_uInt32 nPara, sal_Int32 nLogicalIndex )
688 {
689     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
690 
691     SvxAccessibleTextIndex aIndex;
692     aIndex.SetIndex(nPara, nLogicalIndex, *mrTextForwarder);
693     return aIndex.GetEEIndex();
694 }
695 
696 
697 
698 sal_Bool SvxAccessibleTextAdapter::IsValid() const
699 {
700     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
701 
702     if( mrTextForwarder )
703         return mrTextForwarder->IsValid();
704     else
705         return sal_False;
706 }
707 
708 LanguageType SvxAccessibleTextAdapter::GetLanguage( sal_uInt32 nPara, sal_uInt16 nPos ) const
709 {
710     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
711 
712     SvxAccessibleTextIndex aIndex;
713 
714     aIndex.SetIndex( nPara, nPos, *this );
715 
716     return mrTextForwarder->GetLanguage( nPara, aIndex.GetEEIndex() );
717 }
718 
719 sal_uInt16 SvxAccessibleTextAdapter::GetFieldCount( sal_uInt32 nPara ) const
720 {
721     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
722 
723     return mrTextForwarder->GetFieldCount( nPara );
724 }
725 
726 EFieldInfo SvxAccessibleTextAdapter::GetFieldInfo( sal_uInt32 nPara, sal_uInt16 nField ) const
727 {
728     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
729 
730     return mrTextForwarder->GetFieldInfo( nPara, nField );
731 }
732 
733 EBulletInfo SvxAccessibleTextAdapter::GetBulletInfo( sal_uInt32 nPara ) const
734 {
735     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
736 
737     return mrTextForwarder->GetBulletInfo( nPara );
738 }
739 void	SvxAccessibleTextAdapter::SetUpdateModeForAcc( sal_Bool bUp)
740 {
741 	return mrTextForwarder->SetUpdateModeForAcc( bUp );
742 }
743 sal_Bool	SvxAccessibleTextAdapter::GetUpdateModeForAcc( ) const
744 {
745 	return mrTextForwarder->GetUpdateModeForAcc( );
746 }
747 Rectangle SvxAccessibleTextAdapter::GetCharBounds( sal_uInt32 nPara, sal_uInt16 nIndex ) const
748 {
749     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
750 
751     SvxAccessibleTextIndex aIndex;
752     aIndex.SetIndex( nPara, nIndex, *this );
753 
754     // preset if anything goes wrong below
755     // n-th char in GetParagraphIndex's paragraph
756     Rectangle aRect = mrTextForwarder->GetCharBounds( nPara, static_cast< sal_uInt16 >( aIndex.GetEEIndex() ) );
757 
758     if( aIndex.InBullet() )
759     {
760         EBulletInfo aBulletInfo = GetBulletInfo( nPara );
761 
762         OutputDevice* pOutDev = GetRefDevice();
763 
764         DBG_ASSERT(pOutDev!=NULL, "SvxAccessibleTextAdapter::GetCharBounds: No ref device");
765 
766         // preset if anything goes wrong below
767         aRect = aBulletInfo.aBounds; // better than nothing
768         if( pOutDev )
769         {
770             AccessibleStringWrap aStringWrap( *pOutDev, aBulletInfo.aFont, aBulletInfo.aText );
771 
772             if( aStringWrap.GetCharacterBounds( aIndex.GetBulletOffset(), aRect ) )
773                 aRect.Move( aBulletInfo.aBounds.Left(), aBulletInfo.aBounds.Top() );
774         }
775     }
776     else
777     {
778         // handle field content manually
779         if( aIndex.InField() )
780         {
781             OutputDevice* pOutDev = GetRefDevice();
782 
783             DBG_ASSERT(pOutDev!=NULL, "SvxAccessibleTextAdapter::GetCharBounds: No ref device");
784 
785             if( pOutDev )
786             {
787                 ESelection aSel = MakeEESelection( aIndex );
788 
789                 SvxFont aFont = EditEngine::CreateSvxFontFromItemSet( mrTextForwarder->GetAttribs( aSel ) );
790                 AccessibleStringWrap aStringWrap( *pOutDev,
791                                                   aFont,
792                                                   mrTextForwarder->GetText( aSel ) );
793 
794                 Rectangle aStartRect = mrTextForwarder->GetCharBounds( nPara, static_cast< sal_uInt16 >( aIndex.GetEEIndex() ) );
795 
796                 if( !aStringWrap.GetCharacterBounds( aIndex.GetFieldOffset(), aRect ) )
797                     aRect = aStartRect;
798                 else
799                     aRect.Move( aStartRect.Left(), aStartRect.Top() );
800             }
801         }
802     }
803 
804     return aRect;
805 }
806 
807 Rectangle SvxAccessibleTextAdapter::GetParaBounds( sal_uInt32 nPara ) const
808 {
809     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
810 
811     EBulletInfo aBulletInfo = GetBulletInfo( nPara );
812 
813     if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
814         aBulletInfo.bVisible &&
815         aBulletInfo.nType != SVX_NUM_BITMAP )
816     {
817         // include bullet in para bounding box
818         Rectangle aRect( mrTextForwarder->GetParaBounds( nPara ) );
819 
820         aRect.Union( aBulletInfo.aBounds );
821 
822         return aRect;
823     }
824 
825     return mrTextForwarder->GetParaBounds( nPara );
826 }
827 
828 MapMode SvxAccessibleTextAdapter::GetMapMode() const
829 {
830     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
831 
832     return mrTextForwarder->GetMapMode();
833 }
834 
835 OutputDevice* SvxAccessibleTextAdapter::GetRefDevice() const
836 {
837     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
838 
839     return mrTextForwarder->GetRefDevice();
840 }
841 
842 sal_Bool SvxAccessibleTextAdapter::GetIndexAtPoint( const Point& rPoint, sal_uInt32& nPara, sal_uInt16& nIndex ) const
843 {
844     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
845 
846     if( !mrTextForwarder->GetIndexAtPoint( rPoint, nPara, nIndex ) )
847         return sal_False;
848 
849     SvxAccessibleTextIndex aIndex;
850     aIndex.SetEEIndex(nPara, nIndex, *this);
851 
852     DBG_ASSERT(aIndex.GetIndex() >= 0 && aIndex.GetIndex() <= USHRT_MAX,
853                "SvxAccessibleTextIndex::SetIndex: index value overflow");
854 
855     nIndex = static_cast< sal_uInt16 > (aIndex.GetIndex());
856 
857     EBulletInfo aBulletInfo = GetBulletInfo( nPara );
858 
859     // any text bullets?
860     if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
861         aBulletInfo.bVisible &&
862         aBulletInfo.nType != SVX_NUM_BITMAP )
863     {
864         if( aBulletInfo.aBounds.IsInside( rPoint) )
865         {
866             OutputDevice* pOutDev = GetRefDevice();
867 
868             DBG_ASSERT(pOutDev!=NULL, "SvxAccessibleTextAdapter::GetIndexAtPoint: No ref device");
869 
870             if( !pOutDev )
871                 return sal_False;
872 
873             AccessibleStringWrap aStringWrap( *pOutDev, aBulletInfo.aFont, aBulletInfo.aText );
874 
875             Point aPoint = rPoint;
876             aPoint.Move( -aBulletInfo.aBounds.Left(), -aBulletInfo.aBounds.Top() );
877 
878             DBG_ASSERT(aStringWrap.GetIndexAtPoint( aPoint ) >= 0 &&
879                        aStringWrap.GetIndexAtPoint( aPoint ) <= USHRT_MAX,
880                        "SvxAccessibleTextIndex::SetIndex: index value overflow");
881 
882             nIndex = static_cast< sal_uInt16 > (aStringWrap.GetIndexAtPoint( aPoint ));
883             return sal_True;
884         }
885     }
886 
887     if( aIndex.InField() )
888     {
889         OutputDevice* pOutDev = GetRefDevice();
890 
891         DBG_ASSERT(pOutDev!=NULL, "SvxAccessibleTextAdapter::GetIndexAtPoint: No ref device");
892 
893         if( !pOutDev )
894             return sal_False;
895 
896         ESelection aSelection = MakeEESelection( aIndex );
897         SvxFont aFont = EditEngine::CreateSvxFontFromItemSet( mrTextForwarder->GetAttribs( aSelection ) );
898         AccessibleStringWrap aStringWrap( *pOutDev,
899                                           aFont,
900                                           mrTextForwarder->GetText( aSelection ) );
901 
902         Rectangle aRect = mrTextForwarder->GetCharBounds( nPara, aIndex.GetEEIndex() );
903         Point aPoint = rPoint;
904         aPoint.Move( -aRect.Left(), -aRect.Top() );
905 
906         DBG_ASSERT(aIndex.GetIndex() + aStringWrap.GetIndexAtPoint( rPoint ) >= 0 &&
907                    aIndex.GetIndex() + aStringWrap.GetIndexAtPoint( rPoint ) <= USHRT_MAX,
908                    "SvxAccessibleTextIndex::SetIndex: index value overflow");
909 
910         nIndex = static_cast< sal_uInt16 >(aIndex.GetIndex() + aStringWrap.GetIndexAtPoint( aPoint ));
911         return sal_True;
912     }
913 
914     return sal_True;
915 }
916 
917 sal_Bool SvxAccessibleTextAdapter::GetWordIndices( sal_uInt32 nPara, sal_uInt16 nIndex, sal_uInt16& nStart, sal_uInt16& nEnd ) const
918 {
919     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
920 
921     SvxAccessibleTextIndex aIndex;
922     aIndex.SetIndex(nPara, nIndex, *this);
923     nIndex = aIndex.GetEEIndex();
924 
925     if( aIndex.InBullet() )
926     {
927         DBG_ASSERT(aIndex.GetBulletLen() >= 0 &&
928                    aIndex.GetBulletLen() <= USHRT_MAX,
929                    "SvxAccessibleTextIndex::SetIndex: index value overflow");
930 
931         // always treat bullet as separate word
932         nStart = 0;
933         nEnd = static_cast< sal_uInt16 > (aIndex.GetBulletLen());
934 
935         return sal_True;
936     }
937 
938     if( aIndex.InField() )
939     {
940         DBG_ASSERT(aIndex.GetIndex() - aIndex.GetFieldOffset() >= 0 &&
941                    aIndex.GetIndex() - aIndex.GetFieldOffset() <= USHRT_MAX &&
942                    nStart + aIndex.GetFieldLen() >= 0 &&
943                    nStart + aIndex.GetFieldLen() <= USHRT_MAX,
944                    "SvxAccessibleTextIndex::SetIndex: index value overflow");
945 
946         // always treat field as separate word
947         // TODO: to circumvent this, _we_ would have to do the break iterator stuff!
948         nStart = static_cast< sal_uInt16 > (aIndex.GetIndex() - aIndex.GetFieldOffset());
949         nEnd = static_cast< sal_uInt16 > (nStart + aIndex.GetFieldLen());
950 
951         return sal_True;
952     }
953 
954     if( !mrTextForwarder->GetWordIndices( nPara, nIndex, nStart, nEnd ) )
955         return sal_False;
956 
957     aIndex.SetEEIndex( nPara, nStart, *this );
958     DBG_ASSERT(aIndex.GetIndex() >= 0 &&
959                aIndex.GetIndex() <= USHRT_MAX,
960                "SvxAccessibleTextIndex::SetIndex: index value overflow");
961     nStart = static_cast< sal_uInt16 > (aIndex.GetIndex());
962 
963     aIndex.SetEEIndex( nPara, nEnd, *this );
964     DBG_ASSERT(aIndex.GetIndex() >= 0 &&
965                aIndex.GetIndex() <= USHRT_MAX,
966                "SvxAccessibleTextIndex::SetIndex: index value overflow");
967     nEnd = static_cast< sal_uInt16 > (aIndex.GetIndex());
968 
969     return sal_True;
970 }
971 sal_Bool SvxAccessibleTextAdapter::GetAttributeRun( sal_uInt16& nStartIndex, sal_uInt16& nEndIndex, sal_uInt32 nPara, sal_uInt16 nIndex, sal_Bool /* bInCell */) const
972 {
973     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
974 
975     SvxAccessibleTextIndex aIndex;
976     aIndex.SetIndex(nPara, nIndex, *this);
977     nIndex = aIndex.GetEEIndex();
978 
979     if( aIndex.InBullet() )
980     {
981         DBG_ASSERT(aIndex.GetBulletLen() >= 0 &&
982                    aIndex.GetBulletLen() <= USHRT_MAX,
983                    "SvxAccessibleTextIndex::SetIndex: index value overflow");
984 
985         // always treat bullet as distinct attribute
986         nStartIndex = 0;
987         nEndIndex = static_cast< sal_uInt16 > (aIndex.GetBulletLen());
988 
989         return sal_True;
990     }
991 
992     if( aIndex.InField() )
993     {
994         DBG_ASSERT(aIndex.GetIndex() - aIndex.GetFieldOffset() >= 0 &&
995                    aIndex.GetIndex() - aIndex.GetFieldOffset() <= USHRT_MAX,
996                    "SvxAccessibleTextIndex::SetIndex: index value overflow");
997 
998         // always treat field as distinct attribute
999         nStartIndex = static_cast< sal_uInt16 > (aIndex.GetIndex() - aIndex.GetFieldOffset());
1000         nEndIndex = static_cast< sal_uInt16 > (nStartIndex + aIndex.GetFieldLen());
1001 
1002         return sal_True;
1003     }
1004 
1005     if( !mrTextForwarder->GetAttributeRun( nStartIndex, nEndIndex, nPara, nIndex ) )
1006         return sal_False;
1007 
1008     aIndex.SetEEIndex( nPara, nStartIndex, *this );
1009     DBG_ASSERT(aIndex.GetIndex() >= 0 &&
1010                aIndex.GetIndex() <= USHRT_MAX,
1011                "SvxAccessibleTextIndex::SetIndex: index value overflow");
1012     nStartIndex = static_cast< sal_uInt16 > (aIndex.GetIndex());
1013 
1014     aIndex.SetEEIndex( nPara, nEndIndex, *this );
1015     DBG_ASSERT(aIndex.GetIndex() >= 0 &&
1016                aIndex.GetIndex() <= USHRT_MAX,
1017                "SvxAccessibleTextIndex::SetIndex: index value overflow");
1018     nEndIndex = static_cast< sal_uInt16 > (aIndex.GetIndex());
1019 
1020     return sal_True;
1021 }
1022 
1023 sal_uInt16 SvxAccessibleTextAdapter::GetLineCount( sal_uInt32 nPara ) const
1024 {
1025     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1026 
1027     return mrTextForwarder->GetLineCount( nPara );
1028 }
1029 
1030 sal_uInt16 SvxAccessibleTextAdapter::GetLineLen( sal_uInt32 nPara, sal_uInt16 nLine ) const
1031 {
1032     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1033 
1034     SvxAccessibleTextIndex aStartIndex;
1035     SvxAccessibleTextIndex aEndIndex;
1036     sal_uInt16 nCurrLine;
1037     sal_uInt16 nCurrIndex, nLastIndex;
1038     for( nCurrLine=0, nCurrIndex=0, nLastIndex=0; nCurrLine<=nLine; ++nCurrLine )
1039     {
1040         nLastIndex = nCurrIndex;
1041         nCurrIndex =
1042             nCurrIndex + mrTextForwarder->GetLineLen( nPara, nCurrLine );
1043     }
1044 
1045     aEndIndex.SetEEIndex( nPara, nCurrIndex, *this );
1046     if( nLine > 0 )
1047     {
1048         aStartIndex.SetEEIndex( nPara, nLastIndex, *this );
1049 
1050         return static_cast< sal_uInt16 >(aEndIndex.GetIndex() - aStartIndex.GetIndex());
1051     }
1052     else
1053         return static_cast< sal_uInt16 >(aEndIndex.GetIndex());
1054 }
1055 
1056 void SvxAccessibleTextAdapter::GetLineBoundaries( /*out*/sal_uInt16 &rStart, /*out*/sal_uInt16 &rEnd, sal_uInt32 nParagraph, sal_uInt16 nLine ) const
1057 {
1058     mrTextForwarder->GetLineBoundaries( rStart, rEnd, nParagraph, nLine );
1059 }
1060 
1061 sal_uInt16 SvxAccessibleTextAdapter::GetLineNumberAtIndex( sal_uInt32 nPara, sal_uInt16 nIndex ) const
1062 {
1063     return mrTextForwarder->GetLineNumberAtIndex( nPara, nIndex );
1064 }
1065 
1066 sal_Bool SvxAccessibleTextAdapter::Delete( const ESelection& rSel )
1067 {
1068     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1069 
1070     SvxAccessibleTextIndex aStartIndex;
1071     SvxAccessibleTextIndex aEndIndex;
1072 
1073     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
1074     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
1075 
1076     return mrTextForwarder->Delete( MakeEESelection(aStartIndex, aEndIndex ) );
1077 }
1078 
1079 sal_Bool SvxAccessibleTextAdapter::InsertText( const String& rStr, const ESelection& rSel )
1080 {
1081     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1082 
1083     SvxAccessibleTextIndex aStartIndex;
1084     SvxAccessibleTextIndex aEndIndex;
1085 
1086     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
1087     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
1088 
1089     return mrTextForwarder->InsertText( rStr, MakeEESelection(aStartIndex, aEndIndex) );
1090 }
1091 
1092 sal_Bool SvxAccessibleTextAdapter::QuickFormatDoc( sal_Bool bFull )
1093 {
1094     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1095 
1096     return mrTextForwarder->QuickFormatDoc( bFull );
1097 }
1098 
1099 sal_Int16 SvxAccessibleTextAdapter::GetDepth( sal_uInt32 nPara ) const
1100 {
1101     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1102 
1103     return mrTextForwarder->GetDepth( nPara );
1104 }
1105 
1106 sal_Bool SvxAccessibleTextAdapter::SetDepth( sal_uInt32 nPara, sal_Int16 nNewDepth )
1107 {
1108     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1109 
1110     return mrTextForwarder->SetDepth( nPara, nNewDepth );
1111 }
1112 
1113 void SvxAccessibleTextAdapter::SetForwarder( SvxTextForwarder& rForwarder )
1114 {
1115     mrTextForwarder = &rForwarder;
1116 }
1117 
1118 sal_Bool SvxAccessibleTextAdapter::HaveImageBullet( sal_uInt32 nPara ) const
1119 {
1120     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1121 
1122     EBulletInfo aBulletInfo = GetBulletInfo( nPara );
1123 
1124     if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
1125         aBulletInfo.bVisible &&
1126         aBulletInfo.nType == SVX_NUM_BITMAP )
1127     {
1128         return sal_True;
1129     }
1130     else
1131     {
1132         return sal_False;
1133     }
1134 }
1135 
1136 sal_Bool SvxAccessibleTextAdapter::HaveTextBullet( sal_uInt32 nPara ) const
1137 {
1138     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1139 
1140     EBulletInfo aBulletInfo = GetBulletInfo( nPara );
1141 
1142     if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
1143         aBulletInfo.bVisible &&
1144         aBulletInfo.nType != SVX_NUM_BITMAP )
1145     {
1146         return sal_True;
1147     }
1148     else
1149     {
1150         return sal_False;
1151     }
1152 }
1153 
1154 sal_Bool SvxAccessibleTextAdapter::IsEditable( const ESelection& rSel )
1155 {
1156     DBG_ASSERT(mrTextForwarder, "SvxAccessibleTextAdapter: no forwarder");
1157 
1158     SvxAccessibleTextIndex aStartIndex;
1159     SvxAccessibleTextIndex aEndIndex;
1160 
1161     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *this );
1162     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *this );
1163 
1164     // normalize selection
1165     if( rSel.nStartPara > rSel.nEndPara ||
1166         (rSel.nStartPara == rSel.nEndPara && rSel.nStartPos > rSel.nEndPos) )
1167     {
1168         ::std::swap( aStartIndex, aEndIndex );
1169     }
1170 
1171     return aStartIndex.IsEditableRange( aEndIndex );
1172 }
1173 
1174 const SfxItemSet * SvxAccessibleTextAdapter::GetEmptyItemSetPtr()
1175 {
1176     DBG_ERROR( "not implemented" );
1177     return 0;
1178 }
1179 
1180 void SvxAccessibleTextAdapter::AppendParagraph()
1181 {
1182     DBG_ERROR( "not implemented" );
1183 }
1184 
1185 xub_StrLen SvxAccessibleTextAdapter::AppendTextPortion( sal_uInt32, const String &, const SfxItemSet & )
1186 {
1187     DBG_ERROR( "not implemented" );
1188     return 0;
1189 }
1190 void        SvxAccessibleTextAdapter::CopyText(const SvxTextForwarder&)
1191 {
1192     DBG_ERROR( "not implemented" );
1193 }
1194 
1195 
1196 
1197 //---------------------------------------------------------------------------------------
1198 
1199 SvxAccessibleTextEditViewAdapter::SvxAccessibleTextEditViewAdapter()
1200 {
1201 }
1202 
1203 SvxAccessibleTextEditViewAdapter::~SvxAccessibleTextEditViewAdapter()
1204 {
1205 }
1206 
1207 sal_Bool SvxAccessibleTextEditViewAdapter::IsValid() const
1208 {
1209     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1210 
1211     if( mrViewForwarder )
1212         return mrViewForwarder->IsValid();
1213     else
1214         return sal_False;
1215 }
1216 
1217 Rectangle SvxAccessibleTextEditViewAdapter::GetVisArea() const
1218 {
1219     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1220 
1221     return mrViewForwarder->GetVisArea();
1222 }
1223 
1224 Point SvxAccessibleTextEditViewAdapter::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
1225 {
1226     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1227 
1228     return mrViewForwarder->LogicToPixel(rPoint, rMapMode);
1229 }
1230 
1231 Point SvxAccessibleTextEditViewAdapter::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
1232 {
1233     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1234 
1235     return mrViewForwarder->PixelToLogic(rPoint, rMapMode);
1236 }
1237 
1238 sal_Bool SvxAccessibleTextEditViewAdapter::GetSelection( ESelection& rSel ) const
1239 {
1240     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1241 
1242     ESelection aSelection;
1243 
1244     if( !mrViewForwarder->GetSelection( aSelection ) )
1245         return sal_False;
1246 
1247     SvxAccessibleTextIndex aStartIndex;
1248     SvxAccessibleTextIndex aEndIndex;
1249 
1250     aStartIndex.SetEEIndex( aSelection.nStartPara, aSelection.nStartPos, *mrTextForwarder );
1251     aEndIndex.SetEEIndex( aSelection.nEndPara, aSelection.nEndPos, *mrTextForwarder );
1252 
1253     DBG_ASSERT(aStartIndex.GetIndex() >= 0 && aStartIndex.GetIndex() <= USHRT_MAX &&
1254                aEndIndex.GetIndex() >= 0 && aEndIndex.GetIndex() <= USHRT_MAX,
1255                "SvxAccessibleTextEditViewAdapter::GetSelection: index value overflow");
1256 
1257     rSel = ESelection( aStartIndex.GetParagraph(), static_cast< sal_uInt16 > (aStartIndex.GetIndex()),
1258                        aEndIndex.GetParagraph(), static_cast< sal_uInt16 > (aEndIndex.GetIndex()) );
1259 
1260     return sal_True;
1261 }
1262 
1263 sal_Bool SvxAccessibleTextEditViewAdapter::SetSelection( const ESelection& rSel )
1264 {
1265     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1266 
1267     SvxAccessibleTextIndex aStartIndex;
1268     SvxAccessibleTextIndex aEndIndex;
1269 
1270     aStartIndex.SetIndex( rSel.nStartPara, rSel.nStartPos, *mrTextForwarder );
1271     aEndIndex.SetIndex( rSel.nEndPara, rSel.nEndPos, *mrTextForwarder );
1272 
1273     return mrViewForwarder->SetSelection( MakeEESelection(aStartIndex, aEndIndex) );
1274 }
1275 
1276 sal_Bool SvxAccessibleTextEditViewAdapter::Copy()
1277 {
1278     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1279 
1280     return mrViewForwarder->Copy();
1281 }
1282 
1283 sal_Bool SvxAccessibleTextEditViewAdapter::Cut()
1284 {
1285     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1286 
1287     return mrViewForwarder->Cut();
1288 }
1289 
1290 sal_Bool SvxAccessibleTextEditViewAdapter::Paste()
1291 {
1292     DBG_ASSERT(mrViewForwarder, "SvxAccessibleTextEditViewAdapter: no forwarder");
1293 
1294     return mrViewForwarder->Paste();
1295 }
1296 
1297 void SvxAccessibleTextEditViewAdapter::SetForwarder( SvxEditViewForwarder& 		rForwarder,
1298                                                      SvxAccessibleTextAdapter&	rTextForwarder )
1299 {
1300     mrViewForwarder = &rForwarder;
1301     mrTextForwarder = &rTextForwarder;
1302 }
1303 
1304