svx/source/accessibility/AccessibleStaticTextBase.cxx

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