svx/source/accessibility/AccessibleEditableTextPara.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: AccessibleEditableTextPara.cxx,v $
  10  * $Revision: 1.53 $
  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 <vos/mutex.hxx>
  44 #include <vcl/window.hxx>
  45 #include <vcl/svapp.hxx>
  46 #include <com/sun/star/uno/Any.hxx>
  47 #include <com/sun/star/uno/Reference.hxx>
  48 #include <com/sun/star/awt/Point.hpp>
  49 #include <com/sun/star/awt/Rectangle.hpp>
  50 #include <com/sun/star/lang/DisposedException.hpp>
  51 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  52 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
  53 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  54 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  55 #include <comphelper/accessibleeventnotifier.hxx>
  56 #include <comphelper/sequenceashashmap.hxx>
  57 #include <unotools/accessiblestatesethelper.hxx>
  58
  59 // --> OD 2006-01-11 #i27138#
  60 #include <unotools/accessiblerelationsethelper.hxx>
  61 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  62 // <--
  63 #include <vcl/unohelp.hxx>
  64
  65 //------------------------------------------------------------------------
  66 //
  67 // Project-local header
  68 //
  69 //------------------------------------------------------------------------
  70
  71 #include <com/sun/star/beans/PropertyState.hpp>
  72 #include <svx/unoshape.hxx>
  73 #include "unolingu.hxx"
  74 #include "unopracc.hxx"
  75 #include "AccessibleEditableTextPara.hxx"
  76 #include <svx/dialmgr.hxx>
  77
  78 #include "accessibility.hrc"
  79 #include <svtools/colorcfg.hxx>
  80
  81
  82 using namespace ::com::sun::star;
  83 using namespace ::com::sun::star::beans;
  84 using namespace ::com::sun::star::accessibility;
  85
  86
  87 //------------------------------------------------------------------------
  88 //
  89 // AccessibleEditableTextPara implementation
  90 //
  91 //------------------------------------------------------------------------
  92
  93 namespace accessibility
  94 {
  95
  96     const SvxItemPropertySet* ImplGetSvxCharAndParaPropertiesSet()
  97     {
  98         // PropertyMap for character and paragraph properties
  99         static const SfxItemPropertyMapEntry aPropMap[] =
 100         {
 101             SVX_UNOEDIT_CHAR_PROPERTIES,
 102             SVX_UNOEDIT_PARA_PROPERTIES,
 103             SVX_UNOEDIT_NUMBERING_PROPERTIE,
 104             {MAP_CHAR_LEN("TextUserDefinedAttributes"),     EE_CHAR_XMLATTRIBS,     &::getCppuType((const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameContainer >*)0)  ,        0,     0},
 105             {MAP_CHAR_LEN("ParaUserDefinedAttributes"),     EE_PARA_XMLATTRIBS,     &::getCppuType((const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameContainer >*)0)  ,        0,     0},
 106             {0,0,0,0,0,0}
 107         };
 108         static SvxItemPropertySet aPropSet( aPropMap );
 109         return &aPropSet;
 110     }
 111
 112
 113     DBG_NAME( AccessibleEditableTextPara )
 114
 115     // --> OD 2006-01-11 #i27138# - add parameter <_pParaManager>
 116     AccessibleEditableTextPara::AccessibleEditableTextPara(
 117                                 const uno::Reference< XAccessible >& rParent,
 118                                 const AccessibleParaManager* _pParaManager )
 119         : AccessibleTextParaInterfaceBase( m_aMutex ),
 120           mnParagraphIndex( 0 ),
 121           mnIndexInParent( 0 ),
 122           mpEditSource( NULL ),
 123           maEEOffset( 0, 0 ),
 124           mxParent( rParent ),
 125           // well, that's strictly (UNO) exception safe, though not
 126           // really robust. We rely on the fact that this member is
 127           // constructed last, and that the constructor body catches
 128           // exceptions, thus no chance for exceptions once the Id is
 129           // fetched. Nevertheless, normally should employ RAII here...
 130           mnNotifierClientId(::comphelper::AccessibleEventNotifier::registerClient()),
 131           // --> OD 2006-01-11 #i27138#
 132           mpParaManager( _pParaManager )
 133           // <--
 134     {
 135 #ifdef DBG_UTIL
 136         DBG_CTOR( AccessibleEditableTextPara, NULL );
 137         OSL_TRACE( "AccessibleEditableTextPara received ID: %d\n", mnNotifierClientId );
 138 #endif
 139
 140         try
 141         {
 142             // Create the state set.
 143             ::utl::AccessibleStateSetHelper* pStateSet  = new ::utl::AccessibleStateSetHelper ();
 144             mxStateSet = pStateSet;
 145
 146             // these are always on
 147             pStateSet->AddState( AccessibleStateType::MULTI_LINE );
 148             pStateSet->AddState( AccessibleStateType::FOCUSABLE );
 149             pStateSet->AddState( AccessibleStateType::VISIBLE );
 150             pStateSet->AddState( AccessibleStateType::SHOWING );
 151             pStateSet->AddState( AccessibleStateType::ENABLED );
 152             pStateSet->AddState( AccessibleStateType::SENSITIVE );
 153         }
 154         catch( const uno::Exception& ) {}
 155     }
 156
 157     AccessibleEditableTextPara::~AccessibleEditableTextPara()
 158     {
 159         DBG_DTOR( AccessibleEditableTextPara, NULL );
 160
 161         // sign off from event notifier
 162         if( getNotifierClientId() != -1 )
 163         {
 164             try
 165             {
 166                 ::comphelper::AccessibleEventNotifier::revokeClient( getNotifierClientId() );
 167 #ifdef DBG_UTIL
 168                 OSL_TRACE( "AccessibleEditableTextPara revoked ID: %d\n", mnNotifierClientId );
 169 #endif
 170             }
 171             catch( const uno::Exception& ) {}
 172         }
 173     }
 174
 175     ::rtl::OUString AccessibleEditableTextPara::implGetText()
 176     {
 177         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 178
 179         return GetTextRange( 0, GetTextLen() );
 180     }
 181
 182     ::com::sun::star::lang::Locale AccessibleEditableTextPara::implGetLocale()
 183     {
 184         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 185
 186         lang::Locale            aLocale;
 187
 188         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
 189                    "AccessibleEditableTextPara::getLocale: paragraph index value overflow");
 190
 191         // return locale of first character in the paragraph
 192         return SvxLanguageToLocale(aLocale, GetTextForwarder().GetLanguage( static_cast< USHORT >( GetParagraphIndex() ), 0 ));
 193     }
 194
 195     void AccessibleEditableTextPara::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 196     {
 197         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 198
 199         USHORT nStart, nEnd;
 200
 201         if( GetSelection( nStart, nEnd ) )
 202         {
 203             nStartIndex = nStart;
 204             nEndIndex = nEnd;
 205         }
 206         else
 207         {
 208             // #102234# No exception, just set to 'invalid'
 209             nStartIndex = -1;
 210             nEndIndex = -1;
 211         }
 212     }
 213
 214     void AccessibleEditableTextPara::implGetParagraphBoundary( ::com::sun::star::i18n::Boundary& rBoundary, sal_Int32 /*nIndex*/ )
 215     {
 216         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 217         DBG_WARNING( "AccessibleEditableTextPara::implGetParagraphBoundary: only a base implementation, ignoring the index" );
 218
 219         rBoundary.startPos = 0;
 220         rBoundary.endPos = GetTextLen();
 221     }
 222
 223     void AccessibleEditableTextPara::implGetLineBoundary( ::com::sun::star::i18n::Boundary& rBoundary, sal_Int32 nIndex )
 224     {
 225         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 226
 227         SvxTextForwarder&       rCacheTF = GetTextForwarder();
 228         const sal_Int32         nParaIndex = GetParagraphIndex();
 229
 230         DBG_ASSERT(nParaIndex >= 0 && nParaIndex <= USHRT_MAX,
 231                    "AccessibleEditableTextPara::implGetLineBoundary: paragraph index value overflow");
 232
 233         const sal_Int32 nTextLen = rCacheTF.GetTextLen( static_cast< USHORT >( nParaIndex ) );
 234
 235         CheckPosition(nIndex);
 236
 237         rBoundary.startPos = rBoundary.endPos = -1;
 238
 239         const USHORT nLineCount=rCacheTF.GetLineCount( static_cast< USHORT >( nParaIndex ) );
 240
 241         if( nIndex == nTextLen )
 242         {
 243             // #i17014# Special-casing one-behind-the-end character
 244             if( nLineCount <= 1 )
 245                 rBoundary.startPos = 0;
 246             else
 247                 rBoundary.startPos = nTextLen - rCacheTF.GetLineLen( static_cast< USHORT >( nParaIndex ),
 248                                                                      nLineCount-1 );
 249
 250             rBoundary.endPos = nTextLen;
 251         }
 252         else
 253         {
 254             // normal line search
 255             USHORT nLine;
 256             sal_Int32 nCurIndex;
 257             for( nLine=0, nCurIndex=0; nLine<nLineCount; ++nLine )
 258             {
 259                 nCurIndex += rCacheTF.GetLineLen( static_cast< USHORT >( nParaIndex ), nLine);
 260
 261                 if( nCurIndex > nIndex )
 262                 {
 263                     rBoundary.startPos = nCurIndex - rCacheTF.GetLineLen(static_cast< USHORT >( nParaIndex ), nLine);
 264                     rBoundary.endPos = nCurIndex;
 265                     break;
 266                 }
 267             }
 268         }
 269     }
 270
 271     int AccessibleEditableTextPara::getNotifierClientId() const
 272     {
 273         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 274
 275         return mnNotifierClientId;
 276     }
 277
 278     void AccessibleEditableTextPara::SetIndexInParent( sal_Int32 nIndex )
 279     {
 280         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 281
 282         mnIndexInParent = nIndex;
 283     }
 284
 285     sal_Int32 AccessibleEditableTextPara::GetIndexInParent() const
 286     {
 287         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 288
 289         return mnIndexInParent;
 290     }
 291
 292     void AccessibleEditableTextPara::SetParagraphIndex( sal_Int32 nIndex )
 293     {
 294         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 295
 296         sal_Int32 nOldIndex = mnParagraphIndex;
 297
 298         mnParagraphIndex = nIndex;
 299
 300         WeakBullet::HardRefType aChild( maImageBullet.get() );
 301         if( aChild.is() )
 302             aChild->SetParagraphIndex(mnParagraphIndex);
 303
 304         try
 305         {
 306             if( nOldIndex != nIndex )
 307             {
 308                 uno::Any aOldDesc;
 309                 uno::Any aOldName;
 310
 311                 try
 312                 {
 313                     aOldDesc <<= getAccessibleDescription();
 314                     aOldName <<= getAccessibleName();
 315                 }
 316                 catch( const uno::Exception& ) {} // optional behaviour
 317                 // index and therefore description changed
 318                 FireEvent( AccessibleEventId::DESCRIPTION_CHANGED, uno::makeAny( getAccessibleDescription() ), aOldDesc );
 319                 FireEvent( AccessibleEventId::NAME_CHANGED, uno::makeAny( getAccessibleName() ), aOldName );
 320             }
 321         }
 322         catch( const uno::Exception& ) {} // optional behaviour
 323     }
 324
 325     sal_Int32 AccessibleEditableTextPara::GetParagraphIndex() const SAL_THROW((uno::RuntimeException))
 326     {
 327         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 328
 329         return mnParagraphIndex;
 330     }
 331
 332     void AccessibleEditableTextPara::Dispose()
 333     {
 334         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 335
 336         int nClientId( getNotifierClientId() );
 337
 338         // #108212# drop all references before notifying dispose
 339         mxParent = NULL;
 340         mnNotifierClientId = -1;
 341         mpEditSource = NULL;
 342
 343         // notify listeners
 344         if( nClientId != -1 )
 345         {
 346             try
 347             {
 348                 uno::Reference < XAccessibleContext > xThis = getAccessibleContext();
 349
 350                 // #106234# Delegate to EventNotifier
 351                 ::comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nClientId, xThis );
 352 #ifdef DBG_UTIL
 353                 OSL_TRACE( "Disposed ID: %d\n", nClientId );
 354 #endif
 355             }
 356             catch( const uno::Exception& ) {}
 357         }
 358     }
 359
 360     void AccessibleEditableTextPara::SetEditSource( SvxEditSourceAdapter* pEditSource )
 361     {
 362         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 363
 364         mpEditSource = pEditSource;
 365
 366         WeakBullet::HardRefType aChild( maImageBullet.get() );
 367         if( aChild.is() )
 368             aChild->SetEditSource(pEditSource);
 369
 370         if( !mpEditSource )
 371         {
 372             // going defunc
 373             UnSetState( AccessibleStateType::SHOWING );
 374             UnSetState( AccessibleStateType::VISIBLE );
 375             SetState( AccessibleStateType::INVALID );
 376             SetState( AccessibleStateType::DEFUNC );
 377
 378             Dispose();
 379         }
 380
 381         // #108900# Init last text content
 382         try
 383         {
 384             TextChanged();
 385         }
 386         catch( const uno::RuntimeException& ) {}
 387     }
 388
 389     ESelection AccessibleEditableTextPara::MakeSelection( sal_Int32 nStartEEIndex, sal_Int32 nEndEEIndex )
 390     {
 391         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 392
 393         // check overflow
 394         DBG_ASSERT(nStartEEIndex >= 0 && nStartEEIndex <= USHRT_MAX &&
 395                    nEndEEIndex >= 0 && nEndEEIndex <= USHRT_MAX &&
 396                    GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
 397                    "AccessibleEditableTextPara::MakeSelection: index value overflow");
 398
 399         USHORT nParaIndex = static_cast< USHORT >( GetParagraphIndex() );
 400         return ESelection( nParaIndex, static_cast< USHORT >( nStartEEIndex ),
 401                            nParaIndex, static_cast< USHORT >( nEndEEIndex ) );
 402     }
 403
 404     ESelection AccessibleEditableTextPara::MakeSelection( sal_Int32 nEEIndex )
 405     {
 406         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 407
 408         return MakeSelection( nEEIndex, nEEIndex+1 );
 409     }
 410
 411     ESelection AccessibleEditableTextPara::MakeCursor( sal_Int32 nEEIndex )
 412     {
 413         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 414
 415         return MakeSelection( nEEIndex, nEEIndex );
 416     }
 417
 418     void AccessibleEditableTextPara::CheckIndex( sal_Int32 nIndex ) SAL_THROW((lang::IndexOutOfBoundsException, uno::RuntimeException))
 419     {
 420         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 421
 422         if( nIndex < 0 || nIndex >= getCharacterCount() )
 423             throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleEditableTextPara: character index out of bounds")),
 424                                                   uno::Reference< uno::XInterface >
 425                                                   ( static_cast< ::cppu::OWeakObject* > (this) ) );     // disambiguate hierarchy
 426     }
 427
 428     void AccessibleEditableTextPara::CheckPosition( sal_Int32 nIndex ) SAL_THROW((lang::IndexOutOfBoundsException, uno::RuntimeException))
 429     {
 430         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 431
 432         if( nIndex < 0 || nIndex > getCharacterCount() )
 433             throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleEditableTextPara: character position out of bounds")),
 434                                                   uno::Reference< uno::XInterface >
 435                                                   ( static_cast< ::cppu::OWeakObject* > (this) ) );     // disambiguate hierarchy
 436     }
 437
 438     void AccessibleEditableTextPara::CheckRange( sal_Int32 nStart, sal_Int32 nEnd ) SAL_THROW((lang::IndexOutOfBoundsException, uno::RuntimeException))
 439     {
 440         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 441
 442         CheckPosition( nStart );
 443         CheckPosition( nEnd );
 444     }
 445
 446     sal_Bool AccessibleEditableTextPara::GetSelection( USHORT& nStartPos, USHORT& nEndPos ) SAL_THROW((uno::RuntimeException))
 447     {
 448         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 449
 450         ESelection aSelection;
 451         USHORT nPara = static_cast< USHORT > ( GetParagraphIndex() );
 452         if( !GetEditViewForwarder().GetSelection( aSelection ) )
 453             return sal_False;
 454
 455         if( aSelection.nStartPara < aSelection.nEndPara )
 456         {
 457             if( aSelection.nStartPara > nPara ||
 458                 aSelection.nEndPara < nPara )
 459                 return sal_False;
 460
 461             if( nPara == aSelection.nStartPara )
 462                 nStartPos = aSelection.nStartPos;
 463             else
 464                 nStartPos = 0;
 465
 466             if( nPara == aSelection.nEndPara )
 467                 nEndPos = aSelection.nEndPos;
 468             else
 469                 nEndPos = GetTextLen();
 470         }
 471         else
 472         {
 473             if( aSelection.nStartPara < nPara ||
 474                 aSelection.nEndPara > nPara )
 475                 return sal_False;
 476
 477             if( nPara == aSelection.nStartPara )
 478                 nStartPos = aSelection.nStartPos;
 479             else
 480                 nStartPos = GetTextLen();
 481
 482             if( nPara == aSelection.nEndPara )
 483                 nEndPos = aSelection.nEndPos;
 484             else
 485                 nEndPos = 0;
 486         }
 487
 488         return sal_True;
 489     }
 490
 491     String AccessibleEditableTextPara::GetText( sal_Int32 nIndex ) SAL_THROW((uno::RuntimeException))
 492     {
 493         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 494
 495         return GetTextForwarder().GetText( MakeSelection(nIndex) );
 496     }
 497
 498     String AccessibleEditableTextPara::GetTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) SAL_THROW((uno::RuntimeException))
 499     {
 500         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 501
 502         return GetTextForwarder().GetText( MakeSelection(nStartIndex, nEndIndex) );
 503     }
 504
 505     USHORT AccessibleEditableTextPara::GetTextLen() const SAL_THROW((uno::RuntimeException))
 506     {
 507         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 508
 509         return GetTextForwarder().GetTextLen( static_cast< USHORT >( GetParagraphIndex() ) );
 510     }
 511
 512     sal_Bool AccessibleEditableTextPara::IsVisible() const
 513     {
 514         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 515
 516         return mpEditSource ? sal_True : sal_False ;
 517     }
 518
 519     uno::Reference< XAccessibleText > AccessibleEditableTextPara::GetParaInterface( sal_Int32 nIndex )
 520     {
 521         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 522
 523         uno::Reference< XAccessible > xParent = getAccessibleParent();
 524         if( xParent.is() )
 525         {
 526             uno::Reference< XAccessibleContext > xParentContext = xParent->getAccessibleContext();
 527             if( xParentContext.is() )
 528             {
 529                 uno::Reference< XAccessible > xPara = xParentContext->getAccessibleChild( nIndex );
 530                 if( xPara.is() )
 531                     return uno::Reference< XAccessibleText > ( xPara, uno::UNO_QUERY );
 532             }
 533         }
 534
 535         return uno::Reference< XAccessibleText >();
 536     }
 537
 538     SvxEditSourceAdapter& AccessibleEditableTextPara::GetEditSource() const SAL_THROW((uno::RuntimeException))
 539     {
 540         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 541
 542         if( mpEditSource )
 543             return *mpEditSource;
 544         else
 545             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No edit source, object is defunct")),
 546                                         uno::Reference< uno::XInterface >
 547                                         ( static_cast< ::cppu::OWeakObject* >
 548                                           ( const_cast< AccessibleEditableTextPara* > (this) ) ) );     // disambiguate hierarchy
 549     }
 550
 551     SvxAccessibleTextAdapter& AccessibleEditableTextPara::GetTextForwarder() const SAL_THROW((uno::RuntimeException))
 552     {
 553         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 554
 555         SvxEditSourceAdapter& rEditSource = GetEditSource();
 556         SvxAccessibleTextAdapter* pTextForwarder = rEditSource.GetTextForwarderAdapter();
 557
 558         if( !pTextForwarder )
 559             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unable to fetch text forwarder, object is defunct")),
 560                                         uno::Reference< uno::XInterface >
 561                                         ( static_cast< ::cppu::OWeakObject* >
 562                                           ( const_cast< AccessibleEditableTextPara* > (this) ) ) );     // disambiguate hierarchy
 563
 564         if( pTextForwarder->IsValid() )
 565             return *pTextForwarder;
 566         else
 567             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Text forwarder is invalid, object is defunct")),
 568                                         uno::Reference< uno::XInterface >
 569                                         ( static_cast< ::cppu::OWeakObject* >
 570                                           ( const_cast< AccessibleEditableTextPara* > (this) ) ) );     // disambiguate hierarchy
 571     }
 572
 573     SvxViewForwarder& AccessibleEditableTextPara::GetViewForwarder() const SAL_THROW((uno::RuntimeException))
 574     {
 575         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 576
 577         SvxEditSource& rEditSource = GetEditSource();
 578         SvxViewForwarder* pViewForwarder = rEditSource.GetViewForwarder();
 579
 580         if( !pViewForwarder )
 581         {
 582             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unable to fetch view forwarder, object is defunct")),
 583                                         uno::Reference< uno::XInterface >
 584                                         ( static_cast< ::cppu::OWeakObject* >
 585                                           ( const_cast< AccessibleEditableTextPara* > (this) ) ) );     // disambiguate hierarchy
 586         }
 587
 588         if( pViewForwarder->IsValid() )
 589             return *pViewForwarder;
 590         else
 591             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("View forwarder is invalid, object is defunct")),
 592                                         uno::Reference< uno::XInterface >
 593                                         ( static_cast< ::cppu::OWeakObject* >
 594                                           ( const_cast< AccessibleEditableTextPara* > (this) )  ) );    // disambiguate hierarchy
 595     }
 596
 597     SvxAccessibleTextEditViewAdapter& AccessibleEditableTextPara::GetEditViewForwarder( sal_Bool bCreate ) const SAL_THROW((uno::RuntimeException))
 598     {
 599         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 600
 601         SvxEditSourceAdapter& rEditSource = GetEditSource();
 602         SvxAccessibleTextEditViewAdapter* pTextEditViewForwarder = rEditSource.GetEditViewForwarderAdapter( bCreate );
 603
 604         if( !pTextEditViewForwarder )
 605         {
 606             if( bCreate )
 607                 throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Unable to fetch view forwarder, object is defunct")),
 608                                             uno::Reference< uno::XInterface >
 609                                             ( static_cast< ::cppu::OWeakObject* >
 610                                               ( const_cast< AccessibleEditableTextPara* > (this) ) ) ); // disambiguate hierarchy
 611             else
 612                 throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No view forwarder, object not in edit mode")),
 613                                             uno::Reference< uno::XInterface >
 614                                             ( static_cast< ::cppu::OWeakObject* >
 615                                               ( const_cast< AccessibleEditableTextPara* > (this) ) ) ); // disambiguate hierarchy
 616         }
 617
 618         if( pTextEditViewForwarder->IsValid() )
 619             return *pTextEditViewForwarder;
 620         else
 621         {
 622             if( bCreate )
 623                 throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("View forwarder is invalid, object is defunct")),
 624                                             uno::Reference< uno::XInterface >
 625                                             ( static_cast< ::cppu::OWeakObject* >
 626                                               ( const_cast< AccessibleEditableTextPara* > (this) )  ) );        // disambiguate hierarchy
 627             else
 628                 throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("View forwarder is invalid, object not in edit mode")),
 629                                             uno::Reference< uno::XInterface >
 630                                             ( static_cast< ::cppu::OWeakObject* >
 631                                               ( const_cast< AccessibleEditableTextPara* > (this) )  ) );        // disambiguate hierarchy
 632         }
 633     }
 634
 635     sal_Bool AccessibleEditableTextPara::HaveEditView() const
 636     {
 637         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 638
 639         SvxEditSource& rEditSource = GetEditSource();
 640         SvxEditViewForwarder* pViewForwarder = rEditSource.GetEditViewForwarder();
 641
 642         if( !pViewForwarder )
 643             return sal_False;
 644
 645         if( !pViewForwarder->IsValid() )
 646             return sal_False;
 647
 648         return sal_True;
 649     }
 650
 651     sal_Bool AccessibleEditableTextPara::HaveChildren()
 652     {
 653         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 654
 655         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
 656                    "AccessibleEditableTextPara::HaveChildren: paragraph index value overflow");
 657
 658         return GetTextForwarder().HaveImageBullet( static_cast< USHORT >(GetParagraphIndex()) );
 659     }
 660
 661     sal_Bool AccessibleEditableTextPara::IsActive() const SAL_THROW((uno::RuntimeException))
 662     {
 663         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 664
 665         SvxEditSource& rEditSource = GetEditSource();
 666         SvxEditViewForwarder* pViewForwarder = rEditSource.GetEditViewForwarder();
 667
 668         if( !pViewForwarder )
 669             return sal_False;
 670
 671         if( pViewForwarder->IsValid() )
 672             return sal_False;
 673         else
 674             return sal_True;
 675     }
 676
 677     Rectangle AccessibleEditableTextPara::LogicToPixel( const Rectangle& rRect, const MapMode& rMapMode, SvxViewForwarder& rForwarder )
 678     {
 679         // convert to screen coordinates
 680         return Rectangle( rForwarder.LogicToPixel( rRect.TopLeft(), rMapMode ),
 681                           rForwarder.LogicToPixel( rRect.BottomRight(), rMapMode ) );
 682     }
 683
 684     const Point& AccessibleEditableTextPara::GetEEOffset() const
 685     {
 686         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 687
 688         return maEEOffset;
 689     }
 690
 691     void AccessibleEditableTextPara::SetEEOffset( const Point& rOffset )
 692     {
 693         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 694
 695         WeakBullet::HardRefType aChild( maImageBullet.get() );
 696         if( aChild.is() )
 697             aChild->SetEEOffset(rOffset);
 698
 699         maEEOffset = rOffset;
 700     }
 701
 702     void AccessibleEditableTextPara::FireEvent(const sal_Int16 nEventId, const uno::Any& rNewValue, const uno::Any& rOldValue) const
 703     {
 704         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 705
 706         uno::Reference < XAccessibleContext > xThis( const_cast< AccessibleEditableTextPara* > (this)->getAccessibleContext() );
 707
 708         AccessibleEventObject aEvent(xThis, nEventId, rNewValue, rOldValue);
 709
 710         // #102261# Call global queue for focus events
 711         if( nEventId == AccessibleEventId::STATE_CHANGED )
 712             vcl::unohelper::NotifyAccessibleStateEventGlobally( aEvent );
 713
 714         // #106234# Delegate to EventNotifier
 715         if( getNotifierClientId() != -1 )
 716             ::comphelper::AccessibleEventNotifier::addEvent( getNotifierClientId(),
 717                                                              aEvent );
 718     }
 719
 720     void AccessibleEditableTextPara::GotPropertyEvent( const uno::Any& rNewValue, const sal_Int16 nEventId ) const
 721     {
 722         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 723
 724         FireEvent( nEventId, rNewValue );
 725     }
 726
 727     void AccessibleEditableTextPara::LostPropertyEvent( const uno::Any& rOldValue, const sal_Int16 nEventId ) const
 728     {
 729         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 730
 731         FireEvent( nEventId, uno::Any(), rOldValue );
 732     }
 733
 734     bool AccessibleEditableTextPara::HasState( const sal_Int16 nStateId )
 735     {
 736         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 737
 738         ::utl::AccessibleStateSetHelper* pStateSet = static_cast< ::utl::AccessibleStateSetHelper*>(mxStateSet.get());
 739         if( pStateSet != NULL )
 740             return pStateSet->contains(nStateId) ? true : false;
 741
 742         return false;
 743     }
 744
 745     void AccessibleEditableTextPara::SetState( const sal_Int16 nStateId )
 746     {
 747         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 748
 749         ::utl::AccessibleStateSetHelper* pStateSet = static_cast< ::utl::AccessibleStateSetHelper*>(mxStateSet.get());
 750         if( pStateSet != NULL &&
 751             !pStateSet->contains(nStateId) )
 752         {
 753             pStateSet->AddState( nStateId );
 754             GotPropertyEvent( uno::makeAny( nStateId ), AccessibleEventId::STATE_CHANGED );
 755         }
 756     }
 757
 758     void AccessibleEditableTextPara::UnSetState( const sal_Int16 nStateId )
 759     {
 760         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 761
 762         ::utl::AccessibleStateSetHelper* pStateSet = static_cast< ::utl::AccessibleStateSetHelper*>(mxStateSet.get());
 763         if( pStateSet != NULL &&
 764             pStateSet->contains(nStateId) )
 765         {
 766             pStateSet->RemoveState( nStateId );
 767             LostPropertyEvent( uno::makeAny( nStateId ), AccessibleEventId::STATE_CHANGED );
 768         }
 769     }
 770
 771     void AccessibleEditableTextPara::TextChanged()
 772     {
 773         ::rtl::OUString aCurrentString( OCommonAccessibleText::getText() );
 774         uno::Any aDeleted;
 775         uno::Any aInserted;
 776         if( OCommonAccessibleText::implInitTextChangedEvent( maLastTextString, aCurrentString,
 777                                                              aDeleted, aInserted) )
 778         {
 779             FireEvent( AccessibleEventId::TEXT_CHANGED, aInserted, aDeleted );
 780             maLastTextString = aCurrentString;
 781         }
 782     }
 783
 784     sal_Bool AccessibleEditableTextPara::GetAttributeRun( USHORT& nStartIndex, USHORT& nEndIndex, sal_Int32 nIndex )
 785     {
 786         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 787
 788         DBG_ASSERT(nIndex >= 0 && nIndex <= USHRT_MAX,
 789                    "AccessibleEditableTextPara::GetAttributeRun: index value overflow");
 790
 791         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
 792                    "AccessibleEditableTextPara::getLocale: paragraph index value overflow");
 793
 794         return GetTextForwarder().GetAttributeRun( nStartIndex,
 795                                                    nEndIndex,
 796                                                    static_cast< USHORT >(GetParagraphIndex()),
 797                                                    static_cast< USHORT >(nIndex) );
 798     }
 799
 800     uno::Any SAL_CALL AccessibleEditableTextPara::queryInterface (const uno::Type & rType) throw (uno::RuntimeException)
 801     {
 802         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 803
 804         uno::Any aRet;
 805
 806         // must provide XAccesibleText by hand, since it comes publicly inherited by XAccessibleEditableText
 807         if ( rType == ::getCppuType((uno::Reference< XAccessibleText > *)0) )
 808         {
 809             uno::Reference< XAccessibleText > aAccText = static_cast< XAccessibleEditableText * >(this);
 810             aRet <<= aAccText;
 811         }
 812         else if ( rType == ::getCppuType((uno::Reference< XAccessibleEditableText > *)0) )
 813         {
 814             uno::Reference< XAccessibleEditableText > aAccEditText = this;
 815             aRet <<= aAccEditText;
 816         }
 817         else
 818         {
 819             aRet = AccessibleTextParaInterfaceBase::queryInterface(rType);
 820         }
 821
 822         return aRet;
 823     }
 824
 825     // XAccessible
 826     uno::Reference< XAccessibleContext > SAL_CALL AccessibleEditableTextPara::getAccessibleContext() throw (uno::RuntimeException)
 827     {
 828         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 829
 830         // We implement the XAccessibleContext interface in the same object
 831         return uno::Reference< XAccessibleContext > ( this );
 832     }
 833
 834     // XAccessibleContext
 835     sal_Int32 SAL_CALL AccessibleEditableTextPara::getAccessibleChildCount() throw (uno::RuntimeException)
 836     {
 837         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 838
 839         ::vos::OGuard aGuard( Application::GetSolarMutex() );
 840
 841         return HaveChildren() ? 1 : 0;
 842     }
 843
 844     uno::Reference< XAccessible > SAL_CALL AccessibleEditableTextPara::getAccessibleChild( sal_Int32 i ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
 845     {
 846         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 847
 848         ::vos::OGuard aGuard( Application::GetSolarMutex() );
 849
 850         if( !HaveChildren() )
 851             throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("No childs available")),
 852                                                   uno::Reference< uno::XInterface >
 853                                                   ( static_cast< ::cppu::OWeakObject* > (this) ) );     // static_cast: disambiguate hierarchy
 854
 855         if( i != 0 )
 856             throw lang::IndexOutOfBoundsException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Invalid child index")),
 857                                                   uno::Reference< uno::XInterface >
 858                                                   ( static_cast< ::cppu::OWeakObject* > (this) ) );     // static_cast: disambiguate hierarchy
 859
 860         WeakBullet::HardRefType aChild( maImageBullet.get() );
 861
 862         if( !aChild.is() )
 863         {
 864             // there is no hard reference available, create object then
 865             AccessibleImageBullet* pChild = new AccessibleImageBullet( uno::Reference< XAccessible >( this ) );
 866             uno::Reference< XAccessible > xChild( static_cast< ::cppu::OWeakObject* > (pChild), uno::UNO_QUERY );
 867
 868             if( !xChild.is() )
 869                 throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Child creation failed")),
 870                                             uno::Reference< uno::XInterface >
 871                                             ( static_cast< ::cppu::OWeakObject* > (this) ) );
 872
 873             aChild = WeakBullet::HardRefType( xChild, pChild );
 874
 875             aChild->SetEditSource( &GetEditSource() );
 876             aChild->SetParagraphIndex( GetParagraphIndex() );
 877             aChild->SetIndexInParent( i );
 878
 879             maImageBullet = aChild;
 880         }
 881
 882         return aChild.getRef();
 883     }
 884
 885     uno::Reference< XAccessible > SAL_CALL AccessibleEditableTextPara::getAccessibleParent() throw (uno::RuntimeException)
 886     {
 887         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 888
 889 #ifdef DBG_UTIL
 890         if( !mxParent.is() )
 891             DBG_TRACE( "AccessibleEditableTextPara::getAccessibleParent: no frontend set, did somebody forgot to call AccessibleTextHelper::SetEventSource()?");
 892 #endif
 893
 894         return mxParent;
 895     }
 896
 897     sal_Int32 SAL_CALL AccessibleEditableTextPara::getAccessibleIndexInParent() throw (uno::RuntimeException)
 898     {
 899         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 900
 901         return mnIndexInParent;
 902     }
 903
 904     sal_Int16 SAL_CALL AccessibleEditableTextPara::getAccessibleRole() throw (uno::RuntimeException)
 905     {
 906         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 907
 908         return AccessibleRole::PARAGRAPH;
 909     }
 910
 911     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getAccessibleDescription() throw (uno::RuntimeException)
 912     {
 913         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 914
 915 //        ::vos::OGuard aGuard( Application::GetSolarMutex() );
 916
 917         return ::rtl::OUString();
 918     }
 919
 920     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getAccessibleName() throw (uno::RuntimeException)
 921     {
 922         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 923
 924 //        ::vos::OGuard aGuard( Application::GetSolarMutex() );
 925
 926         return ::rtl::OUString();
 927     }
 928
 929     uno::Reference< XAccessibleRelationSet > SAL_CALL AccessibleEditableTextPara::getAccessibleRelationSet() throw (uno::RuntimeException)
 930     {
 931         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 932
 933         // --> OD 2006-01-11 #i27138# - provide relations CONTENT_FLOWS_FROM
 934         // and CONTENT_FLOWS_TO
 935         if ( mpParaManager )
 936         {
 937             utl::AccessibleRelationSetHelper* pAccRelSetHelper =
 938                                         new utl::AccessibleRelationSetHelper();
 939             sal_Int32 nMyParaIndex( GetParagraphIndex() );
 940             // relation CONTENT_FLOWS_FROM
 941             if ( nMyParaIndex > 0 &&
 942                  mpParaManager->IsReferencable( nMyParaIndex - 1 ) )
 943             {
 944                 uno::Sequence<uno::Reference<XInterface> > aSequence(1);
 945                 aSequence[0] =
 946                     mpParaManager->GetChild( nMyParaIndex - 1 ).first.get().getRef();
 947                 AccessibleRelation aAccRel( AccessibleRelationType::CONTENT_FLOWS_FROM,
 948                                             aSequence );
 949                 pAccRelSetHelper->AddRelation( aAccRel );
 950             }
 951
 952             // relation CONTENT_FLOWS_TO
 953             if ( (nMyParaIndex + 1) < (sal_Int32)mpParaManager->GetNum() &&
 954                  mpParaManager->IsReferencable( nMyParaIndex + 1 ) )
 955             {
 956                 uno::Sequence<uno::Reference<XInterface> > aSequence(1);
 957                 aSequence[0] =
 958                     mpParaManager->GetChild( nMyParaIndex + 1 ).first.get().getRef();
 959                 AccessibleRelation aAccRel( AccessibleRelationType::CONTENT_FLOWS_TO,
 960                                             aSequence );
 961                 pAccRelSetHelper->AddRelation( aAccRel );
 962             }
 963
 964             return pAccRelSetHelper;
 965         }
 966         else
 967         {
 968             // no relations, therefore empty
 969             return uno::Reference< XAccessibleRelationSet >();
 970         }
 971         // <--
 972     }
 973
 974     uno::Reference< XAccessibleStateSet > SAL_CALL AccessibleEditableTextPara::getAccessibleStateSet() throw (uno::RuntimeException)
 975     {
 976         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 977
 978         ::vos::OGuard aGuard( Application::GetSolarMutex() );
 979
 980         // Create a copy of the state set and return it.
 981         ::utl::AccessibleStateSetHelper* pStateSet = static_cast< ::utl::AccessibleStateSetHelper*>(mxStateSet.get());
 982
 983         if( !pStateSet )
 984             return uno::Reference<XAccessibleStateSet>();
 985
 986         return uno::Reference<XAccessibleStateSet>( new ::utl::AccessibleStateSetHelper (*pStateSet) );
 987     }
 988
 989     lang::Locale SAL_CALL AccessibleEditableTextPara::getLocale() throw (IllegalAccessibleComponentStateException, uno::RuntimeException)
 990     {
 991         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
 992
 993         ::vos::OGuard aGuard( Application::GetSolarMutex() );
 994
 995         return implGetLocale();
 996     }
 997
 998     void SAL_CALL AccessibleEditableTextPara::addEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException)
 999     {
1000         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1001
1002         if( getNotifierClientId() != -1 )
1003             ::comphelper::AccessibleEventNotifier::addEventListener( getNotifierClientId(), xListener );
1004     }
1005
1006     void SAL_CALL AccessibleEditableTextPara::removeEventListener( const uno::Reference< XAccessibleEventListener >& xListener ) throw (uno::RuntimeException)
1007     {
1008         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1009
1010         if( getNotifierClientId() != -1 )
1011             ::comphelper::AccessibleEventNotifier::removeEventListener( getNotifierClientId(), xListener );
1012     }
1013
1014     // XAccessibleComponent
1015     sal_Bool SAL_CALL AccessibleEditableTextPara::containsPoint( const awt::Point& aTmpPoint ) throw (uno::RuntimeException)
1016     {
1017         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1018
1019         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1020
1021         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1022                    "AccessibleEditableTextPara::contains: index value overflow");
1023
1024         awt::Rectangle aTmpRect = getBounds();
1025         Rectangle aRect( Point(aTmpRect.X, aTmpRect.Y), Size(aTmpRect.Width, aTmpRect.Height) );
1026         Point aPoint( aTmpPoint.X, aTmpPoint.Y );
1027
1028         return aRect.IsInside( aPoint );
1029     }
1030
1031     uno::Reference< XAccessible > SAL_CALL AccessibleEditableTextPara::getAccessibleAtPoint( const awt::Point& _aPoint ) throw (uno::RuntimeException)
1032     {
1033         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1034
1035         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1036
1037         if( HaveChildren() )
1038         {
1039             // #103862# No longer need to make given position relative
1040             Point aPoint( _aPoint.X, _aPoint.Y );
1041
1042             // respect EditEngine offset to surrounding shape/cell
1043             aPoint -= GetEEOffset();
1044
1045             // convert to EditEngine coordinate system
1046             SvxTextForwarder& rCacheTF = GetTextForwarder();
1047             Point aLogPoint( GetViewForwarder().PixelToLogic( aPoint, rCacheTF.GetMapMode() ) );
1048
1049             EBulletInfo aBulletInfo = rCacheTF.GetBulletInfo( static_cast< USHORT > (GetParagraphIndex()) );
1050
1051             if( aBulletInfo.nParagraph != EE_PARA_NOT_FOUND &&
1052                 aBulletInfo.bVisible &&
1053                 aBulletInfo.nType == SVX_NUM_BITMAP )
1054             {
1055                 Rectangle aRect = aBulletInfo.aBounds;
1056
1057                 if( aRect.IsInside( aLogPoint ) )
1058                     return getAccessibleChild(0);
1059             }
1060         }
1061
1062         // no children at all, or none at given position
1063         return uno::Reference< XAccessible >();
1064     }
1065
1066     awt::Rectangle SAL_CALL AccessibleEditableTextPara::getBounds() throw (uno::RuntimeException)
1067     {
1068         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1069
1070         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1071
1072         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1073                    "AccessibleEditableTextPara::getBounds: index value overflow");
1074
1075         SvxTextForwarder& rCacheTF = GetTextForwarder();
1076         Rectangle aRect = rCacheTF.GetParaBounds( static_cast< USHORT >( GetParagraphIndex() ) );
1077
1078         // convert to screen coordinates
1079         Rectangle aScreenRect = AccessibleEditableTextPara::LogicToPixel( aRect,
1080                                                                           rCacheTF.GetMapMode(),
1081                                                                           GetViewForwarder() );
1082
1083         // offset from shape/cell
1084         Point aOffset = GetEEOffset();
1085
1086         return awt::Rectangle( aScreenRect.Left() + aOffset.X(),
1087                                aScreenRect.Top() + aOffset.Y(),
1088                                aScreenRect.GetSize().Width(),
1089                                aScreenRect.GetSize().Height() );
1090     }
1091
1092     awt::Point SAL_CALL AccessibleEditableTextPara::getLocation(  ) throw (uno::RuntimeException)
1093     {
1094         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1095
1096         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1097
1098         awt::Rectangle aRect = getBounds();
1099
1100         return awt::Point( aRect.X, aRect.Y );
1101     }
1102
1103     awt::Point SAL_CALL AccessibleEditableTextPara::getLocationOnScreen(  ) throw (uno::RuntimeException)
1104     {
1105         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1106
1107         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1108
1109         // relate us to parent
1110         uno::Reference< XAccessible > xParent = getAccessibleParent();
1111         if( xParent.is() )
1112         {
1113             uno::Reference< XAccessibleComponent > xParentComponent( xParent, uno::UNO_QUERY );
1114             if( xParentComponent.is() )
1115             {
1116                 awt::Point aRefPoint = xParentComponent->getLocationOnScreen();
1117                 awt::Point aPoint = getLocation();
1118                 aPoint.X += aRefPoint.X;
1119                 aPoint.Y += aRefPoint.Y;
1120
1121                 return aPoint;
1122             }
1123         }
1124
1125         throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Cannot access parent")),
1126                                     uno::Reference< uno::XInterface >
1127                                     ( static_cast< XAccessible* > (this) ) );   // disambiguate hierarchy
1128     }
1129
1130     awt::Size SAL_CALL AccessibleEditableTextPara::getSize(  ) throw (uno::RuntimeException)
1131     {
1132         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1133
1134         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1135
1136         awt::Rectangle aRect = getBounds();
1137
1138         return awt::Size( aRect.Width, aRect.Height );
1139     }
1140
1141     void SAL_CALL AccessibleEditableTextPara::grabFocus(  ) throw (uno::RuntimeException)
1142     {
1143         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1144
1145         // set cursor to this paragraph
1146         setSelection(0,0);
1147     }
1148
1149     sal_Int32 SAL_CALL AccessibleEditableTextPara::getForeground(  ) throw (::com::sun::star::uno::RuntimeException)
1150     {
1151         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1152
1153         // #104444# Added to XAccessibleComponent interface
1154         svtools::ColorConfig aColorConfig;
1155         UINT32 nColor = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor;
1156         return static_cast<sal_Int32>(nColor);
1157     }
1158
1159     sal_Int32 SAL_CALL AccessibleEditableTextPara::getBackground(  ) throw (::com::sun::star::uno::RuntimeException)
1160     {
1161         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1162
1163         // #104444# Added to XAccessibleComponent interface
1164         Color aColor( Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor() );
1165
1166         // the background is transparent
1167         aColor.SetTransparency( 0xFF);
1168
1169         return static_cast<sal_Int32>( aColor.GetColor() );
1170     }
1171
1172     // XAccessibleText
1173     sal_Int32 SAL_CALL AccessibleEditableTextPara::getCaretPosition() throw (uno::RuntimeException)
1174     {
1175         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1176
1177         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1178
1179         if( !HaveEditView() )
1180             return -1;
1181
1182         ESelection aSelection;
1183         if( GetEditViewForwarder().GetSelection( aSelection ) &&
1184             GetParagraphIndex() == aSelection.nEndPara )
1185         {
1186             // caret is always nEndPara,nEndPos
1187             return aSelection.nEndPos;
1188         }
1189
1190         // not within this paragraph
1191         return -1;
1192     }
1193
1194     sal_Bool SAL_CALL AccessibleEditableTextPara::setCaretPosition( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1195     {
1196         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1197
1198         return setSelection(nIndex, nIndex);
1199     }
1200
1201     sal_Unicode SAL_CALL AccessibleEditableTextPara::getCharacter( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1202     {
1203         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1204
1205         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1206
1207         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1208                    "AccessibleEditableTextPara::getCharacter: index value overflow");
1209
1210         return OCommonAccessibleText::getCharacter( nIndex );
1211     }
1212
1213     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleEditableTextPara::getCharacterAttributes( sal_Int32 nIndex, const ::com::sun::star::uno::Sequence< ::rtl::OUString >& rRequestedAttributes ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1214     {
1215         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1216         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1217
1218         CheckIndex(nIndex);     // may throw IndexOutOfBoundsException
1219
1220         // get default attribues...
1221         ::comphelper::SequenceAsHashMap aPropHashMap( getDefaultAttributes( rRequestedAttributes ) );
1222
1223         // ... and override them with the direct attributes from the specific position
1224         uno::Sequence< beans::PropertyValue > aRunAttribs( getRunAttributes( nIndex, rRequestedAttributes ) );
1225         sal_Int32 nRunAttribs = aRunAttribs.getLength();
1226         const beans::PropertyValue *pRunAttrib = aRunAttribs.getConstArray();
1227         for (sal_Int32 k = 0;  k < nRunAttribs;  ++k)
1228         {
1229             const beans::PropertyValue &rRunAttrib = pRunAttrib[k];
1230             aPropHashMap[ rRunAttrib.Name ] = rRunAttrib.Value; //!! should not only be the value !!
1231         }
1232 #ifdef TL_DEBUG
1233         {
1234             uno::Sequence< rtl::OUString > aNames(1);
1235             aNames.getArray()[0] = rtl::OUString::createFromAscii("CharHeight");
1236             const rtl::OUString *pNames = aNames.getConstArray();
1237             const uno::Sequence< beans::PropertyValue > aAttribs( getRunAttributes( nIndex, aNames ) );
1238             const beans::PropertyValue *pAttribs = aAttribs.getConstArray();
1239             double d1 = -1.0;
1240             float  f1 = -1.0;
1241             if (aAttribs.getLength())
1242             {
1243                 uno::Any aAny( pAttribs[0].Value );
1244                 aAny >>= d1;
1245                 aAny >>= f1;
1246             }
1247             int i = 3;
1248         }
1249 #endif
1250
1251         // get resulting sequence
1252         uno::Sequence< beans::PropertyValue > aRes;
1253         aPropHashMap >> aRes;
1254
1255         // since SequenceAsHashMap ignores property handles and property state
1256         // we have to restore the property state here (property handles are
1257         // of no use to the accessibility API).
1258         sal_Int32 nRes = aRes.getLength();
1259         beans::PropertyValue *pRes = aRes.getArray();
1260         for (sal_Int32 i = 0;  i < nRes;  ++i)
1261         {
1262             beans::PropertyValue &rRes = pRes[i];
1263             sal_Bool bIsDirectVal = sal_False;
1264             for (sal_Int32 k = 0;  k < nRunAttribs && !bIsDirectVal;  ++k)
1265             {
1266                 if (rRes.Name == pRunAttrib[k].Name)
1267                     bIsDirectVal = sal_True;
1268             }
1269             rRes.Handle = -1;
1270             rRes.State  = bIsDirectVal ? PropertyState_DIRECT_VALUE : PropertyState_DEFAULT_VALUE;
1271         }
1272
1273         return aRes;
1274     }
1275
1276     awt::Rectangle SAL_CALL AccessibleEditableTextPara::getCharacterBounds( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1277     {
1278         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1279
1280         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1281
1282         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1283                    "AccessibleEditableTextPara::getCharacterBounds: index value overflow");
1284
1285         // #108900# Have position semantics now for nIndex, as
1286         // one-past-the-end values are legal, too.
1287         CheckPosition( nIndex );
1288
1289         SvxTextForwarder& rCacheTF = GetTextForwarder();
1290         Rectangle aRect = rCacheTF.GetCharBounds( static_cast< USHORT >( GetParagraphIndex() ), static_cast< USHORT >( nIndex ) );
1291
1292         // convert to screen
1293         Rectangle aScreenRect = AccessibleEditableTextPara::LogicToPixel( aRect,
1294                                                                           rCacheTF.GetMapMode(),
1295                                                                           GetViewForwarder() );
1296         // #109864# offset from parent (paragraph), but in screen
1297         // coordinates. This makes sure the internal text offset in
1298         // the outline view forwarder gets cancelled out here
1299         awt::Rectangle aParaRect( getBounds() );
1300         aScreenRect.Move( -aParaRect.X, -aParaRect.Y );
1301
1302         // offset from shape/cell
1303         Point aOffset = GetEEOffset();
1304
1305         return awt::Rectangle( aScreenRect.Left() + aOffset.X(),
1306                                aScreenRect.Top() + aOffset.Y(),
1307                                aScreenRect.GetSize().Width(),
1308                                aScreenRect.GetSize().Height() );
1309     }
1310
1311     sal_Int32 SAL_CALL AccessibleEditableTextPara::getCharacterCount() throw (uno::RuntimeException)
1312     {
1313         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1314
1315         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1316
1317         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1318                    "AccessibleEditableTextPara::getCharacterCount: index value overflow");
1319
1320         return OCommonAccessibleText::getCharacterCount();
1321     }
1322
1323     sal_Int32 SAL_CALL AccessibleEditableTextPara::getIndexAtPoint( const awt::Point& rPoint ) throw (uno::RuntimeException)
1324     {
1325         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1326
1327         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1328
1329         USHORT nPara, nIndex;
1330
1331         // offset from surrounding cell/shape
1332         Point aOffset( GetEEOffset() );
1333         Point aPoint( rPoint.X - aOffset.X(), rPoint.Y - aOffset.Y() );
1334
1335         // convert to logical coordinates
1336         SvxTextForwarder& rCacheTF = GetTextForwarder();
1337         Point aLogPoint( GetViewForwarder().PixelToLogic( aPoint, rCacheTF.GetMapMode() ) );
1338
1339         // re-offset to parent (paragraph)
1340         Rectangle aParaRect = rCacheTF.GetParaBounds( static_cast< USHORT >( GetParagraphIndex() ) );
1341         aLogPoint.Move( aParaRect.Left(), aParaRect.Top() );
1342
1343         if( rCacheTF.GetIndexAtPoint( aLogPoint, nPara, nIndex ) &&
1344             GetParagraphIndex() == nPara )
1345         {
1346             // #102259# Double-check if we're _really_ on the given character
1347             try
1348             {
1349                 awt::Rectangle aRect1( getCharacterBounds(nIndex) );
1350                 Rectangle aRect2( aRect1.X, aRect1.Y,
1351                                   aRect1.Width + aRect1.X, aRect1.Height + aRect1.Y );
1352                 if( aRect2.IsInside( Point( rPoint.X, rPoint.Y ) ) )
1353                     return nIndex;
1354                 else
1355                     return -1;
1356             }
1357             catch( const lang::IndexOutOfBoundsException& )
1358             {
1359                 // #103927# Don't throw for invalid nIndex values
1360                 return -1;
1361             }
1362         }
1363         else
1364         {
1365             // not within our paragraph
1366             return -1;
1367         }
1368     }
1369
1370     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getSelectedText() throw (uno::RuntimeException)
1371     {
1372         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1373
1374         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1375
1376         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1377                    "AccessibleEditableTextPara::getSelectedText: index value overflow");
1378
1379         if( !HaveEditView() )
1380             return ::rtl::OUString();
1381
1382         return OCommonAccessibleText::getSelectedText();
1383     }
1384
1385     sal_Int32 SAL_CALL AccessibleEditableTextPara::getSelectionStart() throw (uno::RuntimeException)
1386     {
1387         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1388
1389         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1390
1391         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1392                    "AccessibleEditableTextPara::getSelectionStart: index value overflow");
1393
1394         if( !HaveEditView() )
1395             return -1;
1396
1397         return OCommonAccessibleText::getSelectionStart();
1398     }
1399
1400     sal_Int32 SAL_CALL AccessibleEditableTextPara::getSelectionEnd() throw (uno::RuntimeException)
1401     {
1402         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1403
1404         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1405
1406         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1407                    "AccessibleEditableTextPara::getSelectionEnd: index value overflow");
1408
1409         if( !HaveEditView() )
1410             return -1;
1411
1412         return OCommonAccessibleText::getSelectionEnd();
1413     }
1414
1415     sal_Bool SAL_CALL AccessibleEditableTextPara::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1416     {
1417         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1418
1419         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1420
1421         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1422                    "AccessibleEditableTextPara::setSelection: paragraph index value overflow");
1423
1424         CheckRange(nStartIndex, nEndIndex);
1425
1426         try
1427         {
1428             SvxEditViewForwarder& rCacheVF = GetEditViewForwarder( sal_True );
1429             return rCacheVF.SetSelection( MakeSelection(nStartIndex, nEndIndex) );
1430         }
1431         catch( const uno::RuntimeException& )
1432         {
1433             return sal_False;
1434         }
1435     }
1436
1437     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getText() throw (uno::RuntimeException)
1438     {
1439         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1440
1441         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1442
1443         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1444                    "AccessibleEditableTextPara::getText: paragraph index value overflow");
1445
1446         return OCommonAccessibleText::getText();
1447     }
1448
1449     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1450     {
1451         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1452
1453         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1454
1455         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1456                    "AccessibleEditableTextPara::getTextRange: paragraph index value overflow");
1457
1458         return OCommonAccessibleText::getTextRange(nStartIndex, nEndIndex);
1459     }
1460
1461     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleEditableTextPara::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
1462     {
1463         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1464
1465         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1466
1467         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1468                    "AccessibleEditableTextPara::getTextAtIndex: paragraph index value overflow");
1469
1470         ::com::sun::star::accessibility::TextSegment aResult;
1471         aResult.SegmentStart = -1;
1472         aResult.SegmentEnd = -1;
1473
1474         switch( aTextType )
1475         {
1476             // Not yet handled by OCommonAccessibleText. Missing
1477             // implGetAttributeRunBoundary() method there
1478             case AccessibleTextType::ATTRIBUTE_RUN:
1479             {
1480                 const sal_Int32 nTextLen = GetTextForwarder().GetTextLen( static_cast< USHORT >( GetParagraphIndex() ) );
1481
1482                 if( nIndex == nTextLen )
1483                 {
1484                     // #i17014# Special-casing one-behind-the-end character
1485                     aResult.SegmentStart = aResult.SegmentEnd = nTextLen;
1486                 }
1487                 else
1488                 {
1489                     USHORT nStartIndex, nEndIndex;
1490
1491                     if( GetAttributeRun(nStartIndex, nEndIndex, nIndex) )
1492                     {
1493                         aResult.SegmentText = GetTextRange(nStartIndex, nEndIndex);
1494                         aResult.SegmentStart = nStartIndex;
1495                         aResult.SegmentEnd = nEndIndex;
1496                     }
1497                 }
1498                 break;
1499             }
1500
1501             default:
1502                 aResult = OCommonAccessibleText::getTextAtIndex( nIndex, aTextType );
1503                 break;
1504         } /* end of switch( aTextType ) */
1505
1506         return aResult;
1507     }
1508
1509     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleEditableTextPara::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
1510     {
1511         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1512
1513         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1514
1515         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1516                    "AccessibleEditableTextPara::getTextBeforeIndex: paragraph index value overflow");
1517
1518         ::com::sun::star::accessibility::TextSegment aResult;
1519         aResult.SegmentStart = -1;
1520         aResult.SegmentEnd = -1;
1521
1522         switch( aTextType )
1523         {
1524             // Not yet handled by OCommonAccessibleText. Missing
1525             // implGetAttributeRunBoundary() method there
1526             case AccessibleTextType::ATTRIBUTE_RUN:
1527             {
1528                 const sal_Int32 nTextLen = GetTextForwarder().GetTextLen( static_cast< USHORT >( GetParagraphIndex() ) );
1529                 USHORT nStartIndex, nEndIndex;
1530
1531                 if( nIndex == nTextLen )
1532                 {
1533                     // #i17014# Special-casing one-behind-the-end character
1534                     if( nIndex > 0 &&
1535                         GetAttributeRun(nStartIndex, nEndIndex, nIndex-1) )
1536                     {
1537                         aResult.SegmentText = GetTextRange(nStartIndex, nEndIndex);
1538                         aResult.SegmentStart = nStartIndex;
1539                         aResult.SegmentEnd = nEndIndex;
1540                     }
1541                 }
1542                 else
1543                 {
1544                     if( GetAttributeRun(nStartIndex, nEndIndex, nIndex) )
1545                     {
1546                         // already at the left border? If not, query
1547                         // one index further left
1548                         if( nStartIndex > 0 &&
1549                             GetAttributeRun(nStartIndex, nEndIndex, nStartIndex-1) )
1550                         {
1551                             aResult.SegmentText = GetTextRange(nStartIndex, nEndIndex);
1552                             aResult.SegmentStart = nStartIndex;
1553                             aResult.SegmentEnd = nEndIndex;
1554                         }
1555                     }
1556                 }
1557                 break;
1558             }
1559
1560             default:
1561                 aResult = OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType );
1562                 break;
1563         } /* end of switch( aTextType ) */
1564
1565         return aResult;
1566     }
1567
1568     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleEditableTextPara::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
1569     {
1570         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1571
1572         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1573
1574         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1575                    "AccessibleEditableTextPara::getTextBehindIndex: paragraph index value overflow");
1576
1577         ::com::sun::star::accessibility::TextSegment aResult;
1578         aResult.SegmentStart = -1;
1579         aResult.SegmentEnd = -1;
1580
1581         switch( aTextType )
1582         {
1583             case AccessibleTextType::ATTRIBUTE_RUN:
1584             {
1585                 USHORT nStartIndex, nEndIndex;
1586
1587                 if( GetAttributeRun(nStartIndex, nEndIndex, nIndex) )
1588                 {
1589                     // already at the right border?
1590                     if( nEndIndex < GetTextLen() )
1591                     {
1592                         if( GetAttributeRun(nStartIndex, nEndIndex, nEndIndex) )
1593                         {
1594                             aResult.SegmentText = GetTextRange(nStartIndex, nEndIndex);
1595                             aResult.SegmentStart = nStartIndex;
1596                             aResult.SegmentEnd = nEndIndex;
1597                         }
1598                     }
1599                 }
1600                 break;
1601             }
1602
1603             default:
1604                 aResult = OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType );
1605                 break;
1606         } /* end of switch( aTextType ) */
1607
1608         return aResult;
1609     }
1610
1611     sal_Bool SAL_CALL AccessibleEditableTextPara::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1612     {
1613         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1614
1615         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1616
1617         try
1618         {
1619             SvxEditViewForwarder& rCacheVF = GetEditViewForwarder( sal_True );
1620             #if OSL_DEBUG_LEVEL > 0
1621             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1622             (void)rCacheTF;
1623             #else
1624             GetTextForwarder();                                         // MUST be after GetEditViewForwarder(), see method docs
1625             #endif
1626
1627             sal_Bool aRetVal;
1628
1629             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1630                        "AccessibleEditableTextPara::copyText: index value overflow");
1631
1632             CheckRange(nStartIndex, nEndIndex);
1633
1634             // save current selection
1635             ESelection aOldSelection;
1636
1637             rCacheVF.GetSelection( aOldSelection );
1638             rCacheVF.SetSelection( MakeSelection(nStartIndex, nEndIndex) );
1639             aRetVal = rCacheVF.Copy();
1640             rCacheVF.SetSelection( aOldSelection ); // restore
1641
1642             return aRetVal;
1643         }
1644         catch( const uno::RuntimeException& )
1645         {
1646             return sal_False;
1647         }
1648     }
1649
1650     // XAccessibleEditableText
1651     sal_Bool SAL_CALL AccessibleEditableTextPara::cutText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1652     {
1653         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1654
1655         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1656
1657         try
1658         {
1659             SvxEditViewForwarder& rCacheVF = GetEditViewForwarder( sal_True );
1660             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1661
1662             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1663                        "AccessibleEditableTextPara::cutText: index value overflow");
1664
1665             CheckRange(nStartIndex, nEndIndex);
1666
1667             if( !rCacheTF.IsEditable( MakeSelection(nStartIndex, nEndIndex) ) )
1668                 return sal_False; // non-editable area selected
1669
1670             // don't save selection, might become invalid after cut!
1671             rCacheVF.SetSelection( MakeSelection(nStartIndex, nEndIndex) );
1672
1673             return rCacheVF.Cut();
1674         }
1675         catch( const uno::RuntimeException& )
1676         {
1677             return sal_False;
1678         }
1679     }
1680
1681     sal_Bool SAL_CALL AccessibleEditableTextPara::pasteText( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1682     {
1683         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1684
1685         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1686
1687         try
1688         {
1689             SvxEditViewForwarder& rCacheVF = GetEditViewForwarder( sal_True );
1690             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1691
1692             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1693                        "AccessibleEditableTextPara::pasteText: index value overflow");
1694
1695             CheckPosition(nIndex);
1696
1697             if( !rCacheTF.IsEditable( MakeSelection(nIndex) ) )
1698                 return sal_False; // non-editable area selected
1699
1700             // #104400# set empty selection (=> cursor) to given index
1701             rCacheVF.SetSelection( MakeCursor(nIndex) );
1702
1703             return rCacheVF.Paste();
1704         }
1705         catch( const uno::RuntimeException& )
1706         {
1707             return sal_False;
1708         }
1709     }
1710
1711     sal_Bool SAL_CALL AccessibleEditableTextPara::deleteText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1712     {
1713         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1714
1715         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1716
1717         try
1718         {
1719             // #102710# Request edit view when doing changes
1720             // AccessibleEmptyEditSource relies on this behaviour
1721             GetEditViewForwarder( sal_True );
1722             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1723
1724             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1725                        "AccessibleEditableTextPara::deleteText: index value overflow");
1726
1727             CheckRange(nStartIndex, nEndIndex);
1728
1729             if( !rCacheTF.IsEditable( MakeSelection(nStartIndex, nEndIndex) ) )
1730                 return sal_False; // non-editable area selected
1731
1732             sal_Bool bRet = rCacheTF.Delete( MakeSelection(nStartIndex, nEndIndex) );
1733
1734             GetEditSource().UpdateData();
1735
1736             return bRet;
1737         }
1738         catch( const uno::RuntimeException& )
1739         {
1740             return sal_False;
1741         }
1742     }
1743
1744     sal_Bool SAL_CALL AccessibleEditableTextPara::insertText( const ::rtl::OUString& sText, sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1745     {
1746         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1747
1748         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1749
1750         try
1751         {
1752             // #102710# Request edit view when doing changes
1753             // AccessibleEmptyEditSource relies on this behaviour
1754             GetEditViewForwarder( sal_True );
1755             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1756
1757             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1758                        "AccessibleEditableTextPara::insertText: index value overflow");
1759
1760             CheckPosition(nIndex);
1761
1762             if( !rCacheTF.IsEditable( MakeSelection(nIndex) ) )
1763                 return sal_False; // non-editable area selected
1764
1765             // #104400# insert given text at empty selection (=> cursor)
1766             sal_Bool bRet = rCacheTF.InsertText( sText, MakeCursor(nIndex) );
1767
1768             rCacheTF.QuickFormatDoc();
1769             GetEditSource().UpdateData();
1770
1771             return bRet;
1772         }
1773         catch( const uno::RuntimeException& )
1774         {
1775             return sal_False;
1776         }
1777     }
1778
1779     sal_Bool SAL_CALL AccessibleEditableTextPara::replaceText( sal_Int32 nStartIndex, sal_Int32 nEndIndex, const ::rtl::OUString& sReplacement ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1780     {
1781         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1782
1783         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1784
1785         try
1786         {
1787             // #102710# Request edit view when doing changes
1788             // AccessibleEmptyEditSource relies on this behaviour
1789             GetEditViewForwarder( sal_True );
1790             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1791
1792             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1793                        "AccessibleEditableTextPara::replaceText: index value overflow");
1794
1795             CheckRange(nStartIndex, nEndIndex);
1796
1797             if( !rCacheTF.IsEditable( MakeSelection(nStartIndex, nEndIndex) ) )
1798                 return sal_False; // non-editable area selected
1799
1800             // insert given text into given range => replace
1801             sal_Bool bRet = rCacheTF.InsertText( sReplacement, MakeSelection(nStartIndex, nEndIndex) );
1802
1803             rCacheTF.QuickFormatDoc();
1804             GetEditSource().UpdateData();
1805
1806             return bRet;
1807         }
1808         catch( const uno::RuntimeException& )
1809         {
1810             return sal_False;
1811         }
1812     }
1813
1814     sal_Bool SAL_CALL AccessibleEditableTextPara::setAttributes( sal_Int32 nStartIndex, sal_Int32 nEndIndex, const uno::Sequence< beans::PropertyValue >& aAttributeSet ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1815     {
1816         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1817
1818         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1819
1820         try
1821         {
1822             // #102710# Request edit view when doing changes
1823             // AccessibleEmptyEditSource relies on this behaviour
1824             GetEditViewForwarder( sal_True );
1825             SvxAccessibleTextAdapter& rCacheTF = GetTextForwarder();    // MUST be after GetEditViewForwarder(), see method docs
1826             USHORT nPara = static_cast< USHORT >( GetParagraphIndex() );
1827
1828             DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1829                        "AccessibleEditableTextPara::setAttributes: index value overflow");
1830
1831             CheckRange(nStartIndex, nEndIndex);
1832
1833             if( !rCacheTF.IsEditable( MakeSelection(nStartIndex, nEndIndex) ) )
1834                 return sal_False; // non-editable area selected
1835
1836             // do the indices span the whole paragraph? Then use the outliner map
1837             // TODO: hold it as a member?
1838             SvxAccessibleTextPropertySet aPropSet( &GetEditSource(),
1839                                                    0 == nStartIndex &&
1840                                                    rCacheTF.GetTextLen(nPara) == nEndIndex ?
1841                                                    ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() :
1842                                                    ImplGetSvxTextPortionSvxPropertySet() );
1843
1844             aPropSet.SetSelection( MakeSelection(nStartIndex, nEndIndex) );
1845
1846             // convert from PropertyValue to Any
1847             sal_Int32 i, nLength( aAttributeSet.getLength() );
1848             const beans::PropertyValue* pPropArray = aAttributeSet.getConstArray();
1849             for(i=0; i<nLength; ++i)
1850             {
1851                 try
1852                 {
1853                     aPropSet.setPropertyValue(pPropArray->Name, pPropArray->Value);
1854                 }
1855                 catch( const uno::Exception& )
1856                 {
1857                     DBG_ERROR("AccessibleEditableTextPara::setAttributes exception in setPropertyValue");
1858                 }
1859
1860                 ++pPropArray;
1861             }
1862
1863             rCacheTF.QuickFormatDoc();
1864             GetEditSource().UpdateData();
1865
1866             return sal_True;
1867         }
1868         catch( const uno::RuntimeException& )
1869         {
1870             return sal_False;
1871         }
1872     }
1873
1874     sal_Bool SAL_CALL AccessibleEditableTextPara::setText( const ::rtl::OUString& sText ) throw (uno::RuntimeException)
1875     {
1876         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1877
1878         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1879
1880         return replaceText(0, getCharacterCount(), sText);
1881     }
1882
1883     // XAccessibleTextAttributes
1884     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleEditableTextPara::getDefaultAttributes(
1885             const uno::Sequence< ::rtl::OUString >& rRequestedAttributes )
1886         throw (uno::RuntimeException)
1887     {
1888         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1889         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1890
1891         #if OSL_DEBUG_LEVEL > 0
1892         SvxAccessibleTextAdapter& rCacheTF =
1893         #endif
1894             GetTextForwarder();
1895
1896         #if OSL_DEBUG_LEVEL > 0
1897         (void)rCacheTF;
1898         #endif
1899
1900         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
1901                    "AccessibleEditableTextPara::getCharacterAttributes: index value overflow");
1902
1903         // get XPropertySetInfo for paragraph attributes and
1904         // character attributes that span all the paragraphs text.
1905         SvxAccessibleTextPropertySet aPropSet( &GetEditSource(),
1906                 ImplGetSvxCharAndParaPropertiesSet() );
1907         aPropSet.SetSelection( MakeSelection( 0, GetTextLen() ) );
1908         uno::Reference< beans::XPropertySetInfo > xPropSetInfo = aPropSet.getPropertySetInfo();
1909         if (!xPropSetInfo.is())
1910             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Cannot query XPropertySetInfo")),
1911                         uno::Reference< uno::XInterface >
1912                         ( static_cast< XAccessible* > (this) ) );   // disambiguate hierarchy
1913
1914         // build sequence of available properties to check
1915         sal_Int32 nLenReqAttr = rRequestedAttributes.getLength();
1916         uno::Sequence< beans::Property > aProperties;
1917         if (nLenReqAttr)
1918         {
1919             const rtl::OUString *pRequestedAttributes = rRequestedAttributes.getConstArray();
1920
1921             aProperties.realloc( nLenReqAttr );
1922             beans::Property *pProperties = aProperties.getArray();
1923             sal_Int32 nCurLen = 0;
1924             for (sal_Int32 i = 0;  i < nLenReqAttr;  ++i)
1925             {
1926                 beans::Property aProp;
1927                 try
1928                 {
1929                     aProp = xPropSetInfo->getPropertyByName( pRequestedAttributes[i] );
1930                 }
1931                 catch (beans::UnknownPropertyException &)
1932                 {
1933                     continue;
1934                 }
1935                 pProperties[ nCurLen++ ] = aProp;
1936             }
1937             aProperties.realloc( nCurLen );
1938         }
1939         else
1940             aProperties = xPropSetInfo->getProperties();
1941
1942         sal_Int32 nLength = aProperties.getLength();
1943         const beans::Property *pProperties = aProperties.getConstArray();
1944
1945         // build resulting sequence
1946         uno::Sequence< beans::PropertyValue > aOutSequence( nLength );
1947         beans::PropertyValue* pOutSequence = aOutSequence.getArray();
1948         sal_Int32 nOutLen = 0;
1949         for (sal_Int32 i = 0;  i < nLength;  ++i)
1950         {
1951             // calling implementation functions:
1952             // _getPropertyState and _getPropertyValue (see below) to provide
1953             // the proper paragraph number when retrieving paragraph attributes
1954             PropertyState eState = aPropSet._getPropertyState( pProperties->Name, mnParagraphIndex );
1955             if ( eState == PropertyState_AMBIGUOUS_VALUE )
1956             {
1957                 OSL_ENSURE( false, "ambiguous property value encountered" );
1958             }
1959
1960             //if (eState == PropertyState_DIRECT_VALUE)
1961             // per definition all paragraph properties and all character
1962             // properties spanning the whole paragraph should be returned
1963             // and declared as default value
1964             {
1965                 pOutSequence->Name      = pProperties->Name;
1966                 pOutSequence->Handle    = pProperties->Handle;
1967                 pOutSequence->Value     = aPropSet._getPropertyValue( pProperties->Name, mnParagraphIndex );
1968                 pOutSequence->State     = PropertyState_DEFAULT_VALUE;
1969
1970                 ++pOutSequence;
1971                 ++nOutLen;
1972             }
1973             ++pProperties;
1974         }
1975         aOutSequence.realloc( nOutLen );
1976
1977         return aOutSequence;
1978     }
1979
1980
1981     uno::Sequence< beans::PropertyValue > SAL_CALL AccessibleEditableTextPara::getRunAttributes(
1982             sal_Int32 nIndex,
1983             const uno::Sequence< ::rtl::OUString >& rRequestedAttributes )
1984         throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
1985     {
1986         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
1987
1988         ::vos::OGuard aGuard( Application::GetSolarMutex() );
1989
1990         #if OSL_DEBUG_LEVEL > 0
1991         SvxAccessibleTextAdapter& rCacheTF =
1992         #endif
1993             GetTextForwarder();
1994
1995         #if OSL_DEBUG_LEVEL > 0
1996         (void)rCacheTF;
1997         #endif
1998
1999         DBG_ASSERT(GetParagraphIndex() >= 0 && GetParagraphIndex() <= USHRT_MAX,
2000                    "AccessibleEditableTextPara::getCharacterAttributes: index value overflow");
2001
2002         CheckIndex(nIndex);
2003
2004         SvxAccessibleTextPropertySet aPropSet( &GetEditSource(),
2005                                                ImplGetSvxCharAndParaPropertiesSet() );
2006         aPropSet.SetSelection( MakeSelection( nIndex ) );
2007         uno::Reference< beans::XPropertySetInfo > xPropSetInfo = aPropSet.getPropertySetInfo();
2008         if (!xPropSetInfo.is())
2009             throw uno::RuntimeException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Cannot query XPropertySetInfo")),
2010                                         uno::Reference< uno::XInterface >
2011                                         ( static_cast< XAccessible* > (this) ) );   // disambiguate hierarchy
2012
2013         // build sequence of available properties to check
2014         sal_Int32 nLenReqAttr = rRequestedAttributes.getLength();
2015         uno::Sequence< beans::Property > aProperties;
2016         if (nLenReqAttr)
2017         {
2018             const rtl::OUString *pRequestedAttributes = rRequestedAttributes.getConstArray();
2019
2020             aProperties.realloc( nLenReqAttr );
2021             beans::Property *pProperties = aProperties.getArray();
2022             sal_Int32 nCurLen = 0;
2023             for (sal_Int32 i = 0;  i < nLenReqAttr;  ++i)
2024             {
2025                 beans::Property aProp;
2026                 try
2027                 {
2028                     aProp = xPropSetInfo->getPropertyByName( pRequestedAttributes[i] );
2029                 }
2030                 catch (beans::UnknownPropertyException &)
2031                 {
2032                     continue;
2033                 }
2034                 pProperties[ nCurLen++ ] = aProp;
2035             }
2036             aProperties.realloc( nCurLen );
2037         }
2038         else
2039             aProperties = xPropSetInfo->getProperties();
2040
2041         sal_Int32 nLength = aProperties.getLength();
2042         const beans::Property *pProperties = aProperties.getConstArray();
2043
2044         // build resulting sequence
2045         uno::Sequence< beans::PropertyValue > aOutSequence( nLength );
2046         beans::PropertyValue* pOutSequence = aOutSequence.getArray();
2047         sal_Int32 nOutLen = 0;
2048         for (sal_Int32 i = 0;  i < nLength;  ++i)
2049         {
2050             // calling 'regular' functions that will operate on the selection
2051             PropertyState eState = aPropSet.getPropertyState( pProperties->Name );
2052             if (eState == PropertyState_DIRECT_VALUE)
2053             {
2054                 pOutSequence->Name      = pProperties->Name;
2055                 pOutSequence->Handle    = pProperties->Handle;
2056                 pOutSequence->Value     = aPropSet.getPropertyValue( pProperties->Name );
2057                 pOutSequence->State     = eState;
2058
2059                 ++pOutSequence;
2060                 ++nOutLen;
2061             }
2062             ++pProperties;
2063         }
2064         aOutSequence.realloc( nOutLen );
2065
2066         return aOutSequence;
2067     }
2068
2069     // XAccessibleMultiLineText
2070     sal_Int32 SAL_CALL AccessibleEditableTextPara::getLineNumberAtIndex( sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
2071     {
2072         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2073
2074         sal_Int32 nRes = -1;
2075         sal_Int32 nPara = GetParagraphIndex();
2076
2077         SvxTextForwarder &rCacheTF = GetTextForwarder();
2078         const bool bValidPara = 0 <= nPara && nPara < rCacheTF.GetParagraphCount();
2079         DBG_ASSERT( bValidPara, "getLineNumberAtIndex: current paragraph index out of range" );
2080         if (bValidPara)
2081         {
2082             // we explicitly allow for the index to point at the character right behind the text
2083             if (0 <= nIndex && nIndex <= rCacheTF.GetTextLen( static_cast< USHORT >(nPara) ))
2084                 nRes = rCacheTF.GetLineNumberAtIndex( static_cast< USHORT >(nPara), static_cast< USHORT >(nIndex) );
2085             else
2086                 throw lang::IndexOutOfBoundsException();
2087         }
2088         return nRes;
2089     }
2090
2091     // XAccessibleMultiLineText
2092     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleEditableTextPara::getTextAtLineNumber( sal_Int32 nLineNo ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
2093     {
2094         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2095
2096         ::com::sun::star::accessibility::TextSegment aResult;
2097         sal_Int32 nPara = GetParagraphIndex();
2098         SvxTextForwarder &rCacheTF = GetTextForwarder();
2099         const bool bValidPara = 0 <= nPara && nPara < rCacheTF.GetParagraphCount();
2100         DBG_ASSERT( bValidPara, "getTextAtLineNumber: current paragraph index out of range" );
2101         if (bValidPara)
2102         {
2103             if (0 <= nLineNo && nLineNo < rCacheTF.GetLineCount( static_cast< USHORT >(nPara) ))
2104             {
2105                 USHORT nStart = 0, nEnd = 0;
2106                 rCacheTF.GetLineBoundaries( nStart, nEnd, static_cast< USHORT >(nPara), static_cast< USHORT >(nLineNo) );
2107                 if (nStart != 0xFFFF && nEnd != 0xFFFF)
2108                 {
2109                     try
2110                     {
2111                         aResult.SegmentText     = getTextRange( nStart, nEnd );
2112                         aResult.SegmentStart    = nStart;
2113                         aResult.SegmentEnd      = nEnd;
2114                     }
2115                     catch (lang::IndexOutOfBoundsException)
2116                     {
2117                         // this is not the exception that should be raised in this function ...
2118                         DBG_ASSERT( 0, "unexpected exception" );
2119                     }
2120                 }
2121             }
2122             else
2123                 throw lang::IndexOutOfBoundsException();
2124         }
2125         return aResult;
2126     }
2127
2128     // XAccessibleMultiLineText
2129     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleEditableTextPara::getTextAtLineWithCaret(  ) throw (uno::RuntimeException)
2130     {
2131         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2132
2133         ::com::sun::star::accessibility::TextSegment aResult;
2134         try
2135         {
2136             aResult = getTextAtLineNumber( getNumberOfLineWithCaret() );
2137         }
2138         catch (lang::IndexOutOfBoundsException &)
2139         {
2140             // this one needs to be catched since this interface does not allow for it.
2141         }
2142         return aResult;
2143     }
2144
2145     // XAccessibleMultiLineText
2146     sal_Int32 SAL_CALL AccessibleEditableTextPara::getNumberOfLineWithCaret(  ) throw (uno::RuntimeException)
2147     {
2148         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2149
2150         sal_Int32 nRes = -1;
2151         try
2152         {
2153             nRes = getLineNumberAtIndex( getCaretPosition() );
2154         }
2155         catch (lang::IndexOutOfBoundsException &)
2156         {
2157             // this one needs to be catched since this interface does not allow for it.
2158         }
2159         return nRes;
2160     }
2161
2162
2163     // XServiceInfo
2164     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getImplementationName (void) throw (uno::RuntimeException)
2165     {
2166         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2167
2168         return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM ("AccessibleEditableTextPara"));
2169     }
2170
2171     sal_Bool SAL_CALL AccessibleEditableTextPara::supportsService (const ::rtl::OUString& sServiceName) throw (uno::RuntimeException)
2172     {
2173         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2174
2175         //  Iterate over all supported service names and return true if on of them
2176         //  matches the given name.
2177         uno::Sequence< ::rtl::OUString> aSupportedServices (
2178             getSupportedServiceNames ());
2179         for (int i=0; i<aSupportedServices.getLength(); i++)
2180             if (sServiceName == aSupportedServices[i])
2181                 return sal_True;
2182         return sal_False;
2183     }
2184
2185     uno::Sequence< ::rtl::OUString> SAL_CALL AccessibleEditableTextPara::getSupportedServiceNames (void) throw (uno::RuntimeException)
2186     {
2187         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2188
2189         const ::rtl::OUString sServiceName( getServiceName() );
2190         return uno::Sequence< ::rtl::OUString > (&sServiceName, 1);
2191     }
2192
2193     // XServiceName
2194     ::rtl::OUString SAL_CALL AccessibleEditableTextPara::getServiceName (void) throw (uno::RuntimeException)
2195     {
2196         DBG_CHKTHIS( AccessibleEditableTextPara, NULL );
2197
2198         // #105185# Using correct service now
2199         return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.AccessibleParagraphView"));
2200     }
2201
2202 }  // end of namespace accessibility
2203
2204 //------------------------------------------------------------------------