editeng/source/accessibility/AccessibleStaticTextBase.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 // Global header
  22
  23
  24 #include <limits.h>
  25 #include <utility>
  26 #include <memory>
  27 #include <vector>
  28 #include <algorithm>
  29 #include <functional>
  30 #include <tools/debug.hxx>
  31 #include <vcl/window.hxx>
  32 #include <vcl/svapp.hxx>
  33 #include <comphelper/sequence.hxx>
  34 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  35 #include <com/sun/star/uno/Reference.hxx>
  36 #include <com/sun/star/awt/Point.hpp>
  37 #include <com/sun/star/awt/Rectangle.hpp>
  38 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
  39
  40
  41 // Project-local header
  42
  43
  44 #include <editeng/editdata.hxx>
  45 #include <editeng/unopracc.hxx>
  46 #include <editeng/unoedprx.hxx>
  47 #include <editeng/AccessibleStaticTextBase.hxx>
  48 #include <editeng/AccessibleEditableTextPara.hxx>
  49
  50
  51 using namespace ::com::sun::star;
  52 using namespace ::com::sun::star::accessibility;
  53
  54 /* TODO:
  55    =====
  56
  57    - separate adapter functionality from AccessibleStaticText class
  58
  59    - refactor common loops into templates, using mem_fun
  60
  61  */
  62
  63 namespace accessibility
  64 {
  65     typedef std::vector< beans::PropertyValue > PropertyValueVector;
  66
  67     class PropertyValueEqualFunctor
  68     {
  69         const beans::PropertyValue& m_rPValue;
  70
  71     public:
  72         explicit PropertyValueEqualFunctor(const beans::PropertyValue& rPValue)
  73             : m_rPValue(rPValue)
  74         {}
  75         bool operator() ( const beans::PropertyValue& rhs ) const
  76         {
  77             return ( m_rPValue.Name == rhs.Name && m_rPValue.Value == rhs.Value );
  78         }
  79     };
  80     sal_Unicode const cNewLine(0x0a);
  81
  82
  83     // Static Helper
  84
  85
  86     static ESelection MakeSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
  87                               sal_Int32 nEndPara, sal_Int32 nEndIndex )
  88     {
  89         DBG_ASSERT(nStartPara >= 0 &&
  90                    nStartIndex >= 0 &&
  91                    nEndPara >= 0 &&
  92                    nEndIndex >= 0,
  93                    "AccessibleStaticTextBase_Impl::MakeSelection: index value overflow");
  94
  95         return ESelection(nStartPara, nStartIndex, nEndPara, nEndIndex);
  96     }
  97
  98
  99     // AccessibleStaticTextBase_Impl declaration
 100
 101
 102     /** AccessibleStaticTextBase_Impl
 103
 104         This class implements the AccessibleStaticTextBase
 105         functionality, mainly by forwarding the calls to an aggregated
 106         AccessibleEditableTextPara. As this is a therefore non-trivial
 107         adapter, factoring out the common functionality from
 108         AccessibleEditableTextPara might be a profitable future task.
 109      */
 110     class AccessibleStaticTextBase_Impl
 111     {
 112         friend class AccessibleStaticTextBase;
 113     public:
 114
 115         // receive pointer to our frontend class and view window
 116         AccessibleStaticTextBase_Impl();
 117
 118         void SetEditSource( std::unique_ptr< SvxEditSource > && pEditSource );
 119
 120         void SetEventSource( const uno::Reference< XAccessible >& rInterface )
 121         {
 122
 123             mxThis = rInterface;
 124         }
 125
 126         void SetOffset( const Point& );
 127
 128         void Dispose();
 129
 130         AccessibleEditableTextPara& GetParagraph( sal_Int32 nPara ) const;
 131         sal_Int32                   GetParagraphCount() const;
 132
 133         EPosition                   Index2Internal( sal_Int32 nFlatIndex ) const
 134         {
 135
 136             return ImpCalcInternal( nFlatIndex, false );
 137         }
 138
 139         EPosition                   Range2Internal( sal_Int32 nFlatIndex ) const
 140         {
 141
 142             return ImpCalcInternal( nFlatIndex, true );
 143         }
 144
 145         sal_Int32                   Internal2Index( EPosition nEEIndex ) const;
 146
 147         void                        CorrectTextSegment( TextSegment&    aTextSegment,
 148                                                         int             nPara   ) const;
 149
 150         bool                    SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
 151                                                   sal_Int32 nEndPara, sal_Int32 nEndIndex );
 152         bool                    CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
 153                                               sal_Int32 nEndPara, sal_Int32 nEndIndex );
 154
 155         tools::Rectangle                   GetParagraphBoundingBox() const;
 156         bool                    RemoveLineBreakCount( sal_Int32& rIndex );
 157
 158     private:
 159
 160         EPosition                   ImpCalcInternal( sal_Int32 nFlatIndex, bool bExclusive ) const;
 161
 162         // our frontend class (the one implementing the actual
 163         // interface). That's not necessarily the one containing the impl
 164         // pointer
 165         uno::Reference< XAccessible > mxThis;
 166
 167         // implements our functionality, we're just an adapter (guarded by solar mutex)
 168         mutable rtl::Reference<AccessibleEditableTextPara> mxTextParagraph;
 169
 170         // a wrapper for the text forwarders (guarded by solar mutex)
 171         mutable SvxEditSourceAdapter maEditSource;
 172     };
 173
 174
 175     // AccessibleStaticTextBase_Impl implementation
 176
 177
 178     AccessibleStaticTextBase_Impl::AccessibleStaticTextBase_Impl() :
 179         mxTextParagraph( new AccessibleEditableTextPara(nullptr) ),
 180         maEditSource()
 181     {
 182
 183         // TODO: this is still somewhat of a hack, all the more since
 184         // now the maTextParagraph has an empty parent reference set
 185     }
 186
 187     void AccessibleStaticTextBase_Impl::SetEditSource( std::unique_ptr< SvxEditSource > && pEditSource )
 188     {
 189
 190         maEditSource.SetEditSource( std::move(pEditSource) );
 191         if( mxTextParagraph.is() )
 192             mxTextParagraph->SetEditSource( &maEditSource );
 193     }
 194
 195     void AccessibleStaticTextBase_Impl::SetOffset( const Point& rPoint )
 196     {
 197         if( mxTextParagraph.is() )
 198             mxTextParagraph->SetEEOffset( rPoint );
 199     }
 200
 201     void AccessibleStaticTextBase_Impl::Dispose()
 202     {
 203
 204         // we're the owner of the paragraph, so destroy it, too
 205         if( mxTextParagraph.is() )
 206             mxTextParagraph->Dispose();
 207
 208         // drop references
 209         mxThis = nullptr;
 210         mxTextParagraph.clear();
 211     }
 212
 213     AccessibleEditableTextPara& AccessibleStaticTextBase_Impl::GetParagraph( sal_Int32 nPara ) const
 214     {
 215
 216         if( !mxTextParagraph.is() )
 217             throw lang::DisposedException ("object has been already disposed", mxThis );
 218
 219         // TODO: Have a different method on AccessibleEditableTextPara
 220         // that does not care about state changes
 221         mxTextParagraph->SetParagraphIndex( nPara );
 222
 223         return *mxTextParagraph;
 224     }
 225
 226     sal_Int32 AccessibleStaticTextBase_Impl::GetParagraphCount() const
 227     {
 228
 229         if( !mxTextParagraph.is() )
 230             return 0;
 231         else
 232             return mxTextParagraph->GetTextForwarder().GetParagraphCount();
 233     }
 234
 235     sal_Int32 AccessibleStaticTextBase_Impl::Internal2Index( EPosition nEEIndex ) const
 236     {
 237         // XXX checks for overflow and returns maximum if so
 238         sal_Int32 aRes(0);
 239         for(sal_Int32 i=0; i<nEEIndex.nPara; ++i)
 240         {
 241             sal_Int32 nCount = GetParagraph(i).getCharacterCount();
 242             if (SAL_MAX_INT32 - aRes > nCount)
 243                 return SAL_MAX_INT32;
 244             aRes += nCount;
 245         }
 246
 247         if (SAL_MAX_INT32 - aRes > nEEIndex.nIndex)
 248             return SAL_MAX_INT32;
 249         return aRes + nEEIndex.nIndex;
 250     }
 251
 252     void AccessibleStaticTextBase_Impl::CorrectTextSegment( TextSegment&    aTextSegment,
 253                                                             int             nPara   ) const
 254     {
 255         // Keep 'invalid' values at the TextSegment
 256         if( aTextSegment.SegmentStart != -1 &&
 257             aTextSegment.SegmentEnd != -1 )
 258         {
 259             // #112814# Correct TextSegment by paragraph offset
 260             sal_Int32 nOffset(0);
 261             int i;
 262             for(i=0; i<nPara; ++i)
 263                 nOffset += GetParagraph(i).getCharacterCount();
 264
 265             aTextSegment.SegmentStart += nOffset;
 266             aTextSegment.SegmentEnd += nOffset;
 267         }
 268     }
 269
 270     EPosition AccessibleStaticTextBase_Impl::ImpCalcInternal( sal_Int32 nFlatIndex, bool bExclusive ) const
 271     {
 272
 273         if( nFlatIndex < 0 )
 274             throw lang::IndexOutOfBoundsException("AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds",
 275                                                   mxThis);
 276         // gratuitously accepting larger indices here, AccessibleEditableTextPara will throw eventually
 277
 278         sal_Int32 nCurrPara, nCurrIndex, nParas, nCurrCount;
 279         for( nCurrPara=0, nParas=GetParagraphCount(), nCurrCount=0, nCurrIndex=0; nCurrPara<nParas; ++nCurrPara )
 280         {
 281             nCurrCount = GetParagraph( nCurrPara ).getCharacterCount();
 282             nCurrIndex += nCurrCount;
 283             if( nCurrIndex >= nFlatIndex )
 284             {
 285                 // check overflow
 286                 DBG_ASSERT(nCurrPara >= 0 &&
 287                            nFlatIndex - nCurrIndex + nCurrCount >= 0,
 288                            "AccessibleStaticTextBase_Impl::Index2Internal: index value overflow");
 289
 290                 return EPosition(nCurrPara, nFlatIndex - nCurrIndex + nCurrCount);
 291             }
 292         }
 293
 294         // #102170# Allow one-past the end for ranges
 295         if( bExclusive && nCurrIndex == nFlatIndex )
 296         {
 297             // check overflow
 298             DBG_ASSERT(nCurrPara > 0 &&
 299                        nFlatIndex - nCurrIndex + nCurrCount >= 0,
 300                        "AccessibleStaticTextBase_Impl::Index2Internal: index value overflow");
 301
 302             return EPosition(nCurrPara-1, nFlatIndex - nCurrIndex + nCurrCount);
 303         }
 304
 305         // not found? Out of bounds
 306         throw lang::IndexOutOfBoundsException("AccessibleStaticTextBase_Impl::Index2Internal: character index out of bounds",
 307                                               mxThis);
 308     }
 309
 310     bool AccessibleStaticTextBase_Impl::SetSelection( sal_Int32 nStartPara, sal_Int32 nStartIndex,
 311                                                           sal_Int32 nEndPara, sal_Int32 nEndIndex )
 312     {
 313
 314         if( !mxTextParagraph.is() )
 315             return false;
 316
 317         try
 318         {
 319             SvxEditViewForwarder& rCacheVF = mxTextParagraph->GetEditViewForwarder( true );
 320             return rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
 321         }
 322         catch( const uno::RuntimeException& )
 323         {
 324             return false;
 325         }
 326     }
 327
 328     bool AccessibleStaticTextBase_Impl::CopyText( sal_Int32 nStartPara, sal_Int32 nStartIndex,
 329                                                       sal_Int32 nEndPara, sal_Int32 nEndIndex )
 330     {
 331
 332         if( !mxTextParagraph.is() )
 333             return false;
 334
 335         try
 336         {
 337             SvxEditViewForwarder& rCacheVF = mxTextParagraph->GetEditViewForwarder( true );
 338             mxTextParagraph->GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
 339             bool aRetVal;
 340
 341             // save current selection
 342             ESelection aOldSelection;
 343
 344             rCacheVF.GetSelection( aOldSelection );
 345             rCacheVF.SetSelection( MakeSelection(nStartPara, nStartIndex, nEndPara, nEndIndex) );
 346             aRetVal = rCacheVF.Copy();
 347             rCacheVF.SetSelection( aOldSelection ); // restore
 348
 349             return aRetVal;
 350         }
 351         catch( const uno::RuntimeException& )
 352         {
 353             return false;
 354         }
 355     }
 356
 357     tools::Rectangle AccessibleStaticTextBase_Impl::GetParagraphBoundingBox() const
 358     {
 359         tools::Rectangle aRect;
 360         if( mxTextParagraph.is() )
 361         {
 362             awt::Rectangle aAwtRect = mxTextParagraph->getBounds();
 363             aRect = tools::Rectangle( Point( aAwtRect.X, aAwtRect.Y ), Size( aAwtRect.Width, aAwtRect.Height ) );
 364         }
 365         else
 366         {
 367             aRect.SetEmpty();
 368         }
 369         return aRect;
 370     }
 371     //the input argument is the index(including "\n" ) in the string.
 372     //the function will calculate the actual index(not including "\n") in the string.
 373     //and return true if the index is just at a "\n"
 374     bool AccessibleStaticTextBase_Impl::RemoveLineBreakCount( sal_Int32& rIndex )
 375     {
 376         // get the total char number inside the cell.
 377         sal_Int32 i, nCount, nParas;
 378         for( i=0, nCount=0, nParas=GetParagraphCount(); i<nParas; ++i )
 379             nCount += GetParagraph(i).getCharacterCount();
 380         nCount = nCount + (nParas-1);
 381         if( nCount == 0 &&  rIndex == 0) return false;
 382
 383
 384         sal_Int32 nCurrPara, nCurrCount;
 385         sal_Int32 nLineBreakPos = 0, nLineBreakCount = 0;
 386         sal_Int32 nParaCount = GetParagraphCount();
 387         for ( nCurrCount = 0, nCurrPara = 0; nCurrPara < nParaCount; nCurrPara++ )
 388         {
 389             nCurrCount += GetParagraph( nCurrPara ).getCharacterCount();
 390             nLineBreakPos = nCurrCount++;
 391             if ( rIndex == nLineBreakPos )
 392             {
 393                 rIndex -= (++nLineBreakCount);//(++nLineBreakCount);
 394                 if ( rIndex < 0)
 395                 {
 396                     rIndex = 0;
 397                 }
 398                 //if the index is at the last position of the last paragraph
 399                 //there is no "\n" , so we should increase rIndex by 1 and return false.
 400                 if ( (nCurrPara+1) == nParaCount )
 401                 {
 402                     rIndex++;
 403                     return false;
 404                 }
 405                 else
 406                 {
 407                     return true;
 408                 }
 409             }
 410             else if ( rIndex < nLineBreakPos )
 411             {
 412                 rIndex -= nLineBreakCount;
 413                 return false;
 414             }
 415             else
 416             {
 417                 nLineBreakCount++;
 418             }
 419         }
 420         return false;
 421     }
 422
 423
 424     // AccessibleStaticTextBase implementation
 425
 426     AccessibleStaticTextBase::AccessibleStaticTextBase( std::unique_ptr< SvxEditSource > && pEditSource ) :
 427         mpImpl( new AccessibleStaticTextBase_Impl() )
 428     {
 429         SolarMutexGuard aGuard;
 430
 431         SetEditSource( std::move(pEditSource) );
 432     }
 433
 434     AccessibleStaticTextBase::~AccessibleStaticTextBase()
 435     {
 436     }
 437
 438     void AccessibleStaticTextBase::SetEditSource( std::unique_ptr< SvxEditSource > && pEditSource )
 439     {
 440         // precondition: solar mutex locked
 441         DBG_TESTSOLARMUTEX();
 442
 443         mpImpl->SetEditSource( std::move(pEditSource) );
 444     }
 445
 446     void AccessibleStaticTextBase::SetEventSource( const uno::Reference< XAccessible >& rInterface )
 447     {
 448         mpImpl->SetEventSource( rInterface );
 449
 450     }
 451
 452     void AccessibleStaticTextBase::SetOffset( const Point& rPoint )
 453     {
 454         // precondition: solar mutex locked
 455         DBG_TESTSOLARMUTEX();
 456
 457         mpImpl->SetOffset( rPoint );
 458     }
 459
 460     void AccessibleStaticTextBase::Dispose()
 461     {
 462         mpImpl->Dispose();
 463
 464     }
 465
 466     // XAccessibleContext
 467     sal_Int32 AccessibleStaticTextBase::getAccessibleChildCount()
 468     {
 469         // no children at all
 470         return 0;
 471     }
 472
 473     uno::Reference< XAccessible > AccessibleStaticTextBase::getAccessibleChild( sal_Int32 /*i*/ )
 474     {
 475         // no children at all
 476         return uno::Reference< XAccessible >();
 477     }
 478
 479     uno::Reference< XAccessible > AccessibleStaticTextBase::getAccessibleAtPoint( const awt::Point& /*_aPoint*/ )
 480     {
 481         // no children at all
 482         return uno::Reference< XAccessible >();
 483     }
 484
 485     // XAccessibleText
 486     sal_Int32 SAL_CALL AccessibleStaticTextBase::getCaretPosition()
 487     {
 488         SolarMutexGuard aGuard;
 489
 490         sal_Int32 i, nPos, nParas;
 491         for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
 492         {
 493             if( (nPos=mpImpl->GetParagraph(i).getCaretPosition()) != -1 )
 494                 return nPos;
 495         }
 496
 497         return nPos;
 498     }
 499
 500     sal_Bool SAL_CALL AccessibleStaticTextBase::setCaretPosition( sal_Int32 nIndex )
 501     {
 502         return setSelection(nIndex, nIndex);
 503     }
 504
 505     sal_Unicode SAL_CALL AccessibleStaticTextBase::getCharacter( sal_Int32 nIndex )
 506     {
 507         SolarMutexGuard aGuard;
 508
 509         EPosition aPos( mpImpl->Index2Internal(nIndex) );
 510
 511         return mpImpl->GetParagraph( aPos.nPara ).getCharacter( aPos.nIndex );
 512     }
 513
 514     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getCharacterAttributes( sal_Int32 nIndex, const css::uno::Sequence< OUString >& aRequestedAttributes )
 515     {
 516         SolarMutexGuard aGuard;
 517
 518         //get the actual index without "\n"
 519         mpImpl->RemoveLineBreakCount( nIndex );
 520
 521         EPosition aPos( mpImpl->Index2Internal(nIndex) );
 522
 523         return mpImpl->GetParagraph( aPos.nPara ).getCharacterAttributes( aPos.nIndex, aRequestedAttributes );
 524     }
 525
 526     awt::Rectangle SAL_CALL AccessibleStaticTextBase::getCharacterBounds( sal_Int32 nIndex )
 527     {
 528         SolarMutexGuard aGuard;
 529
 530         // #108900# Allow ranges for nIndex, as one-past-the-end
 531         // values are now legal, too.
 532         EPosition aPos( mpImpl->Range2Internal(nIndex) );
 533
 534         // #i70916# Text in spread sheet cells return the wrong extents
 535         AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( aPos.nPara );
 536         awt::Rectangle aParaBounds( rPara.getBounds() );
 537         awt::Rectangle aBounds( rPara.getCharacterBounds( aPos.nIndex ) );
 538         aBounds.X += aParaBounds.X;
 539         aBounds.Y += aParaBounds.Y;
 540
 541         return aBounds;
 542     }
 543
 544     sal_Int32 SAL_CALL AccessibleStaticTextBase::getCharacterCount()
 545     {
 546         SolarMutexGuard aGuard;
 547
 548         sal_Int32 i, nCount, nParas;
 549         for( i=0, nCount=0, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
 550             nCount += mpImpl->GetParagraph(i).getCharacterCount();
 551         //count on the number of "\n" which equals number of paragraphs decrease 1.
 552         nCount = nCount + (nParas-1);
 553         return nCount;
 554     }
 555
 556     sal_Int32 SAL_CALL AccessibleStaticTextBase::getIndexAtPoint( const awt::Point& rPoint )
 557     {
 558         SolarMutexGuard aGuard;
 559
 560         const sal_Int32 nParas( mpImpl->GetParagraphCount() );
 561         sal_Int32 nIndex;
 562         int i;
 563         for( i=0; i<nParas; ++i )
 564         {
 565             // TODO: maybe exploit the fact that paragraphs are
 566             // ordered vertically for early exit
 567
 568             // #i70916# Text in spread sheet cells return the wrong extents
 569             AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( i );
 570             awt::Rectangle aParaBounds( rPara.getBounds() );
 571             awt::Point aPoint( rPoint );
 572             aPoint.X -= aParaBounds.X;
 573             aPoint.Y -= aParaBounds.Y;
 574
 575             // #112814# Use correct index offset
 576             if ( ( nIndex = rPara.getIndexAtPoint( aPoint ) ) != -1 )
 577                 return mpImpl->Internal2Index(EPosition(i, nIndex));
 578         }
 579
 580         return -1;
 581     }
 582
 583     OUString SAL_CALL AccessibleStaticTextBase::getSelectedText()
 584     {
 585         SolarMutexGuard aGuard;
 586
 587         sal_Int32 nStart( getSelectionStart() );
 588         sal_Int32 nEnd( getSelectionEnd() );
 589
 590         // #104481# Return the empty string for 'no selection'
 591         if( nStart < 0 || nEnd < 0 )
 592             return OUString();
 593
 594         return getTextRange( nStart, nEnd );
 595     }
 596
 597     sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionStart()
 598     {
 599         SolarMutexGuard aGuard;
 600
 601         sal_Int32 i, nPos, nParas;
 602         for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
 603         {
 604             if( (nPos=mpImpl->GetParagraph(i).getSelectionStart()) != -1 )
 605                 return nPos;
 606         }
 607
 608         return nPos;
 609     }
 610
 611     sal_Int32 SAL_CALL AccessibleStaticTextBase::getSelectionEnd()
 612     {
 613         SolarMutexGuard aGuard;
 614
 615         sal_Int32 i, nPos, nParas;
 616         for( i=0, nPos=-1, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
 617         {
 618             if( (nPos=mpImpl->GetParagraph(i).getSelectionEnd()) != -1 )
 619                 return nPos;
 620         }
 621
 622         return nPos;
 623     }
 624
 625     sal_Bool SAL_CALL AccessibleStaticTextBase::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 626     {
 627         SolarMutexGuard aGuard;
 628
 629         EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
 630         EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
 631
 632         return mpImpl->SetSelection( aStartIndex.nPara, aStartIndex.nIndex,
 633                                      aEndIndex.nPara, aEndIndex.nIndex );
 634     }
 635
 636     OUString SAL_CALL AccessibleStaticTextBase::getText()
 637     {
 638         SolarMutexGuard aGuard;
 639
 640         sal_Int32 i, nParas;
 641         OUStringBuffer aRes;
 642         for( i=0, nParas=mpImpl->GetParagraphCount(); i<nParas; ++i )
 643             aRes.append(mpImpl->GetParagraph(i).getText());
 644
 645         return aRes.makeStringAndClear();
 646     }
 647
 648     OUString SAL_CALL AccessibleStaticTextBase::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 649     {
 650         SolarMutexGuard aGuard;
 651
 652         if( nStartIndex > nEndIndex )
 653             std::swap(nStartIndex, nEndIndex);
 654         //if startindex equals endindex we will get nothing. So return an empty string directly.
 655         if ( nStartIndex == nEndIndex )
 656         {
 657             return OUString();
 658         }
 659         bool bStart = mpImpl->RemoveLineBreakCount( nStartIndex );
 660         //if the start index is just at a "\n", we need to begin from the next char
 661         if ( bStart )
 662         {
 663             nStartIndex++;
 664         }
 665         //we need to find out whether the previous position of the current endindex is at "\n" or not
 666         //if yes we need to mark it and add "\n" at the end of the result
 667         sal_Int32 nTemp = nEndIndex - 1;
 668         bool bEnd = mpImpl->RemoveLineBreakCount( nTemp );
 669         bool bTemp = mpImpl->RemoveLineBreakCount( nEndIndex );
 670         //if the below condition is true it indicates an empty paragraph with just a "\n"
 671         //so we need to set one "\n" flag to avoid duplication.
 672         if ( bStart && bEnd && ( nStartIndex == nEndIndex) )
 673         {
 674             bEnd = false;
 675         }
 676         //if the current endindex is at a "\n", we need to increase endindex by 1 to make sure
 677         //the char before "\n" is included. Because string returned by this function will not include
 678         //the char at the endindex.
 679         if ( bTemp )
 680         {
 681             nEndIndex++;
 682         }
 683         OUStringBuffer aRes;
 684         EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
 685         EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
 686
 687         // #102170# Special case: start and end paragraph are identical
 688         if( aStartIndex.nPara == aEndIndex.nPara )
 689         {
 690             //we don't return the string directly now for that we have to do some further process for "\n"
 691             aRes = mpImpl->GetParagraph( aStartIndex.nPara ).getTextRange( aStartIndex.nIndex, aEndIndex.nIndex );
 692         }
 693         else
 694         {
 695             sal_Int32 i( aStartIndex.nPara );
 696             aRes = mpImpl->GetParagraph(i).getTextRange( aStartIndex.nIndex,
 697                                                          mpImpl->GetParagraph(i).getCharacterCount()/*-1*/);
 698             ++i;
 699
 700             // paragraphs inbetween are fully included
 701             for( ; i<aEndIndex.nPara; ++i )
 702             {
 703                 aRes.append(cNewLine);
 704                 aRes.append(mpImpl->GetParagraph(i).getText());
 705             }
 706
 707             if( i<=aEndIndex.nPara )
 708             {
 709                 //if the below condition is matched it means that endindex is at mid of the last paragraph
 710                 //we need to add a "\n" before we add the last part of the string.
 711                 if ( !bEnd && aEndIndex.nIndex )
 712                 {
 713                     aRes.append(cNewLine);
 714                 }
 715                 aRes.append(mpImpl->GetParagraph(i).getTextRange( 0, aEndIndex.nIndex ));
 716             }
 717         }
 718         //According to the flag we marked before, we have to add "\n" at the beginning
 719         //or at the end of the result string.
 720         if ( bStart )
 721         {
 722             aRes.insert(0, OUStringChar(cNewLine));
 723         }
 724         if ( bEnd )
 725         {
 726             aRes.append(OUStringChar(cNewLine));
 727         }
 728         return aRes.makeStringAndClear();
 729     }
 730
 731     css::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
 732     {
 733         SolarMutexGuard aGuard;
 734
 735         bool bLineBreak = mpImpl->RemoveLineBreakCount( nIndex );
 736         EPosition aPos( mpImpl->Range2Internal(nIndex) );
 737
 738         css::accessibility::TextSegment aResult;
 739
 740         if( AccessibleTextType::PARAGRAPH == aTextType )
 741         {
 742             // #106393# Special casing one behind last paragraph is
 743             // not necessary, since then, we return the content and
 744             // boundary of that last paragraph. Range2Internal is
 745             // tolerant against that, and returns the last paragraph
 746             // in aPos.nPara.
 747
 748             // retrieve full text of the paragraph
 749             aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara ).getText();
 750
 751             // #112814# Adapt the start index with the paragraph offset
 752             aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara, 0 ) );
 753             aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
 754         }
 755         else if ( AccessibleTextType::ATTRIBUTE_RUN == aTextType )
 756         {
 757               SvxAccessibleTextAdapter& rTextForwarder = mpImpl->GetParagraph( aPos.nIndex ).GetTextForwarder();
 758               sal_Int32 nStartIndex, nEndIndex;
 759               if ( rTextForwarder.GetAttributeRun( nStartIndex, nEndIndex, aPos.nPara, aPos.nIndex, true ) )
 760               {
 761                      aResult.SegmentText = getTextRange( nStartIndex, nEndIndex );
 762                      aResult.SegmentStart = nStartIndex;
 763                      aResult.SegmentEnd = nEndIndex;
 764               }
 765         }
 766         else
 767         {
 768             // No special handling required, forward to wrapped class
 769             aResult = mpImpl->GetParagraph( aPos.nPara ).getTextAtIndex( aPos.nIndex, aTextType );
 770
 771             // #112814# Adapt the start index with the paragraph offset
 772             mpImpl->CorrectTextSegment( aResult, aPos.nPara );
 773             if ( bLineBreak )
 774             {
 775                 aResult.SegmentText = OUString(cNewLine);
 776             }
 777         }
 778
 779         return aResult;
 780     }
 781
 782     css::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
 783     {
 784         SolarMutexGuard aGuard;
 785
 786         sal_Int32 nOldIdx = nIndex;
 787         bool bLineBreak =  mpImpl->RemoveLineBreakCount( nIndex );
 788         EPosition aPos( mpImpl->Range2Internal(nIndex) );
 789
 790         css::accessibility::TextSegment aResult;
 791
 792         if( AccessibleTextType::PARAGRAPH == aTextType )
 793         {
 794             if( aPos.nIndex == mpImpl->GetParagraph( aPos.nPara ).getCharacterCount() )
 795             {
 796                 // #103589# Special casing one behind the last paragraph
 797                 aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara ).getText();
 798
 799                 // #112814# Adapt the start index with the paragraph offset
 800                 aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara, 0 ) );
 801             }
 802             else if( aPos.nPara > 0 )
 803             {
 804                 aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara - 1 ).getText();
 805
 806                 // #112814# Adapt the start index with the paragraph offset
 807                 aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara - 1, 0 ) );
 808             }
 809
 810             aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
 811         }
 812         else
 813         {
 814             // No special handling required, forward to wrapped class
 815             aResult = mpImpl->GetParagraph( aPos.nPara ).getTextBeforeIndex( aPos.nIndex, aTextType );
 816
 817             // #112814# Adapt the start index with the paragraph offset
 818             mpImpl->CorrectTextSegment( aResult, aPos.nPara );
 819             if ( bLineBreak && (nOldIdx-1) >= 0)
 820             {
 821                 aResult = getTextAtIndex( nOldIdx-1, aTextType );
 822             }
 823         }
 824
 825         return aResult;
 826     }
 827
 828     css::accessibility::TextSegment SAL_CALL AccessibleStaticTextBase::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
 829     {
 830         SolarMutexGuard aGuard;
 831
 832         sal_Int32 nTemp = nIndex+1;
 833         bool bLineBreak = mpImpl->RemoveLineBreakCount( nTemp );
 834         mpImpl->RemoveLineBreakCount( nIndex );
 835         EPosition aPos( mpImpl->Range2Internal(nIndex) );
 836
 837         css::accessibility::TextSegment aResult;
 838
 839         if( AccessibleTextType::PARAGRAPH == aTextType )
 840         {
 841             // Special casing one behind the last paragraph is not
 842             // necessary, this case is invalid here for
 843             // getTextBehindIndex
 844             if( aPos.nPara + 1 < mpImpl->GetParagraphCount() )
 845             {
 846                 aResult.SegmentText = mpImpl->GetParagraph( aPos.nPara + 1 ).getText();
 847
 848                 // #112814# Adapt the start index with the paragraph offset
 849                 aResult.SegmentStart = mpImpl->Internal2Index( EPosition( aPos.nPara + 1, 0 ) );
 850                 aResult.SegmentEnd = aResult.SegmentStart + aResult.SegmentText.getLength();
 851             }
 852         }
 853         else
 854         {
 855             // No special handling required, forward to wrapped class
 856             aResult = mpImpl->GetParagraph( aPos.nPara ).getTextBehindIndex( aPos.nIndex, aTextType );
 857
 858             // #112814# Adapt the start index with the paragraph offset
 859             mpImpl->CorrectTextSegment( aResult, aPos.nPara );
 860             if ( bLineBreak )
 861             {
 862                 aResult.SegmentText = OUStringChar(cNewLine) + aResult.SegmentText;
 863             }
 864        }
 865
 866         return aResult;
 867     }
 868
 869     sal_Bool SAL_CALL AccessibleStaticTextBase::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 870     {
 871         SolarMutexGuard aGuard;
 872
 873         if( nStartIndex > nEndIndex )
 874             std::swap(nStartIndex, nEndIndex);
 875
 876         EPosition aStartIndex( mpImpl->Range2Internal(nStartIndex) );
 877         EPosition aEndIndex( mpImpl->Range2Internal(nEndIndex) );
 878
 879         return mpImpl->CopyText( aStartIndex.nPara, aStartIndex.nIndex,
 880                                  aEndIndex.nPara, aEndIndex.nIndex );
 881     }
 882
 883     // XAccessibleTextAttributes
 884     uno::Sequence< beans::PropertyValue > AccessibleStaticTextBase::getDefaultAttributes( const uno::Sequence< OUString >& RequestedAttributes )
 885     {
 886         // get the intersection of the default attributes of all paragraphs
 887
 888         SolarMutexGuard aGuard;
 889
 890         PropertyValueVector aDefAttrVec(
 891                 comphelper::sequenceToContainer<PropertyValueVector>(mpImpl->GetParagraph( 0 ).getDefaultAttributes( RequestedAttributes )) );
 892
 893         const sal_Int32 nParaCount = mpImpl->GetParagraphCount();
 894         for ( sal_Int32 nPara = 1; nPara < nParaCount; ++nPara )
 895         {
 896             uno::Sequence< beans::PropertyValue > aSeq = mpImpl->GetParagraph( nPara ).getDefaultAttributes( RequestedAttributes );
 897             PropertyValueVector aIntersectionVec;
 898
 899             for ( const auto& rDefAttr : aDefAttrVec )
 900             {
 901                 const beans::PropertyValue* pItr = aSeq.getConstArray();
 902                 const beans::PropertyValue* pEnd  = pItr + aSeq.getLength();
 903                 const beans::PropertyValue* pFind = std::find_if( pItr, pEnd, PropertyValueEqualFunctor(rDefAttr) );
 904                 if ( pFind != pEnd )
 905                 {
 906                     aIntersectionVec.push_back( *pFind );
 907                 }
 908             }
 909
 910             aDefAttrVec.swap( aIntersectionVec );
 911
 912             if ( aDefAttrVec.empty() )
 913             {
 914                 break;
 915             }
 916         }
 917
 918         return comphelper::containerToSequence(aDefAttrVec);
 919     }
 920
 921     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleStaticTextBase::getRunAttributes( sal_Int32 nIndex, const uno::Sequence< OUString >& RequestedAttributes )
 922     {
 923         // get those default attributes of the paragraph, which are not part
 924         // of the intersection of all paragraphs and add them to the run attributes
 925
 926         SolarMutexGuard aGuard;
 927
 928         EPosition aPos( mpImpl->Index2Internal( nIndex ) );
 929         AccessibleEditableTextPara& rPara = mpImpl->GetParagraph( aPos.nPara );
 930         uno::Sequence< beans::PropertyValue > aDefAttrSeq = rPara.getDefaultAttributes( RequestedAttributes );
 931         uno::Sequence< beans::PropertyValue > aRunAttrSeq = rPara.getRunAttributes( aPos.nIndex, RequestedAttributes );
 932         uno::Sequence< beans::PropertyValue > aIntersectionSeq = getDefaultAttributes( RequestedAttributes );
 933         PropertyValueVector aDiffVec;
 934
 935         const beans::PropertyValue* pDefAttr = aDefAttrSeq.getConstArray();
 936         const sal_Int32 nLength = aDefAttrSeq.getLength();
 937         for ( sal_Int32 i = 0; i < nLength; ++i )
 938         {
 939             const beans::PropertyValue* pItr = aIntersectionSeq.getConstArray();
 940             const beans::PropertyValue* pEnd  = pItr + aIntersectionSeq.getLength();
 941             bool bNone = std::none_of( pItr, pEnd, PropertyValueEqualFunctor( pDefAttr[i] ) );
 942             if ( bNone && pDefAttr[i].Handle != 0)
 943             {
 944                 aDiffVec.push_back( pDefAttr[i] );
 945             }
 946         }
 947
 948         return ::comphelper::concatSequences( aRunAttrSeq, comphelper::containerToSequence(aDiffVec) );
 949     }
 950
 951     tools::Rectangle AccessibleStaticTextBase::GetParagraphBoundingBox() const
 952     {
 953         return mpImpl->GetParagraphBoundingBox();
 954     }
 955
 956 }  // end of namespace accessibility
 957
 958
 959 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */