editeng/source/uno/unoedprx.cxx

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