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