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 <boost/bind.hpp>
37 #include <vos/mutex.hxx>
38 #include <vcl/window.hxx>
39 #include <vcl/svapp.hxx>
40 #include <comphelper/sequenceasvector.hxx>
41 #include <com/sun/star/uno/Any.hxx>
42 #include <com/sun/star/uno/Reference.hxx>
43 #include <com/sun/star/awt/Point.hpp>
44 #include <com/sun/star/awt/Rectangle.hpp>
45 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
46 
47 //------------------------------------------------------------------------
48 //
49 // Project-local header
50 //
51 //------------------------------------------------------------------------
52 
53 #include <editeng/editdata.hxx>
54 #include <editeng/unopracc.hxx>
55 #include "editeng/unoedprx.hxx"
56 #include <editeng/AccessibleStaticTextBase.hxx>
57 #include "editeng/AccessibleEditableTextPara.hxx"
58 
59 
60 using namespace ::com::sun::star;
61 using namespace ::com::sun::star::accessibility;
62 
63 /* TODO:
64    =====
65 
66    - separate adapter functionality from AccessibleStaticText class
67 
68    - refactor common loops into templates, using mem_fun
69 
70  */
71 
72 namespace accessibility
73 {
74     typedef ::comphelper::SequenceAsVector< beans::PropertyValue > PropertyValueVector;
75 
76     class PropertyValueEqualFunctor : public ::std::binary_function< beans::PropertyValue, beans::PropertyValue, bool >
77     {
78     public:
PropertyValueEqualFunctor()79         PropertyValueEqualFunctor()
80         {}
operator ()(const beans::PropertyValue & lhs,const beans::PropertyValue & rhs) const81         bool operator() ( const beans::PropertyValue& lhs, const beans::PropertyValue& rhs ) const
82         {
83             return ( lhs.Name == rhs.Name && lhs.Value == rhs.Value );
84         }
85     };
86 sal_Unicode cNewLine(0x0a);
87 	//------------------------------------------------------------------------
88 	//
89 	// Static Helper
90 	//
91 	//------------------------------------------------------------------------
MakeSelection(sal_Int32 nStartPara,sal_Int32 nStartIndex,sal_Int32 nEndPara,sal_Int32 nEndIndex)92     ESelection MakeSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
93                               sal_Int32 nEndPara, sal_Int32 nEndIndex )
94     {
95         DBG_ASSERT(nStartPara >= 0 && nStartPara <= USHRT_MAX &&
96                    nStartIndex >= 0 && nStartIndex <= USHRT_MAX &&
97                    nEndPara >= 0 && nEndPara <= USHRT_MAX &&
98                    nEndIndex >= 0 && nEndIndex <= USHRT_MAX ,
99                    "AccessibleStaticTextBase_Impl::MakeSelection: index value overflow");
100 
101         return ESelection( nStartPara, static_cast< sal_uInt16 >(nStartIndex),
102                            nEndPara, static_cast< sal_uInt16 >(nEndIndex) );
103     }
104 
105 	//------------------------------------------------------------------------
106 	//
107 	// AccessibleStaticTextBase_Impl declaration
108 	//
109 	//------------------------------------------------------------------------
110 
111     DBG_NAME( AccessibleStaticTextBase_Impl );
112 
113     /** AccessibleStaticTextBase_Impl
114 
115     	This class implements the AccessibleStaticTextBase
116     	functionality, mainly by forwarding the calls to an aggregated
117     	AccessibleEditableTextPara. As this is a therefore non-trivial
118     	adapter, factoring out the common functionality from
119     	AccessibleEditableTextPara might be a profitable future task.
120      */
121     class AccessibleStaticTextBase_Impl
122     {
123 		friend class AccessibleStaticTextBase;
124     public:
125 
126         // receive pointer to our frontend class and view window
127         AccessibleStaticTextBase_Impl();
128         ~AccessibleStaticTextBase_Impl();
129 
GetEditSource() const130         SvxEditSourceAdapter& GetEditSource() const SAL_THROW((uno::RuntimeException))
131         {
132             DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
133 
134             return maEditSource;
135         }
136         void SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) SAL_THROW((uno::RuntimeException));
137 
SetEventSource(const uno::Reference<XAccessible> & rInterface)138         void SetEventSource( const uno::Reference< XAccessible >& rInterface )
139         {
140             DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
141 
142             mxThis = rInterface;
143         }
GetEventSource() const144         uno::Reference< XAccessible > GetEventSource() const
145         {
146             DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
147 
148             return mxThis;
149         }
150 
151         void SetOffset( const Point& );
GetOffset() const152         Point GetOffset() const
153         {
154             DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
155 
156             ::osl::MutexGuard aGuard( maMutex ); Point aPoint( maOffset );
157             return aPoint;
158         }
159 
160         void UpdateChildren();
161         void Dispose();
162 
163 #ifdef DBG_UTIL
164         void CheckInvariants() const;
165 #endif
166 
167         AccessibleEditableTextPara& GetParagraph( sal_Int32 nPara ) const;
168         sal_Int32 					GetParagraphCount() const;
169         sal_Int32                   GetParagraphIndex() const;
170         sal_Int32                   GetLineCount( sal_Int32 nParagraph ) const;
171 
Index2Internal(sal_Int32 nFlatIndex) const172         EPosition                   Index2Internal( sal_Int32 nFlatIndex ) const
173         {
174             DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
175 
176             return ImpCalcInternal( nFlatIndex, false );
177         }
178 
Range2Internal(sal_Int32 nFlatIndex) const179         EPosition                   Range2Internal( sal_Int32 nFlatIndex ) const
180         {
181             DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
182 
183             return ImpCalcInternal( nFlatIndex, true );
184         }
185 
186         sal_Int32					Internal2Index( EPosition nEEIndex ) const;
187 
188         void						CorrectTextSegment( TextSegment&	aTextSegment,
189                                                         int				nPara	) const;
190 
191         sal_Bool					SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
192                                                   sal_Int32 nEndPara, sal_Int32 nEndIndex );
193         sal_Bool					CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
194                                               sal_Int32 nEndPara, sal_Int32 nEndIndex );
195 
196         Rectangle                   GetParagraphBoundingBox() const;
197 		sal_Bool					RemoveLineBreakCount( sal_Int32& rIndex );
198 
199     private:
200 
201         EPosition 					ImpCalcInternal( sal_Int32 nFlatIndex, bool bExclusive ) const;
202 
203         // our frontend class (the one implementing the actual
204         // interface). That's not necessarily the one containing the impl
205         // pointer
206         uno::Reference< XAccessible > mxThis;
207 
208         // implements our functionality, we're just an adapter (guarded by solar mutex)
209         mutable AccessibleEditableTextPara* mpTextParagraph;
210 
211         uno::Reference< XAccessible > mxParagraph;
212 
213         // a wrapper for the text forwarders (guarded by solar mutex)
214         mutable SvxEditSourceAdapter maEditSource;
215 
216         // guard for maOffset
217         mutable ::osl::Mutex maMutex;
218 
219         /// our current offset to the containing shape/cell (guarded by maMutex)
220         Point maOffset;
221 
222     };
223 
224 	//------------------------------------------------------------------------
225 	//
226 	// AccessibleStaticTextBase_Impl implementation
227 	//
228 	//------------------------------------------------------------------------
229 
AccessibleStaticTextBase_Impl()230     AccessibleStaticTextBase_Impl::AccessibleStaticTextBase_Impl() :
231         mxThis( NULL ),
232         mpTextParagraph( new AccessibleEditableTextPara(NULL) ),
233         mxParagraph( mpTextParagraph ),
234         maEditSource(),
235         maMutex(),
236         maOffset(0,0)
237     {
238         DBG_CTOR( AccessibleStaticTextBase_Impl, NULL );
239 
240         // TODO: this is still somewhat of a hack, all the more since
241         // now the maTextParagraph has an empty parent reference set
242     }
243 
~AccessibleStaticTextBase_Impl()244     AccessibleStaticTextBase_Impl::~AccessibleStaticTextBase_Impl()
245     {
246         DBG_DTOR( AccessibleStaticTextBase_Impl, NULL );
247     }
248 
SetEditSource(::std::auto_ptr<SvxEditSource> pEditSource)249     void AccessibleStaticTextBase_Impl::SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) SAL_THROW((uno::RuntimeException))
250     {
251         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
252 
253         maEditSource.SetEditSource( pEditSource );
254         if( mpTextParagraph )
255             mpTextParagraph->SetEditSource( &maEditSource );
256     }
257 
SetOffset(const Point & rPoint)258     void AccessibleStaticTextBase_Impl::SetOffset( const Point& rPoint )
259     {
260         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
261 
262         // guard against non-atomic access to maOffset data structure
263         {
264             ::osl::MutexGuard aGuard( maMutex );
265             maOffset = rPoint;
266         }
267 
268         if( mpTextParagraph )
269             mpTextParagraph->SetEEOffset( rPoint );
270 
271         // in all cases, check visibility afterwards.
272         UpdateChildren();
273     }
274 
UpdateChildren()275     void AccessibleStaticTextBase_Impl::UpdateChildren()
276     {
277         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
278 
279         // currently no children
280     }
281 
Dispose()282     void AccessibleStaticTextBase_Impl::Dispose()
283     {
284         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
285 
286         // we're the owner of the paragraph, so destroy it, too
287         if( mpTextParagraph )
288             mpTextParagraph->Dispose();
289 
290         // drop references
291         mxParagraph = NULL;
292         mxThis = NULL;
293         mpTextParagraph = NULL;
294     }
295 
296 #ifdef DBG_UTIL
CheckInvariants() const297     void AccessibleStaticTextBase_Impl::CheckInvariants() const
298     {
299         // TODO
300     }
301 #endif
302 
GetParagraph(sal_Int32 nPara) const303     AccessibleEditableTextPara& AccessibleStaticTextBase_Impl::GetParagraph( sal_Int32 nPara ) const
304     {
305         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
306 
307         if( !mpTextParagraph )
308             throw lang::DisposedException (
309                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("object has been already disposed")), mxThis );
310 
311         // TODO: Have a different method on AccessibleEditableTextPara
312         // that does not care about state changes
313         mpTextParagraph->SetParagraphIndex( nPara );
314 
315         return *mpTextParagraph;
316     }
317 
GetParagraphCount() const318     sal_Int32 AccessibleStaticTextBase_Impl::GetParagraphCount() const
319     {
320         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
321 
322         if( !mpTextParagraph )
323             return 0;
324         else
325             return mpTextParagraph->GetTextForwarder().GetParagraphCount();
326     }
327 
GetParagraphIndex() const328     sal_Int32 AccessibleStaticTextBase_Impl::GetParagraphIndex() const
329     {
330         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
331 
332         sal_Int32 nIndex = -1;
333         if( mpTextParagraph )
334             nIndex = mpTextParagraph->GetParagraphIndex();
335         return nIndex;
336     }
337 
GetLineCount(sal_Int32 nParagraph) const338     sal_Int32 AccessibleStaticTextBase_Impl::GetLineCount( sal_Int32 nParagraph ) const
339     {
340         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
341 
342         sal_Int32 nIndex = 0;
343         if( mpTextParagraph )
344             nIndex = mpTextParagraph->GetTextForwarder().GetLineCount( nParagraph );
345         return nIndex;
346     }
347 
Internal2Index(EPosition nEEIndex) const348     sal_Int32 AccessibleStaticTextBase_Impl::Internal2Index( EPosition nEEIndex ) const
349     {
350         sal_Int32 aRes(0);
351         int i;
352         for(i=0; i<nEEIndex.nPara; ++i)
353             aRes += GetParagraph(i).getCharacterCount();
354 
355         return aRes + nEEIndex.nIndex;
356     }
357 
CorrectTextSegment(TextSegment & aTextSegment,int nPara) const358     void AccessibleStaticTextBase_Impl::CorrectTextSegment( TextSegment&	aTextSegment,
359                                                             int				nPara	) const
360     {
361         // Keep 'invalid' values at the TextSegment
362         if( aTextSegment.SegmentStart != -1 &&
363             aTextSegment.SegmentEnd != -1 )
364         {
365             // #112814# Correct TextSegment by paragraph offset
366             sal_Int32 nOffset(0);
367             int i;
368             for(i=0; i<nPara; ++i)
369                 nOffset += GetParagraph(i).getCharacterCount();
370 
371             aTextSegment.SegmentStart += nOffset;
372             aTextSegment.SegmentEnd += nOffset;
373         }
374     }
375 
ImpCalcInternal(sal_Int32 nFlatIndex,bool bExclusive) const376     EPosition AccessibleStaticTextBase_Impl::ImpCalcInternal( sal_Int32 nFlatIndex, bool bExclusive ) const
377     {
378         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
379 
380         if( nFlatIndex < 0 )
381             throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds")),
382                                                   mxThis);
383         // gratuitously accepting larger indices here, AccessibleEditableTextPara will throw eventually
384 
385         sal_Int32 nCurrPara, nCurrIndex, nParas, nCurrCount;
386         for( nCurrPara=0, nParas=GetParagraphCount(), nCurrCount=0, nCurrIndex=0; nCurrPara<nParas; ++nCurrPara )
387         {
388             nCurrCount = GetParagraph( nCurrPara ).getCharacterCount();
389             nCurrIndex += nCurrCount;
390             if( nCurrIndex >= nFlatIndex )
391             {
392                 // check overflow
393                 DBG_ASSERT(nCurrPara >= 0 && nCurrPara <= USHRT_MAX &&
394                            nFlatIndex - nCurrIndex + nCurrCount >= 0 && nFlatIndex - nCurrIndex + nCurrCount <= USHRT_MAX ,
395                            "AccessibleStaticTextBase_Impl::Index2Internal: index value overflow");
396 
397                 return EPosition( nCurrPara, static_cast< sal_uInt16 >(nFlatIndex - nCurrIndex + nCurrCount) );
398             }
399         }
400 
401         // #102170# Allow one-past the end for ranges
402         if( bExclusive && nCurrIndex == nFlatIndex )
403         {
404             // check overflow
405             DBG_ASSERT(nCurrPara >= 0 && nCurrPara <= USHRT_MAX &&
406                        nFlatIndex - nCurrIndex + nCurrCount >= 0 && nFlatIndex - nCurrIndex + nCurrCount <= USHRT_MAX ,
407                        "AccessibleStaticTextBase_Impl::Index2Internal: index value overflow");
408 
409             return EPosition( nCurrPara-1, static_cast< sal_uInt16 >(nFlatIndex - nCurrIndex + nCurrCount) );
410         }
411 
412         // not found? Out of bounds
413         throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds")),
414                                               mxThis);
415     }
416 
SetSelection(sal_Int32 nStartPara,sal_Int32 nStartIndex,sal_Int32 nEndPara,sal_Int32 nEndIndex)417     sal_Bool AccessibleStaticTextBase_Impl::SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
418                                                           sal_Int32 nEndPara, sal_Int32 nEndIndex )
419     {
420         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
421 
422         if( !mpTextParagraph )
423             return sal_False;
424 
425         try
426         {
427             SvxEditViewForwarder& rCacheVF = mpTextParagraph->GetEditViewForwarder( sal_True );
428             return rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
429         }
430         catch( const uno::RuntimeException& )
431         {
432             return sal_False;
433         }
434     }
435 
CopyText(sal_Int32 nStartPara,sal_Int32 nStartIndex,sal_Int32 nEndPara,sal_Int32 nEndIndex)436     sal_Bool AccessibleStaticTextBase_Impl::CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
437                                                       sal_Int32 nEndPara, sal_Int32 nEndIndex )
438     {
439         DBG_CHKTHIS( AccessibleStaticTextBase_Impl, NULL );
440 
441         if( !mpTextParagraph )
442             return sal_False;
443 
444         try
445         {
446             SvxEditViewForwarder& rCacheVF = mpTextParagraph->GetEditViewForwarder( sal_True );
447             mpTextParagraph->GetTextForwarder();	// MUST be after GetEditViewForwarder(), see method docs
448             sal_Bool aRetVal;
449 
450             // save current selection
451             ESelection aOldSelection;
452 
453             rCacheVF.GetSelection( aOldSelection );
454             rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
455             aRetVal = rCacheVF.Copy();
456             rCacheVF.SetSelection( aOldSelection ); // restore
457 
458             return aRetVal;
459         }
460         catch( const uno::RuntimeException& )
461         {
462             return sal_False;
463         }
464     }
465 
GetParagraphBoundingBox() const466     Rectangle AccessibleStaticTextBase_Impl::GetParagraphBoundingBox() const
467     {
468         Rectangle aRect;
469         if( mpTextParagraph )
470         {
471             awt::Rectangle aAwtRect = mpTextParagraph->getBounds();
472             aRect = Rectangle( Point( aAwtRect.X, aAwtRect.Y ), Size( aAwtRect.Width, aAwtRect.Height ) );
473         }
474         else
475         {
476             aRect.SetEmpty();
477         }
478         return aRect;
479     }
480 	//the input argument is the index(including "\n" ) in the string.
481 	//the function will calculate the actual index(not including "\n") in the string.
482 	//and return true if the index is just at a "\n"
RemoveLineBreakCount(sal_Int32 & rIndex)483 	sal_Bool AccessibleStaticTextBase_Impl::RemoveLineBreakCount( sal_Int32& rIndex )
484 	{
485 		// get the total char number inside the cell.
486 		sal_Int32 i, nCount, nParas;
487         for( i=0, nCount=0, nParas=GetParagraphCount(); i<nParas; ++i )
488             nCount += GetParagraph(i).getCharacterCount();
489 		nCount = nCount + (nParas-1);
490 		if( nCount == 0 &&  rIndex == 0) return sal_False;
491 
492 
493 		sal_Int32 nCurrPara, nCurrCount;
494 		sal_Int32 nLineBreakPos = 0, nLineBreakCount = 0;
495 		sal_Int32 nParaCount = GetParagraphCount();
496 		for ( nCurrCount = 0, nCurrPara = 0; nCurrPara < nParaCount; nCurrPara++ )
497 		{
498 			nCurrCount += GetParagraph( nCurrPara ).getCharacterCount();
499 			nLineBreakPos = nCurrCount++;
500 			if ( rIndex == nLineBreakPos )
501 			{
502 				rIndex -= (++nLineBreakCount);//(++nLineBreakCount);
503 				if ( rIndex < 0)
504 				{
505 					rIndex = 0;
506 				}
507 				//if the index is at the last position of the last paragraph
508 				//there is no "\n" , so we should increase rIndex by 1 and return false.
509 				if ( (nCurrPara+1) == nParaCount )
510 				{
511 					rIndex++;
512 					return sal_False;
513 				}
514 				else
515 				{
516 					return sal_True;
517 				}
518 			}
519 			else if ( rIndex < nLineBreakPos )
520 			{
521 				rIndex -= nLineBreakCount;
522 				return sal_False;
523 			}
524 			else
525 			{
526 				nLineBreakCount++;
527 			}
528 		}
529 		return sal_False;
530 	}
531 	//------------------------------------------------------------------------
532 	//
533 	// AccessibleStaticTextBase implementation
534 	//
535 	//------------------------------------------------------------------------
536 
AccessibleStaticTextBase(::std::auto_ptr<SvxEditSource> pEditSource)537     AccessibleStaticTextBase::AccessibleStaticTextBase( ::std::auto_ptr< SvxEditSource > 		pEditSource ) :
538         mpImpl( new AccessibleStaticTextBase_Impl() )
539     {
540         ::vos::OGuard aGuard( Application::GetSolarMutex() );
541 
542         SetEditSource( pEditSource );
543     }
544 
~AccessibleStaticTextBase()545     AccessibleStaticTextBase::~AccessibleStaticTextBase()
546     {
547     }
548 
GetEditSource() const549     const SvxEditSource& AccessibleStaticTextBase::GetEditSource() const SAL_THROW((::com::sun::star::uno::RuntimeException))
550     {
551 #ifdef DBG_UTIL
552         mpImpl->CheckInvariants();
553 
554         const SvxEditSource& aEditSource = mpImpl->GetEditSource();
555 
556         mpImpl->CheckInvariants();
557 
558         return aEditSource;
559 #else
560         return mpImpl->GetEditSource();
561 #endif
562     }
563 
SetEditSource(::std::auto_ptr<SvxEditSource> pEditSource)564     void AccessibleStaticTextBase::SetEditSource( ::std::auto_ptr< SvxEditSource > pEditSource ) SAL_THROW((::com::sun::star::uno::RuntimeException))
565     {
566 #ifdef DBG_UTIL
567         // precondition: solar mutex locked
568         DBG_TESTSOLARMUTEX();
569 
570         mpImpl->CheckInvariants();
571 
572         mpImpl->SetEditSource( pEditSource );
573 
574         mpImpl->CheckInvariants();
575 #else
576         mpImpl->SetEditSource( pEditSource );
577 #endif
578     }
579 
SetEventSource(const uno::Reference<XAccessible> & rInterface)580     void AccessibleStaticTextBase::SetEventSource( const uno::Reference< XAccessible >& rInterface )
581     {
582 #ifdef DBG_UTIL
583         mpImpl->CheckInvariants();
584 #endif
585 
586         mpImpl->SetEventSource( rInterface );
587 
588 #ifdef DBG_UTIL
589         mpImpl->CheckInvariants();
590 #endif
591     }
592 
GetEventSource() const593     uno::Reference< XAccessible > AccessibleStaticTextBase::GetEventSource() const
594     {
595 #ifdef DBG_UTIL
596         mpImpl->CheckInvariants();
597 
598         uno::Reference< XAccessible > xRet( mpImpl->GetEventSource() );
599 
600         mpImpl->CheckInvariants();
601 
602         return xRet;
603 #else
604         return mpImpl->GetEventSource();
605 #endif
606     }
607 
SetOffset(const Point & rPoint)608     void AccessibleStaticTextBase::SetOffset( const Point& rPoint )
609     {
610 #ifdef DBG_UTIL
611         // precondition: solar mutex locked
612         DBG_TESTSOLARMUTEX();
613 
614         mpImpl->CheckInvariants();
615 
616         mpImpl->SetOffset( rPoint );
617 
618         mpImpl->CheckInvariants();
619 #else
620         mpImpl->SetOffset( rPoint );
621 #endif
622     }
623 
GetOffset() const624     Point AccessibleStaticTextBase::GetOffset() const
625     {
626 #ifdef DBG_UTIL
627         mpImpl->CheckInvariants();
628 
629         Point aPoint( mpImpl->GetOffset() );
630 
631         mpImpl->CheckInvariants();
632 
633         return aPoint;
634 #else
635         return mpImpl->GetOffset();
636 #endif
637     }
638 
UpdateChildren()639     void AccessibleStaticTextBase::UpdateChildren() SAL_THROW((::com::sun::star::uno::RuntimeException))
640     {
641 #ifdef DBG_UTIL
642         // precondition: solar mutex locked
643         DBG_TESTSOLARMUTEX();
644 
645         mpImpl->CheckInvariants();
646 
647         mpImpl->UpdateChildren();
648 
649         mpImpl->CheckInvariants();
650 #else
651         mpImpl->UpdateChildren();
652 #endif
653     }
654 
Dispose()655     void AccessibleStaticTextBase::Dispose()
656     {
657 #ifdef DBG_UTIL
658         mpImpl->CheckInvariants();
659 #endif
660 
661         mpImpl->Dispose();
662 
663 #ifdef DBG_UTIL
664         mpImpl->CheckInvariants();
665 #endif
666     }
667 
668 	// XAccessibleContext
getAccessibleChildCount()669     sal_Int32 SAL_CALL AccessibleStaticTextBase::getAccessibleChildCount() throw (uno::RuntimeException)
670     {
671         // no children at all
672         return 0;
673     }
674 
getAccessibleChild(sal_Int32)675     uno::Reference< XAccessible > SAL_CALL AccessibleStaticTextBase::getAccessibleChild( sal_Int32 /*i*/ ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
676     {
677         // no children at all
678         return uno::Reference< XAccessible >();
679     }
680 
getAccessibleAtPoint(const awt::Point &)681     uno::Reference< XAccessible > SAL_CALL AccessibleStaticTextBase::getAccessibleAtPoint( const awt::Point& /*_aPoint*/ ) throw (uno::RuntimeException)
682     {
683         // no children at all
684         return uno::Reference< XAccessible >();
685     }
686 
687 	// XAccessibleText
getCaretPosition()688     sal_Int32 SAL_CALL AccessibleStaticTextBase::getCaretPosition() throw (uno::RuntimeException)
689     {
690         ::vos::OGuard aGuard( Application::GetSolarMutex() );
691 
692         sal_Int32 i, nPos, nParas;
693         for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
694         {
695             if( (nPos=mpImpl->GetParagraph(i).getCaretPosition()) != -1 )
696                 return nPos;
697         }
698 
699         return nPos;
700     }
701 
setCaretPosition(sal_Int32 nIndex)702     sal_Bool SAL_CALL AccessibleStaticTextBase::setCaretPosition( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
703     {
704         return setSelection(nIndex, nIndex);
705     }
706 
getCharacter(sal_Int32 nIndex)707     sal_Unicode SAL_CALL AccessibleStaticTextBase::getCharacter( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
708     {
709         ::vos::OGuard aGuard( Application::GetSolarMutex() );
710 
711         EPosition aPos( mpImpl->Index2Internal(nIndex) );
712 
713         return mpImpl->GetParagraph( aPos.nPara ).getCharacter( aPos.nIndex );
714     }
715 
getCharacterAttributes(sal_Int32 nIndex,const::com::sun::star::uno::Sequence<::rtl::OUString> & aRequestedAttributes)716     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getCharacterAttributes( sal_Int32 nIndex, const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aRequestedAttributes ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
717     {
718         ::vos::OGuard aGuard( Application::GetSolarMutex() );
719 		//get the actual index without "\n"
720 		mpImpl->RemoveLineBreakCount( nIndex );
721 
722         EPosition aPos( mpImpl->Index2Internal(nIndex) );
723 
724         return mpImpl->GetParagraph( aPos.nPara ).getCharacterAttributes( aPos.nIndex, aRequestedAttributes );
725     }
726 
getCharacterBounds(sal_Int32 nIndex)727     awt::Rectangle SAL_CALL AccessibleStaticTextBase::getCharacterBounds( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
728     {
729         ::vos::OGuard aGuard( Application::GetSolarMutex() );
730 
731         // #108900# Allow ranges for nIndex, as one-past-the-end
732         // values are now legal, too.
733         EPosition aPos( mpImpl->Range2Internal(nIndex) );
734 
735         // #i70916# Text in spread sheet cells return the wrong extents
736         AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( aPos.nPara );
737         awt::Rectangle aParaBounds( rPara.getBounds() );
738         awt::Rectangle aBounds( rPara.getCharacterBounds( aPos.nIndex ) );
739         aBounds.X += aParaBounds.X;
740         aBounds.Y += aParaBounds.Y;
741 
742         return aBounds;
743     }
744 
getCharacterCount()745     sal_Int32 SAL_CALL AccessibleStaticTextBase::getCharacterCount() throw (uno::RuntimeException)
746     {
747         ::vos::OGuard aGuard( Application::GetSolarMutex() );
748 
749         sal_Int32 i, nCount, nParas;
750         for( i=0, nCount=0, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
751             nCount += mpImpl->GetParagraph(i).getCharacterCount();
752 		//count on the number of "\n" which equals number of paragraphs decrease 1.
753 		nCount = nCount + (nParas-1);
754         return nCount;
755     }
756 
getIndexAtPoint(const awt::Point & rPoint)757     sal_Int32 SAL_CALL AccessibleStaticTextBase::getIndexAtPoint( const awt::Point& rPoint ) throw (uno::RuntimeException)
758     {
759         ::vos::OGuard aGuard( Application::GetSolarMutex() );
760 
761         const sal_Int32 nParas( mpImpl->GetParagraphCount() );
762         sal_Int32 nIndex;
763         int i;
764         for( i=0; i<nParas; ++i )
765         {
766             // TODO: maybe exploit the fact that paragraphs are
767             // ordered vertically for early exit
768 
769             // #i70916# Text in spread sheet cells return the wrong extents
770             AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( i );
771             awt::Rectangle aParaBounds( rPara.getBounds() );
772             awt::Point aPoint( rPoint );
773             aPoint.X -= aParaBounds.X;
774             aPoint.Y -= aParaBounds.Y;
775 
776             // #112814# Use correct index offset
777             if ( ( nIndex = rPara.getIndexAtPoint( aPoint ) ) != -1 )
778                 return mpImpl->Internal2Index( EPosition(i,
779                                                          sal::static_int_cast<sal_uInt16>(nIndex)) );
780         }
781 
782         return -1;
783     }
784 
getSelectedText()785     ::rtl::OUString SAL_CALL AccessibleStaticTextBase::getSelectedText() throw (uno::RuntimeException)
786     {
787         ::vos::OGuard aGuard( Application::GetSolarMutex() );
788 
789         sal_Int32 nStart( getSelectionStart() );
790         sal_Int32 nEnd( getSelectionEnd() );
791 
792         // #104481# Return the empty string for 'no selection'
793         if( nStart < 0 || nEnd < 0 )
794             return ::rtl::OUString();
795 
796         return getTextRange( nStart, nEnd );
797     }
798 
getSelectionStart()799     sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionStart() throw (uno::RuntimeException)
800     {
801         ::vos::OGuard aGuard( Application::GetSolarMutex() );
802 
803         sal_Int32 i, nPos, nParas;
804         for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
805         {
806             if( (nPos=mpImpl->GetParagraph(i).getSelectionStart()) != -1 )
807                 return nPos;
808         }
809 
810         return nPos;
811     }
812 
getSelectionEnd()813     sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionEnd() throw (uno::RuntimeException)
814     {
815         ::vos::OGuard aGuard( Application::GetSolarMutex() );
816 
817         sal_Int32 i, nPos, nParas;
818         for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
819         {
820             if( (nPos=mpImpl->GetParagraph(i).getSelectionEnd()) != -1 )
821                 return nPos;
822         }
823 
824         return nPos;
825     }
826 
setSelection(sal_Int32 nStartIndex,sal_Int32 nEndIndex)827     sal_Bool SAL_CALL AccessibleStaticTextBase::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
828     {
829         ::vos::OGuard aGuard( Application::GetSolarMutex() );
830 
831         EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
832         EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
833 
834         return mpImpl->SetSelection( aStartIndex.nPara, aStartIndex.nIndex,
835                                      aEndIndex.nPara, aEndIndex.nIndex );
836     }
837 
getText()838     ::rtl::OUString SAL_CALL AccessibleStaticTextBase::getText() throw (uno::RuntimeException)
839     {
840         ::vos::OGuard aGuard( Application::GetSolarMutex() );
841 
842         sal_Int32 i, nParas;
843         ::rtl::OUString aRes;
844         for( i=0, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
845             aRes += mpImpl->GetParagraph(i).getText();
846 
847         return aRes;
848     }
849 
getTextRange(sal_Int32 nStartIndex,sal_Int32 nEndIndex)850     ::rtl::OUString SAL_CALL AccessibleStaticTextBase::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
851     {
852         ::vos::OGuard aGuard( Application::GetSolarMutex() );
853 
854         if( nStartIndex > nEndIndex )
855             ::std::swap(nStartIndex, nEndIndex);
856 		//if startindex equals endindex we will get nothing. So return an empty string directly.
857 		if ( nStartIndex == nEndIndex )
858 		{
859 			::rtl::OUString sEmptyStr;
860 			return sEmptyStr;
861 		}
862 		sal_Bool bStart = mpImpl->RemoveLineBreakCount( nStartIndex );
863 		//if the start index is just at a "\n", we need to begin from the next char
864 		if ( bStart )
865 		{
866 			nStartIndex++;
867 		}
868 		//we need to find out whether the previous position of the current endindex is at "\n" or not
869 		//if yes we need to mark it and add "\n" at the end of the result
870 		sal_Int32 nTemp = nEndIndex - 1;
871 		sal_Bool bEnd = mpImpl->RemoveLineBreakCount( nTemp );
872 		sal_Bool bTemp = mpImpl->RemoveLineBreakCount( nEndIndex );
873 		//if the below condition is true it indicates an empty paragraph with just a "\n"
874 		//so we need to set one "\n" flag to avoid duplication.
875 		if ( bStart && bEnd && ( nStartIndex == nEndIndex) )
876 		{
877 			bEnd = sal_False;
878 		}
879 		//if the current endindex is at a "\n", we need to increase endindex by 1 to make sure
880 		//the char before "\n" is included. Because string returned by this function will not include
881 		//the char at the endindex.
882 		if ( bTemp )
883 		{
884 			nEndIndex++;
885 		}
886 		::rtl::OUString aRes;
887         EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
888         EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
889 
890         // #102170# Special case: start and end paragraph are identical
891         if( aStartIndex.nPara == aEndIndex.nPara )
892         {
893 			//we don't return the string directly now for that we have to do some further process for "\n"
894 			aRes = mpImpl->GetParagraph( aStartIndex.nPara ).getTextRange( aStartIndex.nIndex, aEndIndex.nIndex );
895         }
896         else
897         {
898             sal_Int32 i( aStartIndex.nPara );
899 	            aRes = mpImpl->GetParagraph(i).getTextRange( aStartIndex.nIndex,
900                                                                         mpImpl->GetParagraph(i).getCharacterCount()/*-1*/);
901             ++i;
902 
903             // paragraphs inbetween are fully included
904             for( ; i<aEndIndex.nPara; ++i )
905 			{
906 				aRes += rtl::OUString(cNewLine);
907                 aRes += mpImpl->GetParagraph(i).getText();
908 			}
909 
910             if( i<=aEndIndex.nPara )
911 			{
912 				//if the below condition is mathed it means the endindex is at mid of the last paragraph
913 				//we need to add a "\n" before we add the last part of the string.
914 				if ( !bEnd && aEndIndex.nIndex )
915 				{
916 					aRes += rtl::OUString(cNewLine);
917 				}
918                 aRes += mpImpl->GetParagraph(i).getTextRange( 0, aEndIndex.nIndex );
919 			}
920             //return aRes;
921         }
922 		//According to the flag we marked before, we have to add "\n" at the beginning
923 		//or at the end of the result string.
924 		if ( bStart )
925 		{
926 			aRes = rtl::OUString(cNewLine) + aRes;
927 		}
928 		if ( bEnd )
929 		{
930 			aRes += rtl::OUString(cNewLine);
931 		}
932 		return aRes;
933     }
934 
getTextAtIndex(sal_Int32 nIndex,sal_Int16 aTextType)935     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
936     {
937         ::vos::OGuard aGuard( Application::GetSolarMutex() );
938 
939 		sal_Bool bLineBreak = mpImpl->RemoveLineBreakCount( nIndex );
940         EPosition aPos( mpImpl->Range2Internal(nIndex) );
941 
942         ::com::sun::star::accessibility::TextSegment aResult;
943 
944         if( AccessibleTextType::PARAGRAPH == aTextType )
945         {
946             // #106393# Special casing one behind last paragraph is
947             // not necessary, since then, we return the content and
948             // boundary of that last paragraph. Range2Internal is
949             // tolerant against that, and returns the last paragraph
950             // in aPos.nPara.
951 
952             // retrieve full text of the paragraph
953             aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara ).getText();
954 
955             // #112814# Adapt the start index with the paragraph offset
956             aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara, 0 ) );
957             aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
958         }
959         else if ( AccessibleTextType::ATTRIBUTE_RUN == aTextType )
960         {
961               SvxAccessibleTextAdapter& rTextForwarder = mpImpl->GetParagraph( aPos.nIndex ).GetTextForwarder();
962               sal_uInt16 nStartIndex, nEndIndex;
963               if ( rTextForwarder.GetAttributeRun( nStartIndex, nEndIndex, aPos.nPara, aPos.nIndex, sal_True ) )
964               {
965                      aResult.SegmentText = getTextRange( nStartIndex, nEndIndex );
966                      aResult.SegmentStart = nStartIndex;
967                      aResult.SegmentEnd = nEndIndex;
968               }
969         }
970         else
971         {
972             // No special handling required, forward to wrapped class
973             aResult = mpImpl->GetParagraph( aPos.nPara ).getTextAtIndex( aPos.nIndex, aTextType );
974 
975             // #112814# Adapt the start index with the paragraph offset
976             mpImpl->CorrectTextSegment( aResult, aPos.nPara );
977 			if ( bLineBreak )
978 			{
979 				aResult.SegmentText = rtl::OUString(cNewLine);
980 			}
981         }
982 
983         return aResult;
984     }
985 
getTextBeforeIndex(sal_Int32 nIndex,sal_Int16 aTextType)986     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
987     {
988         ::vos::OGuard aGuard( Application::GetSolarMutex() );
989 		sal_Int32 nOldIdx = nIndex;
990 		sal_Bool bLineBreak =  mpImpl->RemoveLineBreakCount( nIndex );
991         EPosition aPos( mpImpl->Range2Internal(nIndex) );
992 
993         ::com::sun::star::accessibility::TextSegment aResult;
994 
995         if( AccessibleTextType::PARAGRAPH == aTextType )
996         {
997             if( aPos.nIndex == mpImpl->GetParagraph( aPos.nPara ).getCharacterCount() )
998             {
999                 // #103589# Special casing one behind the last paragraph
1000                 aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara ).getText();
1001 
1002                 // #112814# Adapt the start index with the paragraph offset
1003                 aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara, 0 ) );
1004             }
1005             else if( aPos.nPara > 0 )
1006             {
1007                 aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara - 1 ).getText();
1008 
1009                 // #112814# Adapt the start index with the paragraph offset
1010                 aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara - 1, 0 ) );
1011             }
1012 
1013             aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
1014         }
1015         else
1016         {
1017             // No special handling required, forward to wrapped class
1018             aResult = mpImpl->GetParagraph( aPos.nPara ).getTextBeforeIndex( aPos.nIndex, aTextType );
1019 
1020             // #112814# Adapt the start index with the paragraph offset
1021             mpImpl->CorrectTextSegment( aResult, aPos.nPara );
1022 			if ( bLineBreak && (nOldIdx-1) >= 0)
1023 			{
1024 				aResult = getTextAtIndex( nOldIdx-1, aTextType );
1025 			}
1026         }
1027 
1028         return aResult;
1029     }
1030 
getTextBehindIndex(sal_Int32 nIndex,sal_Int16 aTextType)1031     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
1032     {
1033         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1034 		sal_Int32 nTemp = nIndex+1;
1035 		sal_Bool bLineBreak = mpImpl->RemoveLineBreakCount( nTemp );
1036 		mpImpl->RemoveLineBreakCount( nIndex );
1037         EPosition aPos( mpImpl->Range2Internal(nIndex) );
1038 
1039         ::com::sun::star::accessibility::TextSegment aResult;
1040 
1041         if( AccessibleTextType::PARAGRAPH == aTextType )
1042         {
1043             // Special casing one behind the last paragraph is not
1044             // necessary, this case is invalid here for
1045             // getTextBehindIndex
1046             if( aPos.nPara + 1 < mpImpl->GetParagraphCount() )
1047             {
1048                 aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara + 1 ).getText();
1049 
1050                 // #112814# Adapt the start index with the paragraph offset
1051                 aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara + 1, 0 ) );
1052                 aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
1053             }
1054         }
1055         else
1056         {
1057             // No special handling required, forward to wrapped class
1058             aResult = mpImpl->GetParagraph( aPos.nPara ).getTextBehindIndex( aPos.nIndex, aTextType );
1059 
1060             // #112814# Adapt the start index with the paragraph offset
1061             mpImpl->CorrectTextSegment( aResult, aPos.nPara );
1062 			if ( bLineBreak )
1063 			{
1064 				aResult.SegmentText = rtl::OUString(cNewLine) + aResult.SegmentText;
1065 			}
1066        }
1067 
1068         return aResult;
1069     }
1070 
copyText(sal_Int32 nStartIndex,sal_Int32 nEndIndex)1071     sal_Bool SAL_CALL AccessibleStaticTextBase::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1072     {
1073         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1074 
1075         if( nStartIndex > nEndIndex )
1076             ::std::swap(nStartIndex, nEndIndex);
1077 
1078         EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
1079         EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
1080 
1081         return mpImpl->CopyText( aStartIndex.nPara, aStartIndex.nIndex,
1082                                  aEndIndex.nPara, aEndIndex.nIndex );
1083     }
1084 
1085     // XAccessibleTextAttributes
getDefaultAttributes(const uno::Sequence<::rtl::OUString> & RequestedAttributes)1086     uno::Sequence< beans::PropertyValue > AccessibleStaticTextBase::getDefaultAttributes( const uno::Sequence< ::rtl::OUString >& RequestedAttributes ) throw (uno::RuntimeException)
1087     {
1088         // get the intersection of the default attributes of all paragraphs
1089 
1090         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1091 
1092         PropertyValueVector aDefAttrVec( mpImpl->GetParagraph( 0 ).getDefaultAttributes( RequestedAttributes ) );
1093 
1094         const sal_Int32 nParaCount = mpImpl->GetParagraphCount();
1095         for ( sal_Int32 nPara = 1; nPara < nParaCount; ++nPara )
1096         {
1097             uno::Sequence< beans::PropertyValue > aSeq = mpImpl->GetParagraph( nPara ).getDefaultAttributes( RequestedAttributes );
1098             PropertyValueVector aIntersectionVec;
1099 
1100             PropertyValueVector::const_iterator aEnd = aDefAttrVec.end();
1101             for ( PropertyValueVector::const_iterator aItr = aDefAttrVec.begin(); aItr != aEnd; ++aItr )
1102             {
1103                 const beans::PropertyValue* pItr = aSeq.getConstArray();
1104                 const beans::PropertyValue* pEnd  = pItr + aSeq.getLength();
1105                 const beans::PropertyValue* pFind = ::std::find_if( pItr, pEnd, ::std::bind2nd( PropertyValueEqualFunctor(), boost::cref( *aItr ) ) );
1106                 if ( pFind != pEnd )
1107                 {
1108                     aIntersectionVec.push_back( *pFind );
1109                 }
1110             }
1111 
1112             aDefAttrVec.swap( aIntersectionVec );
1113 
1114             if ( aDefAttrVec.empty() )
1115             {
1116                 break;
1117             }
1118         }
1119 
1120         return aDefAttrVec.getAsConstList();
1121     }
1122 
getRunAttributes(sal_Int32 nIndex,const uno::Sequence<::rtl::OUString> & RequestedAttributes)1123     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getRunAttributes( sal_Int32 nIndex, const uno::Sequence< ::rtl::OUString >& RequestedAttributes ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1124     {
1125         // get those default attributes of the paragraph, which are not part
1126         // of the intersection of all paragraphs and add them to the run attributes
1127 
1128         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1129 
1130         EPosition aPos( mpImpl->Index2Internal( nIndex ) );
1131         AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( aPos.nPara );
1132         uno::Sequence< beans::PropertyValue > aDefAttrSeq = rPara.getDefaultAttributes( RequestedAttributes );
1133         uno::Sequence< beans::PropertyValue > aRunAttrSeq = rPara.getRunAttributes( aPos.nIndex, RequestedAttributes );
1134         uno::Sequence< beans::PropertyValue > aIntersectionSeq = getDefaultAttributes( RequestedAttributes );
1135         PropertyValueVector aDiffVec;
1136 
1137         const beans::PropertyValue* pDefAttr = aDefAttrSeq.getConstArray();
1138         const sal_Int32 nLength = aDefAttrSeq.getLength();
1139         for ( sal_Int32 i = 0; i < nLength; ++i )
1140         {
1141             const beans::PropertyValue* pItr = aIntersectionSeq.getConstArray();
1142             const beans::PropertyValue* pEnd  = pItr + aIntersectionSeq.getLength();
1143             const beans::PropertyValue* pFind = ::std::find_if( pItr, pEnd, ::std::bind2nd( PropertyValueEqualFunctor(), boost::cref( pDefAttr[i] ) ) );
1144             if ( pFind == pEnd && pDefAttr[i].Handle != 0)
1145             {
1146                 aDiffVec.push_back( pDefAttr[i] );
1147             }
1148         }
1149 
1150         return ::comphelper::concatSequences( aRunAttrSeq, aDiffVec.getAsConstList() );
1151     }
1152 
GetParagraphBoundingBox() const1153     Rectangle AccessibleStaticTextBase::GetParagraphBoundingBox() const
1154     {
1155         return mpImpl->GetParagraphBoundingBox();
1156     }
1157 
GetParagraphIndex() const1158     sal_Int32 AccessibleStaticTextBase::GetParagraphIndex() const
1159     {
1160         return mpImpl->GetParagraphIndex();
1161     }
1162 
GetParagraphCount() const1163     sal_Int32 AccessibleStaticTextBase::GetParagraphCount() const
1164     {
1165         return mpImpl->GetParagraphCount();
1166     }
1167 
GetLineCount(sal_Int32 nParagraph) const1168     sal_Int32 AccessibleStaticTextBase::GetLineCount( sal_Int32 nParagraph ) const
1169     {
1170         return mpImpl->GetLineCount( nParagraph );
1171     }
1172 
1173 }  // end of namespace accessibility
1174 
1175 //------------------------------------------------------------------------
1176