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