editeng/source/uno/unotext.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 #include <vcl/svapp.hxx>
  21 #include <com/sun/star/text/ControlCharacter.hpp>
  22 #include <com/sun/star/text/XTextField.hpp>
  23 #include <com/sun/star/text/TextRangeSelection.hpp>
  24 #include <com/sun/star/lang/Locale.hpp>
  25 #include <com/sun/star/beans/PropertyAttribute.hpp>
  26 #include <com/sun/star/container/XNameContainer.hpp>
  27
  28 #include <svl/itemset.hxx>
  29 #include <svl/itempool.hxx>
  30 #include <svl/eitem.hxx>
  31 #include <rtl/instance.hxx>
  32 #include <tools/debug.hxx>
  33
  34 #include <editeng/unoprnms.hxx>
  35 #include <editeng/unotext.hxx>
  36 #include <editeng/unoedsrc.hxx>
  37 #include <editeng/unonrule.hxx>
  38 #include <editeng/unofdesc.hxx>
  39 #include <editeng/unofield.hxx>
  40 #include <editeng/flditem.hxx>
  41 #include <editeng/numitem.hxx>
  42 #include <editeng/editeng.hxx>
  43 #include <editeng/outliner.hxx>
  44 #include <editeng/unoipset.hxx>
  45 #include <comphelper/sequence.hxx>
  46 #include <comphelper/servicehelper.hxx>
  47 #include <cppuhelper/supportsservice.hxx>
  48
  49 #include <editeng/unonames.hxx>
  50
  51 #include <initializer_list>
  52 #include <memory>
  53 #include <string_view>
  54
  55 using namespace ::cppu;
  56 using namespace ::com::sun::star;
  57
  58 namespace {
  59
  60 ESelection toESelection(const text::TextRangeSelection& rSel)
  61 {
  62     ESelection aESel;
  63     aESel.nStartPara = rSel.Start.Paragraph;
  64     aESel.nStartPos = rSel.Start.PositionInParagraph;
  65     aESel.nEndPara = rSel.End.Paragraph;
  66     aESel.nEndPos = rSel.End.PositionInParagraph;
  67     return aESel;
  68 }
  69
  70 }
  71
  72 #define QUERYINT( xint ) \
  73     if( rType == cppu::UnoType<xint>::get() ) \
  74         return uno::makeAny(uno::Reference< xint >(this))
  75
  76 const SvxItemPropertySet* ImplGetSvxUnoOutlinerTextCursorSvxPropertySet()
  77 {
  78     static SvxItemPropertySet aTextCursorSvxPropertySet( ImplGetSvxUnoOutlinerTextCursorPropertyMap(), EditEngine::GetGlobalItemPool() );
  79     return &aTextCursorSvxPropertySet;
  80 }
  81
  82 const SfxItemPropertyMapEntry* ImplGetSvxTextPortionPropertyMap()
  83 {
  84     // Propertymap for an Outliner Text
  85     static const SfxItemPropertyMapEntry aSvxTextPortionPropertyMap[] =
  86     {
  87         SVX_UNOEDIT_CHAR_PROPERTIES,
  88         SVX_UNOEDIT_FONT_PROPERTIES,
  89         SVX_UNOEDIT_OUTLINER_PROPERTIES,
  90         SVX_UNOEDIT_PARA_PROPERTIES,
  91         { u"TextField",                     EE_FEATURE_FIELD,   cppu::UnoType<text::XTextField>::get(),   beans::PropertyAttribute::READONLY, 0 },
  92         { u"TextPortionType",               WID_PORTIONTYPE,    ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0 },
  93         { u"TextUserDefinedAttributes",     EE_CHAR_XMLATTRIBS,     cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
  94         { u"ParaUserDefinedAttributes",     EE_PARA_XMLATTRIBS,     cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
  95         { u"", 0, css::uno::Type(), 0, 0 }
  96     };
  97     return aSvxTextPortionPropertyMap;
  98 }
  99 const SvxItemPropertySet* ImplGetSvxTextPortionSvxPropertySet()
 100 {
 101     static SvxItemPropertySet aSvxTextPortionPropertySet( ImplGetSvxTextPortionPropertyMap(), EditEngine::GetGlobalItemPool() );
 102     return &aSvxTextPortionPropertySet;
 103 }
 104
 105 static const SfxItemPropertySet* ImplGetSvxTextPortionSfxPropertySet()
 106 {
 107     static SfxItemPropertySet aSvxTextPortionSfxPropertySet( ImplGetSvxTextPortionPropertyMap() );
 108     return &aSvxTextPortionSfxPropertySet;
 109 }
 110
 111 const SfxItemPropertyMapEntry* ImplGetSvxUnoOutlinerTextCursorPropertyMap()
 112 {
 113     // Propertymap for an Outliner Text
 114     static const SfxItemPropertyMapEntry aSvxUnoOutlinerTextCursorPropertyMap[] =
 115     {
 116         SVX_UNOEDIT_CHAR_PROPERTIES,
 117         SVX_UNOEDIT_FONT_PROPERTIES,
 118         SVX_UNOEDIT_OUTLINER_PROPERTIES,
 119         SVX_UNOEDIT_PARA_PROPERTIES,
 120         { u"TextUserDefinedAttributes",         EE_CHAR_XMLATTRIBS,     cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
 121         { u"ParaUserDefinedAttributes",         EE_PARA_XMLATTRIBS,     cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
 122         { u"", 0, css::uno::Type(), 0, 0 }
 123     };
 124
 125     return aSvxUnoOutlinerTextCursorPropertyMap;
 126 }
 127 static const SfxItemPropertySet* ImplGetSvxUnoOutlinerTextCursorSfxPropertySet()
 128 {
 129     static SfxItemPropertySet aTextCursorSfxPropertySet( ImplGetSvxUnoOutlinerTextCursorPropertyMap() );
 130     return &aTextCursorSfxPropertySet;
 131 }
 132
 133
 134 // helper for Item/Property conversion
 135
 136
 137 void GetSelection( struct ESelection& rSel, SvxTextForwarder const * pForwarder ) throw()
 138 {
 139     DBG_ASSERT( pForwarder, "I need a valid SvxTextForwarder!" );
 140     if( pForwarder )
 141     {
 142         sal_Int32 nParaCount = pForwarder->GetParagraphCount();
 143         if(nParaCount>0)
 144             nParaCount--;
 145
 146         rSel = ESelection( 0,0, nParaCount, pForwarder->GetTextLen( nParaCount ));
 147     }
 148 }
 149
 150 void CheckSelection( struct ESelection& rSel, SvxTextForwarder const * pForwarder ) throw()
 151 {
 152     DBG_ASSERT( pForwarder, "I need a valid SvxTextForwarder!" );
 153     if( !pForwarder )
 154         return;
 155
 156     if( rSel.nStartPara == EE_PARA_MAX_COUNT )
 157     {
 158         ::GetSelection( rSel, pForwarder );
 159     }
 160     else
 161     {
 162         ESelection aMaxSelection;
 163         GetSelection( aMaxSelection, pForwarder );
 164
 165         // check start position
 166         if( rSel.nStartPara < aMaxSelection.nStartPara )
 167         {
 168             rSel.nStartPara = aMaxSelection.nStartPara;
 169             rSel.nStartPos = aMaxSelection.nStartPos;
 170         }
 171         else if( rSel.nStartPara > aMaxSelection.nEndPara )
 172         {
 173             rSel.nStartPara = aMaxSelection.nEndPara;
 174             rSel.nStartPos = aMaxSelection.nEndPos;
 175         }
 176         else if( rSel.nStartPos  > pForwarder->GetTextLen( rSel.nStartPara ) )
 177         {
 178             rSel.nStartPos = pForwarder->GetTextLen( rSel.nStartPara );
 179         }
 180
 181         // check end position
 182         if( rSel.nEndPara < aMaxSelection.nStartPara )
 183         {
 184             rSel.nEndPara = aMaxSelection.nStartPara;
 185             rSel.nEndPos = aMaxSelection.nStartPos;
 186         }
 187         else if( rSel.nEndPara > aMaxSelection.nEndPara )
 188         {
 189             rSel.nEndPara = aMaxSelection.nEndPara;
 190             rSel.nEndPos = aMaxSelection.nEndPos;
 191         }
 192         else if( rSel.nEndPos > pForwarder->GetTextLen( rSel.nEndPara ) )
 193         {
 194             rSel.nEndPos = pForwarder->GetTextLen( rSel.nEndPara );
 195         }
 196     }
 197 }
 198
 199 static void CheckSelection( struct ESelection& rSel, SvxEditSource *pEdit ) throw()
 200 {
 201     if (!pEdit)
 202         return;
 203     CheckSelection( rSel, pEdit->GetTextForwarder() );
 204 }
 205
 206
 207
 208
 209 UNO3_GETIMPLEMENTATION_IMPL( SvxUnoTextRangeBase );
 210
 211 SvxUnoTextRangeBase::SvxUnoTextRangeBase(const SvxItemPropertySet* _pSet)
 212     : mpPropSet(_pSet)
 213 {
 214 }
 215
 216 SvxUnoTextRangeBase::SvxUnoTextRangeBase(const SvxEditSource* pSource, const SvxItemPropertySet* _pSet)
 217 : mpPropSet(_pSet)
 218 {
 219     SolarMutexGuard aGuard;
 220
 221     DBG_ASSERT(pSource,"SvxUnoTextRangeBase: I need a valid SvxEditSource!");
 222
 223     mpEditSource = pSource->Clone();
 224     if (mpEditSource != nullptr)
 225     {
 226         ESelection aSelection;
 227         ::GetSelection( aSelection, mpEditSource->GetTextForwarder() );
 228         SetSelection( aSelection );
 229
 230         mpEditSource->addRange( this );
 231     }
 232 }
 233
 234 SvxUnoTextRangeBase::SvxUnoTextRangeBase(const SvxUnoTextRangeBase& rRange)
 235 :   text::XTextRange()
 236 ,   beans::XPropertySet()
 237 ,   beans::XMultiPropertySet()
 238 ,   beans::XMultiPropertyStates()
 239 ,   beans::XPropertyState()
 240 ,   lang::XServiceInfo()
 241 ,   text::XTextRangeCompare()
 242 ,   lang::XUnoTunnel()
 243 ,   osl::DebugBase<SvxUnoTextRangeBase>()
 244 ,   mpPropSet(rRange.getPropertySet())
 245 {
 246     SolarMutexGuard aGuard;
 247
 248     if (rRange.mpEditSource)
 249         mpEditSource = rRange.mpEditSource->Clone();
 250
 251     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 252     if( pForwarder )
 253     {
 254         maSelection  = rRange.maSelection;
 255         CheckSelection( maSelection, pForwarder );
 256     }
 257
 258     if( mpEditSource )
 259         mpEditSource->addRange( this );
 260 }
 261
 262 SvxUnoTextRangeBase::~SvxUnoTextRangeBase() throw()
 263 {
 264     if( mpEditSource )
 265         mpEditSource->removeRange( this );
 266 }
 267
 268 void SvxUnoTextRangeBase::SetEditSource( SvxEditSource* pSource ) throw()
 269 {
 270     DBG_ASSERT(pSource,"SvxUnoTextRangeBase: I need a valid SvxEditSource!");
 271     DBG_ASSERT(mpEditSource==nullptr,"SvxUnoTextRangeBase::SetEditSource called while SvxEditSource already set" );
 272
 273     mpEditSource.reset( pSource );
 274
 275     maSelection.nStartPara = EE_PARA_MAX_COUNT;
 276
 277     if( mpEditSource )
 278         mpEditSource->addRange( this );
 279 }
 280
 281 /** puts a field item with a copy of the given FieldData into the itemset
 282     corresponding with this range */
 283 void SvxUnoTextRangeBase::attachField( std::unique_ptr<SvxFieldData> pData ) throw()
 284 {
 285     SolarMutexGuard aGuard;
 286
 287     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 288     if( pForwarder )
 289     {
 290         SvxFieldItem aField( std::move(pData), EE_FEATURE_FIELD );
 291         pForwarder->QuickInsertField( std::move(aField), maSelection );
 292     }
 293 }
 294
 295 void SvxUnoTextRangeBase::SetSelection( const ESelection& rSelection ) throw()
 296 {
 297     SolarMutexGuard aGuard;
 298
 299     maSelection = rSelection;
 300     CheckSelection( maSelection, mpEditSource.get() );
 301 }
 302
 303 // Interface XTextRange ( XText )
 304
 305 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextRangeBase::getStart()
 306 {
 307     SolarMutexGuard aGuard;
 308
 309     uno::Reference< text::XTextRange > xRange;
 310
 311     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 312     if( pForwarder )
 313     {
 314         CheckSelection( maSelection, pForwarder );
 315
 316         SvxUnoTextBase* pText = comphelper::getUnoTunnelImplementation<SvxUnoTextBase>( getText() );
 317
 318         if(pText == nullptr)
 319             throw uno::RuntimeException();
 320
 321         SvxUnoTextRange* pRange = new SvxUnoTextRange( *pText );
 322         xRange = pRange;
 323
 324         ESelection aNewSel = maSelection;
 325         aNewSel.nEndPara = aNewSel.nStartPara;
 326         aNewSel.nEndPos  = aNewSel.nStartPos;
 327         pRange->SetSelection( aNewSel );
 328     }
 329
 330     return xRange;
 331 }
 332
 333 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextRangeBase::getEnd()
 334 {
 335     SolarMutexGuard aGuard;
 336
 337     uno::Reference< text::XTextRange > xRet;
 338
 339     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 340     if( pForwarder )
 341     {
 342         CheckSelection( maSelection, pForwarder );
 343
 344         SvxUnoTextBase* pText = comphelper::getUnoTunnelImplementation<SvxUnoTextBase>( getText() );
 345
 346         if(pText == nullptr)
 347             throw uno::RuntimeException();
 348
 349         SvxUnoTextRange* pNew = new SvxUnoTextRange( *pText );
 350         xRet = pNew;
 351
 352         ESelection aNewSel = maSelection;
 353         aNewSel.nStartPara = aNewSel.nEndPara;
 354         aNewSel.nStartPos  = aNewSel.nEndPos;
 355         pNew->SetSelection( aNewSel );
 356     }
 357     return xRet;
 358 }
 359
 360 OUString SAL_CALL SvxUnoTextRangeBase::getString()
 361 {
 362     SolarMutexGuard aGuard;
 363
 364     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 365     if( pForwarder )
 366     {
 367         CheckSelection( maSelection, pForwarder );
 368
 369         return pForwarder->GetText( maSelection );
 370     }
 371     else
 372     {
 373         return OUString();
 374     }
 375 }
 376
 377 void SAL_CALL SvxUnoTextRangeBase::setString(const OUString& aString)
 378 {
 379     SolarMutexGuard aGuard;
 380
 381     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 382     if( !pForwarder )
 383         return;
 384
 385     CheckSelection( maSelection, pForwarder );
 386
 387     OUString aConverted(convertLineEnd(aString, LINEEND_LF));  // Simply count the number of line endings
 388
 389     pForwarder->QuickInsertText( aConverted, maSelection );
 390     mpEditSource->UpdateData();
 391
 392     //  Adapt selection
 393     //! It would be easier if the EditEngine would return the selection
 394     //! on QuickInsertText...
 395     CollapseToStart();
 396
 397     sal_Int32 nLen = aConverted.getLength();
 398     if (nLen)
 399         GoRight( nLen, true );
 400 }
 401
 402 // Interface beans::XPropertySet
 403 uno::Reference< beans::XPropertySetInfo > SAL_CALL SvxUnoTextRangeBase::getPropertySetInfo()
 404 {
 405     return mpPropSet->getPropertySetInfo();
 406 }
 407
 408 void SAL_CALL SvxUnoTextRangeBase::setPropertyValue(const OUString& PropertyName, const uno::Any& aValue)
 409 {
 410     if (PropertyName == UNO_TR_PROP_SELECTION)
 411     {
 412         text::TextRangeSelection aSel = aValue.get<text::TextRangeSelection>();
 413         SetSelection(toESelection(aSel));
 414
 415         return;
 416     }
 417
 418     _setPropertyValue( PropertyName, aValue );
 419 }
 420
 421 void SvxUnoTextRangeBase::_setPropertyValue( const OUString& PropertyName, const uno::Any& aValue, sal_Int32 nPara )
 422 {
 423     SolarMutexGuard aGuard;
 424
 425     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 426     if( pForwarder )
 427     {
 428         CheckSelection( maSelection, pForwarder );
 429
 430         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName );
 431         if ( pMap )
 432         {
 433             ESelection aSel( GetSelection() );
 434             bool bParaAttrib = (pMap->nWID >= EE_PARA_START) && ( pMap->nWID <= EE_PARA_END );
 435
 436             if( nPara == -1 && !bParaAttrib )
 437             {
 438                 SfxItemSet aOldSet( pForwarder->GetAttribs( aSel ) );
 439                 // we have a selection and no para attribute
 440                 SfxItemSet aNewSet( *aOldSet.GetPool(), aOldSet.GetRanges() );
 441
 442                 setPropertyValue( pMap, aValue, maSelection, aOldSet, aNewSet );
 443
 444
 445                 pForwarder->QuickSetAttribs( aNewSet, GetSelection() );
 446             }
 447             else
 448             {
 449                 sal_Int32 nEndPara;
 450
 451                 if( nPara == -1 )
 452                 {
 453                     nPara = aSel.nStartPara;
 454                     nEndPara = aSel.nEndPara;
 455                 }
 456                 else
 457                 {
 458                     // only one paragraph
 459                     nEndPara = nPara;
 460                 }
 461
 462                 while( nPara <= nEndPara )
 463                 {
 464                     // we have a paragraph
 465                     SfxItemSet aSet( pForwarder->GetParaAttribs( nPara ) );
 466                     setPropertyValue( pMap, aValue, maSelection, aSet, aSet );
 467                     pForwarder->SetParaAttribs( nPara, aSet );
 468                     nPara++;
 469                 }
 470             }
 471
 472             GetEditSource()->UpdateData();
 473             return;
 474         }
 475     }
 476
 477     throw beans::UnknownPropertyException(PropertyName);
 478 }
 479
 480 void SvxUnoTextRangeBase::setPropertyValue( const SfxItemPropertySimpleEntry* pMap, const uno::Any& rValue, const ESelection& rSelection, const SfxItemSet& rOldSet, SfxItemSet& rNewSet )
 481 {
 482     if(!SetPropertyValueHelper( pMap, rValue, rNewSet, &rSelection, GetEditSource() ))
 483     {
 484         // For parts of composite items with multiple properties (eg background)
 485         // must be taken from the document before the old item.
 486         rNewSet.Put(rOldSet.Get(pMap->nWID));  // Old Item in new Set
 487         SvxItemPropertySet::setPropertyValue(pMap, rValue, rNewSet, false );
 488     }
 489 }
 490
 491 bool SvxUnoTextRangeBase::SetPropertyValueHelper( const SfxItemPropertySimpleEntry* pMap, const uno::Any& aValue, SfxItemSet& rNewSet, const ESelection* pSelection /* = NULL */, SvxEditSource* pEditSource /* = NULL*/ )
 492 {
 493     switch( pMap->nWID )
 494     {
 495     case WID_FONTDESC:
 496         {
 497             awt::FontDescriptor aDesc;
 498             if(aValue >>= aDesc)
 499             {
 500                 SvxUnoFontDescriptor::FillItemSet( aDesc, rNewSet );
 501                 return true;
 502             }
 503         }
 504         break;
 505
 506     case EE_PARA_NUMBULLET:
 507         {
 508             uno::Reference< container::XIndexReplace > xRule;
 509             return !aValue.hasValue() || ((aValue >>= xRule) && !xRule.is());
 510         }
 511
 512     case WID_NUMLEVEL:
 513         {
 514             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : nullptr;
 515             if(pForwarder && pSelection)
 516             {
 517                 sal_Int16 nLevel = sal_Int16();
 518                 if( aValue >>= nLevel )
 519                 {
 520                     // #101004# Call interface method instead of unsafe cast
 521                     if(! pForwarder->SetDepth( pSelection->nStartPara, nLevel ) )
 522                         throw lang::IllegalArgumentException();
 523
 524                     return true;
 525                 }
 526             }
 527         }
 528         break;
 529     case WID_NUMBERINGSTARTVALUE:
 530         {
 531             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : nullptr;
 532             if(pForwarder && pSelection)
 533             {
 534                 sal_Int16 nStartValue = -1;
 535                 if( aValue >>= nStartValue )
 536                 {
 537                     pForwarder->SetNumberingStartValue( pSelection->nStartPara, nStartValue );
 538                     return true;
 539                 }
 540             }
 541         }
 542         break;
 543     case WID_PARAISNUMBERINGRESTART:
 544         {
 545             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : nullptr;
 546             if(pForwarder && pSelection)
 547             {
 548                 bool bParaIsNumberingRestart = false;
 549                 if( aValue >>= bParaIsNumberingRestart )
 550                 {
 551                     pForwarder->SetParaIsNumberingRestart( pSelection->nStartPara, bParaIsNumberingRestart );
 552                     return true;
 553                 }
 554             }
 555         }
 556         break;
 557     case EE_PARA_BULLETSTATE:
 558         {
 559             bool bBullet = true;
 560             if( aValue >>= bBullet )
 561             {
 562                 SfxBoolItem aItem( EE_PARA_BULLETSTATE, bBullet );
 563                 rNewSet.Put(aItem);
 564                 return true;
 565             }
 566         }
 567         break;
 568
 569     default:
 570         return false;
 571     }
 572
 573     throw lang::IllegalArgumentException();
 574 }
 575
 576 uno::Any SAL_CALL SvxUnoTextRangeBase::getPropertyValue(const OUString& PropertyName)
 577 {
 578     if (PropertyName == UNO_TR_PROP_SELECTION)
 579     {
 580         const ESelection& rSel = GetSelection();
 581         text::TextRangeSelection aSel;
 582         aSel.Start.Paragraph = rSel.nStartPara;
 583         aSel.Start.PositionInParagraph = rSel.nStartPos;
 584         aSel.End.Paragraph = rSel.nEndPara;
 585         aSel.End.PositionInParagraph = rSel.nEndPos;
 586         return uno::makeAny(aSel);
 587     }
 588
 589     return _getPropertyValue( PropertyName );
 590 }
 591
 592 uno::Any SvxUnoTextRangeBase::_getPropertyValue(const OUString& PropertyName, sal_Int32 nPara )
 593 {
 594     SolarMutexGuard aGuard;
 595
 596     uno::Any aAny;
 597
 598     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 599     if( pForwarder )
 600     {
 601         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName );
 602         if( pMap )
 603         {
 604             std::unique_ptr<SfxItemSet> pAttribs;
 605             if( nPara != -1 )
 606                 pAttribs = pForwarder->GetParaAttribs( nPara ).Clone();
 607             else
 608                 pAttribs = pForwarder->GetAttribs( GetSelection() ).Clone();
 609
 610             //  Replace Dontcare with Default, so that one always has a mirror
 611             pAttribs->ClearInvalidItems();
 612
 613             getPropertyValue( pMap, aAny, *pAttribs );
 614
 615             return aAny;
 616         }
 617     }
 618
 619     throw beans::UnknownPropertyException(PropertyName);
 620 }
 621
 622 void SvxUnoTextRangeBase::getPropertyValue( const SfxItemPropertySimpleEntry* pMap, uno::Any& rAny, const SfxItemSet& rSet )
 623 {
 624     switch( pMap->nWID )
 625     {
 626     case EE_FEATURE_FIELD:
 627         if ( rSet.GetItemState( EE_FEATURE_FIELD, false ) == SfxItemState::SET )
 628         {
 629             const SvxFieldItem* pItem = rSet.GetItem<SvxFieldItem>( EE_FEATURE_FIELD );
 630             const SvxFieldData* pData = pItem->GetField();
 631             uno::Reference< text::XTextRange > xAnchor( this );
 632
 633             // get presentation string for field
 634             std::optional<Color> pTColor;
 635             std::optional<Color> pFColor;
 636
 637             SvxTextForwarder* pForwarder = mpEditSource->GetTextForwarder();
 638             OUString aPresentation( pForwarder->CalcFieldValue( SvxFieldItem(*pData, EE_FEATURE_FIELD), maSelection.nStartPara, maSelection.nStartPos, pTColor, pFColor ) );
 639
 640             uno::Reference< text::XTextField > xField( new SvxUnoTextField( xAnchor, aPresentation, pData ) );
 641             rAny <<= xField;
 642         }
 643         break;
 644
 645     case WID_PORTIONTYPE:
 646         if ( rSet.GetItemState( EE_FEATURE_FIELD, false ) == SfxItemState::SET )
 647         {
 648             rAny <<= OUString("TextField");
 649         }
 650         else
 651         {
 652             rAny <<= OUString("Text");
 653         }
 654         break;
 655
 656     default:
 657         if(!GetPropertyValueHelper( *const_cast<SfxItemSet*>(&rSet), pMap, rAny, &maSelection, GetEditSource() ))
 658             rAny = SvxItemPropertySet::getPropertyValue(pMap, rSet, true, false );
 659     }
 660 }
 661
 662 bool SvxUnoTextRangeBase::GetPropertyValueHelper(  SfxItemSet const & rSet, const SfxItemPropertySimpleEntry* pMap, uno::Any& aAny, const ESelection* pSelection /* = NULL */, SvxEditSource* pEditSource /* = NULL */ )
 663 {
 664     switch( pMap->nWID )
 665     {
 666     case WID_FONTDESC:
 667         {
 668             awt::FontDescriptor aDesc;
 669             SvxUnoFontDescriptor::FillFromItemSet( rSet, aDesc );
 670             aAny <<= aDesc;
 671         }
 672         break;
 673
 674     case EE_PARA_NUMBULLET:
 675         {
 676             SfxItemState eState = rSet.GetItemState( EE_PARA_NUMBULLET );
 677             if( eState != SfxItemState::SET && eState != SfxItemState::DEFAULT)
 678                 throw uno::RuntimeException();
 679
 680             const SvxNumBulletItem* pBulletItem = rSet.GetItem( EE_PARA_NUMBULLET );
 681
 682             if( pBulletItem == nullptr )
 683                 throw uno::RuntimeException();
 684
 685             aAny <<= SvxCreateNumRule( pBulletItem->GetNumRule() );
 686         }
 687         break;
 688
 689     case WID_NUMLEVEL:
 690         {
 691             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : nullptr;
 692             if(pForwarder && pSelection)
 693             {
 694                 sal_Int16 nLevel = pForwarder->GetDepth( pSelection->nStartPara );
 695                 if( nLevel >= 0 )
 696                     aAny <<= nLevel;
 697             }
 698         }
 699         break;
 700     case WID_NUMBERINGSTARTVALUE:
 701         {
 702             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : nullptr;
 703             if(pForwarder && pSelection)
 704                 aAny <<= pForwarder->GetNumberingStartValue( pSelection->nStartPara );
 705         }
 706         break;
 707     case WID_PARAISNUMBERINGRESTART:
 708         {
 709             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : nullptr;
 710             if(pForwarder && pSelection)
 711                 aAny <<= pForwarder->IsParaIsNumberingRestart( pSelection->nStartPara );
 712         }
 713         break;
 714
 715     case EE_PARA_BULLETSTATE:
 716         {
 717             bool bState = false;
 718             SfxItemState eState = rSet.GetItemState( EE_PARA_BULLETSTATE );
 719             if( eState == SfxItemState::SET || eState == SfxItemState::DEFAULT )
 720             {
 721                 const SfxBoolItem* pItem = rSet.GetItem<SfxBoolItem>( EE_PARA_BULLETSTATE );
 722                 bState = pItem->GetValue();
 723             }
 724
 725             aAny <<= bState;
 726         }
 727         break;
 728     default:
 729
 730         return false;
 731     }
 732
 733     return true;
 734 }
 735
 736 // is not (yet) supported
 737 void SAL_CALL SvxUnoTextRangeBase::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) {}
 738 void SAL_CALL SvxUnoTextRangeBase::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) {}
 739 void SAL_CALL SvxUnoTextRangeBase::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) {}
 740 void SAL_CALL SvxUnoTextRangeBase::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) {}
 741
 742 // XMultiPropertySet
 743 void SAL_CALL SvxUnoTextRangeBase::setPropertyValues( const uno::Sequence< OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues )
 744 {
 745     _setPropertyValues( aPropertyNames, aValues );
 746 }
 747
 748 void SvxUnoTextRangeBase::_setPropertyValues( const uno::Sequence< OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues, sal_Int32 nPara )
 749 {
 750     SolarMutexGuard aGuard;
 751
 752     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 753     if( !pForwarder )
 754         return;
 755
 756     CheckSelection( maSelection, pForwarder );
 757
 758     ESelection aSel( GetSelection() );
 759
 760     const OUString* pPropertyNames = aPropertyNames.getConstArray();
 761     const uno::Any* pValues = aValues.getConstArray();
 762     sal_Int32 nCount = aPropertyNames.getLength();
 763
 764     sal_Int32 nEndPara = nPara;
 765     sal_Int32 nTempPara = nPara;
 766
 767     if( nTempPara == -1 )
 768     {
 769         nTempPara = aSel.nStartPara;
 770         nEndPara = aSel.nEndPara;
 771     }
 772
 773     std::unique_ptr<SfxItemSet> pOldAttrSet;
 774     std::unique_ptr<SfxItemSet> pNewAttrSet;
 775
 776     std::unique_ptr<SfxItemSet> pOldParaSet;
 777     std::unique_ptr<SfxItemSet> pNewParaSet;
 778
 779     for( ; nCount; nCount--, pPropertyNames++, pValues++ )
 780     {
 781         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( *pPropertyNames );
 782
 783         if( pMap )
 784         {
 785             bool bParaAttrib = (pMap->nWID >= EE_PARA_START) && ( pMap->nWID <= EE_PARA_END );
 786
 787             if( (nPara == -1) && !bParaAttrib )
 788             {
 789                 if( nullptr == pNewAttrSet )
 790                 {
 791                     const SfxItemSet aSet( pForwarder->GetAttribs( aSel ) );
 792                     pOldAttrSet.reset(new SfxItemSet( aSet ));
 793                     pNewAttrSet.reset(new SfxItemSet( *pOldAttrSet->GetPool(), pOldAttrSet->GetRanges() ));
 794                 }
 795
 796                 setPropertyValue( pMap, *pValues, GetSelection(), *pOldAttrSet, *pNewAttrSet );
 797
 798                 if( pMap->nWID >= EE_ITEMS_START && pMap->nWID <= EE_ITEMS_END )
 799                 {
 800                     const SfxPoolItem* pItem;
 801                     if( pNewAttrSet->GetItemState( pMap->nWID, true, &pItem ) == SfxItemState::SET )
 802                     {
 803                         pOldAttrSet->Put( *pItem );
 804                     }
 805                 }
 806             }
 807             else
 808             {
 809                 if( nullptr == pNewParaSet )
 810                 {
 811                     const SfxItemSet & rSet = pForwarder->GetParaAttribs( nTempPara );
 812                     pOldParaSet.reset(new SfxItemSet( rSet ));
 813                     pNewParaSet.reset(new SfxItemSet( *pOldParaSet->GetPool(), pOldParaSet->GetRanges() ));
 814                 }
 815
 816                 setPropertyValue( pMap, *pValues, GetSelection(), *pOldParaSet, *pNewParaSet );
 817
 818                 if( pMap->nWID >= EE_ITEMS_START && pMap->nWID <= EE_ITEMS_END )
 819                 {
 820                     const SfxPoolItem* pItem;
 821                     if( pNewParaSet->GetItemState( pMap->nWID, true, &pItem ) == SfxItemState::SET )
 822                     {
 823                         pOldParaSet->Put( *pItem );
 824                     }
 825                 }
 826
 827             }
 828         }
 829     }
 830
 831     bool bNeedsUpdate = false;
 832
 833     if( pNewParaSet )
 834     {
 835         if( pNewParaSet->Count() )
 836         {
 837             while( nTempPara <= nEndPara )
 838             {
 839                 SfxItemSet aSet( pForwarder->GetParaAttribs( nTempPara ) );
 840                 aSet.Put( *pNewParaSet );
 841                 pForwarder->SetParaAttribs( nTempPara, aSet );
 842                 nTempPara++;
 843             }
 844             bNeedsUpdate = true;
 845         }
 846
 847         pNewParaSet.reset();
 848         pOldParaSet.reset();
 849     }
 850
 851     if( pNewAttrSet )
 852     {
 853         if( pNewAttrSet->Count() )
 854         {
 855             pForwarder->QuickSetAttribs( *pNewAttrSet, GetSelection() );
 856             bNeedsUpdate = true;
 857         }
 858         pNewAttrSet.reset();
 859         pOldAttrSet.reset();
 860     }
 861
 862     if( bNeedsUpdate )
 863         GetEditSource()->UpdateData();
 864 }
 865
 866 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextRangeBase::getPropertyValues( const uno::Sequence< OUString >& aPropertyNames )
 867 {
 868     return _getPropertyValues( aPropertyNames );
 869 }
 870
 871 uno::Sequence< uno::Any > SvxUnoTextRangeBase::_getPropertyValues( const uno::Sequence< OUString >& aPropertyNames, sal_Int32 nPara )
 872 {
 873     SolarMutexGuard aGuard;
 874
 875     sal_Int32 nCount = aPropertyNames.getLength();
 876
 877
 878     uno::Sequence< uno::Any > aValues( nCount );
 879
 880     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 881     if( pForwarder )
 882     {
 883         std::unique_ptr<SfxItemSet> pAttribs;
 884         if( nPara != -1 )
 885             pAttribs = pForwarder->GetParaAttribs( nPara ).Clone();
 886         else
 887             pAttribs = pForwarder->GetAttribs( GetSelection() ).Clone();
 888
 889         pAttribs->ClearInvalidItems();
 890
 891         const OUString* pPropertyNames = aPropertyNames.getConstArray();
 892         uno::Any* pValues = aValues.getArray();
 893
 894         for( ; nCount; nCount--, pPropertyNames++, pValues++ )
 895         {
 896             const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( *pPropertyNames );
 897             if( pMap )
 898             {
 899                 getPropertyValue( pMap, *pValues, *pAttribs );
 900             }
 901         }
 902     }
 903
 904     return aValues;
 905 }
 906
 907 void SAL_CALL SvxUnoTextRangeBase::addPropertiesChangeListener( const uno::Sequence< OUString >& , const uno::Reference< beans::XPropertiesChangeListener >& )
 908 {
 909 }
 910
 911 void SAL_CALL SvxUnoTextRangeBase::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& )
 912 {
 913 }
 914
 915 void SAL_CALL SvxUnoTextRangeBase::firePropertiesChangeEvent( const uno::Sequence< OUString >& , const uno::Reference< beans::XPropertiesChangeListener >& )
 916 {
 917 }
 918
 919 // beans::XPropertyState
 920 beans::PropertyState SAL_CALL SvxUnoTextRangeBase::getPropertyState( const OUString& PropertyName )
 921 {
 922     return _getPropertyState( PropertyName );
 923 }
 924
 925 const sal_uInt16 aSvxUnoFontDescriptorWhichMap[] = { EE_CHAR_FONTINFO, EE_CHAR_FONTHEIGHT, EE_CHAR_ITALIC,
 926                                                   EE_CHAR_UNDERLINE, EE_CHAR_WEIGHT, EE_CHAR_STRIKEOUT, EE_CHAR_CASEMAP,
 927                                                   EE_CHAR_WLM, 0 };
 928
 929 beans::PropertyState SvxUnoTextRangeBase::_getPropertyState(const SfxItemPropertySimpleEntry* pMap, sal_Int32 nPara)
 930 {
 931     if ( pMap )
 932     {
 933         SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
 934         if( pForwarder )
 935         {
 936             SfxItemState eItemState = SfxItemState::UNKNOWN;
 937             sal_uInt16 nWID = 0;
 938
 939             switch( pMap->nWID )
 940             {
 941             case WID_FONTDESC:
 942                 {
 943                     const sal_uInt16* pWhichId = aSvxUnoFontDescriptorWhichMap;
 944                     SfxItemState eTempItemState = SfxItemState::UNKNOWN;
 945                     while( *pWhichId )
 946                     {
 947                         if(nPara != -1)
 948                             eTempItemState = pForwarder->GetItemState( nPara, *pWhichId );
 949                         else
 950                             eTempItemState = pForwarder->GetItemState( GetSelection(), *pWhichId );
 951
 952                         switch( eTempItemState )
 953                         {
 954                         case SfxItemState::DISABLED:
 955                         case SfxItemState::DONTCARE:
 956                             eItemState = SfxItemState::DONTCARE;
 957                             break;
 958
 959                         case SfxItemState::DEFAULT:
 960                             if( eItemState != SfxItemState::DEFAULT )
 961                             {
 962                                 if( eItemState == SfxItemState::UNKNOWN )
 963                                     eItemState = SfxItemState::DEFAULT;
 964                             }
 965                             break;
 966
 967                         case SfxItemState::READONLY:
 968                         case SfxItemState::SET:
 969                             if( eItemState != SfxItemState::SET )
 970                             {
 971                                 if( eItemState == SfxItemState::UNKNOWN )
 972                                     eItemState = SfxItemState::SET;
 973                             }
 974                             break;
 975                         default:
 976                             throw beans::UnknownPropertyException();
 977                         }
 978
 979                         pWhichId++;
 980                     }
 981                 }
 982                 break;
 983
 984             case WID_NUMLEVEL:
 985             case WID_NUMBERINGSTARTVALUE:
 986             case WID_PARAISNUMBERINGRESTART:
 987                 eItemState = SfxItemState::SET;
 988                 break;
 989
 990             default:
 991                 nWID = pMap->nWID;
 992             }
 993
 994             if( nWID != 0 )
 995             {
 996                 if( nPara != -1 )
 997                     eItemState = pForwarder->GetItemState( nPara, nWID );
 998                 else
 999                     eItemState = pForwarder->GetItemState( GetSelection(), nWID );
1000             }
1001
1002             switch( eItemState )
1003             {
1004             case SfxItemState::DONTCARE:
1005             case SfxItemState::DISABLED:
1006                 return beans::PropertyState_AMBIGUOUS_VALUE;
1007             case SfxItemState::READONLY:
1008             case SfxItemState::SET:
1009                 return beans::PropertyState_DIRECT_VALUE;
1010             case SfxItemState::DEFAULT:
1011                 return beans::PropertyState_DEFAULT_VALUE;
1012             default: break;
1013 //              case SfxItemState::UNKNOWN:
1014             }
1015         }
1016     }
1017     throw beans::UnknownPropertyException();
1018 }
1019
1020 beans::PropertyState SvxUnoTextRangeBase::_getPropertyState(const OUString& PropertyName, sal_Int32 nPara /* = -1 */)
1021 {
1022     SolarMutexGuard aGuard;
1023
1024     return _getPropertyState( mpPropSet->getPropertyMapEntry( PropertyName ), nPara);
1025 }
1026
1027 uno::Sequence< beans::PropertyState > SAL_CALL SvxUnoTextRangeBase::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
1028 {
1029     return _getPropertyStates( aPropertyName );
1030 }
1031
1032 uno::Sequence< beans::PropertyState > SvxUnoTextRangeBase::_getPropertyStates(const uno::Sequence< OUString >& PropertyName, sal_Int32 nPara /* = -1 */)
1033 {
1034     uno::Sequence< beans::PropertyState > aRet( PropertyName.getLength() );
1035
1036     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
1037     if( pForwarder )
1038     {
1039         std::unique_ptr<SfxItemSet> pSet;
1040         if( nPara != -1 )
1041         {
1042             pSet.reset(new SfxItemSet( pForwarder->GetParaAttribs( nPara ) ));
1043         }
1044         else
1045         {
1046             ESelection aSel( GetSelection() );
1047             CheckSelection( aSel, pForwarder );
1048             pSet.reset(new SfxItemSet( pForwarder->GetAttribs( aSel, EditEngineAttribs::OnlyHard ) ));
1049         }
1050
1051         beans::PropertyState* pState = aRet.getArray();
1052         for( const OUString& rName : PropertyName )
1053         {
1054             const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( rName );
1055             if( !_getOnePropertyStates(pSet.get(), pMap, *pState++) )
1056             {
1057                 throw beans::UnknownPropertyException(rName);
1058             }
1059         }
1060     }
1061
1062     return aRet;
1063 }
1064
1065 bool SvxUnoTextRangeBase::_getOnePropertyStates(const SfxItemSet* pSet, const SfxItemPropertySimpleEntry* pMap, beans::PropertyState& rState)
1066 {
1067     bool bUnknownPropertyFound = false;
1068     if(pSet && pMap)
1069     {
1070         SfxItemState eItemState = SfxItemState::UNKNOWN;
1071         sal_uInt16 nWID = 0;
1072
1073         switch( pMap->nWID )
1074         {
1075             case WID_FONTDESC:
1076                 {
1077                     const sal_uInt16* pWhichId = aSvxUnoFontDescriptorWhichMap;
1078                     SfxItemState eTempItemState = SfxItemState::UNKNOWN;
1079                     while( *pWhichId )
1080                     {
1081                         eTempItemState = pSet->GetItemState( *pWhichId );
1082
1083                         switch( eTempItemState )
1084                         {
1085                         case SfxItemState::DISABLED:
1086                         case SfxItemState::DONTCARE:
1087                             eItemState = SfxItemState::DONTCARE;
1088                             break;
1089
1090                         case SfxItemState::DEFAULT:
1091                             if( eItemState != SfxItemState::DEFAULT )
1092                             {
1093                                 if( eItemState == SfxItemState::UNKNOWN )
1094                                     eItemState = SfxItemState::DEFAULT;
1095                             }
1096                             break;
1097
1098                         case SfxItemState::READONLY:
1099                         case SfxItemState::SET:
1100                             if( eItemState != SfxItemState::SET )
1101                             {
1102                                 if( eItemState == SfxItemState::UNKNOWN )
1103                                     eItemState = SfxItemState::SET;
1104                             }
1105                             break;
1106                         default:
1107                             bUnknownPropertyFound = true;
1108                             break;
1109                         }
1110
1111                         pWhichId++;
1112                     }
1113                 }
1114                 break;
1115
1116             case WID_NUMLEVEL:
1117             case WID_NUMBERINGSTARTVALUE:
1118             case WID_PARAISNUMBERINGRESTART:
1119                 eItemState = SfxItemState::SET;
1120                 break;
1121
1122             default:
1123                 nWID = pMap->nWID;
1124         }
1125
1126         if( bUnknownPropertyFound )
1127             return false;
1128
1129         if( nWID != 0 )
1130             eItemState = pSet->GetItemState( nWID, false );
1131
1132         switch( eItemState )
1133         {
1134                 case SfxItemState::READONLY:
1135                 case SfxItemState::SET:
1136                     rState = beans::PropertyState_DIRECT_VALUE;
1137                     break;
1138                 case SfxItemState::DEFAULT:
1139                     rState = beans::PropertyState_DEFAULT_VALUE;
1140                     break;
1141 //                  case SfxItemState::UNKNOWN:
1142 //                  case SfxItemState::DONTCARE:
1143 //                  case SfxItemState::DISABLED:
1144                 default:
1145                     rState = beans::PropertyState_AMBIGUOUS_VALUE;
1146         }
1147     }
1148     return true;
1149 }
1150
1151 void SAL_CALL SvxUnoTextRangeBase::setPropertyToDefault( const OUString& PropertyName )
1152 {
1153     _setPropertyToDefault( PropertyName );
1154 }
1155
1156 void SvxUnoTextRangeBase::_setPropertyToDefault(const OUString& PropertyName, sal_Int32 nPara /* = -1 */)
1157 {
1158     SolarMutexGuard aGuard;
1159
1160     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
1161
1162     if( pForwarder )
1163     {
1164         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( PropertyName );
1165         if ( pMap )
1166         {
1167             CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1168             _setPropertyToDefault( pForwarder, pMap, nPara );
1169             return;
1170         }
1171     }
1172
1173     throw beans::UnknownPropertyException(PropertyName);
1174 }
1175
1176 void SvxUnoTextRangeBase::_setPropertyToDefault(SvxTextForwarder* pForwarder, const SfxItemPropertySimpleEntry* pMap, sal_Int32 nPara )
1177 {
1178     do
1179     {
1180         SfxItemSet aSet(*pForwarder->GetPool());
1181
1182         if( pMap->nWID == WID_FONTDESC )
1183         {
1184             SvxUnoFontDescriptor::setPropertyToDefault( aSet );
1185         }
1186         else if( pMap->nWID == WID_NUMLEVEL )
1187         {
1188             // #101004# Call interface method instead of unsafe cast
1189             pForwarder->SetDepth( maSelection.nStartPara, -1 );
1190             return;
1191         }
1192         else if( pMap->nWID == WID_NUMBERINGSTARTVALUE )
1193         {
1194             pForwarder->SetNumberingStartValue( maSelection.nStartPara, -1 );
1195         }
1196         else if( pMap->nWID == WID_PARAISNUMBERINGRESTART )
1197         {
1198             pForwarder->SetParaIsNumberingRestart( maSelection.nStartPara, false );
1199         }
1200         else
1201         {
1202             aSet.InvalidateItem( pMap->nWID );
1203         }
1204
1205         if(nPara != -1)
1206             pForwarder->SetParaAttribs( nPara, aSet );
1207         else
1208             pForwarder->QuickSetAttribs( aSet, GetSelection() );
1209
1210         GetEditSource()->UpdateData();
1211
1212         return;
1213     }
1214     while(false);
1215 }
1216
1217 uno::Any SAL_CALL SvxUnoTextRangeBase::getPropertyDefault( const OUString& aPropertyName )
1218 {
1219     SolarMutexGuard aGuard;
1220
1221     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
1222     if( pForwarder )
1223     {
1224         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( aPropertyName );
1225         if( pMap )
1226         {
1227             SfxItemPool* pPool = pForwarder->GetPool();
1228
1229             switch( pMap->nWID )
1230             {
1231             case WID_FONTDESC:
1232                 return SvxUnoFontDescriptor::getPropertyDefault( pPool );
1233
1234             case WID_NUMLEVEL:
1235                 {
1236                     uno::Any aAny;
1237                     return aAny;
1238                 }
1239
1240             case WID_NUMBERINGSTARTVALUE:
1241                 return uno::Any( sal_Int16(-1) );
1242
1243             case WID_PARAISNUMBERINGRESTART:
1244                 return uno::Any( false );
1245
1246             default:
1247                 {
1248                     // Get Default from ItemPool
1249                     if(SfxItemPool::IsWhich(pMap->nWID))
1250                     {
1251                         SfxItemSet aSet( *pPool,    {{pMap->nWID, pMap->nWID}});
1252                         aSet.Put(pPool->GetDefaultItem(pMap->nWID));
1253                         return SvxItemPropertySet::getPropertyValue(pMap, aSet, true, false );
1254                     }
1255                 }
1256             }
1257         }
1258     }
1259     throw beans::UnknownPropertyException(aPropertyName);
1260 }
1261
1262 // beans::XMultiPropertyStates
1263 void SAL_CALL SvxUnoTextRangeBase::setAllPropertiesToDefault()
1264 {
1265     SolarMutexGuard aGuard;
1266
1267     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
1268
1269     if( pForwarder )
1270     {
1271         for (auto & entry : mpPropSet->getPropertyMap().getPropertyEntries())
1272         {
1273             _setPropertyToDefault( pForwarder, &entry, -1 );
1274         }
1275     }
1276 }
1277
1278 void SAL_CALL SvxUnoTextRangeBase::setPropertiesToDefault( const uno::Sequence< OUString >& aPropertyNames )
1279 {
1280     for( const OUString& rName : aPropertyNames )
1281     {
1282         setPropertyToDefault( rName );
1283     }
1284 }
1285
1286 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextRangeBase::getPropertyDefaults( const uno::Sequence< OUString >& aPropertyNames )
1287 {
1288     uno::Sequence< uno::Any > ret( aPropertyNames.getLength() );
1289     uno::Any* pDefaults = ret.getArray();
1290
1291     for( const OUString& rName : aPropertyNames )
1292     {
1293         *pDefaults++ = getPropertyDefault( rName );
1294     }
1295
1296     return ret;
1297 }
1298
1299 // internal
1300 void SvxUnoTextRangeBase::CollapseToStart() throw()
1301 {
1302     CheckSelection( maSelection, mpEditSource.get() );
1303
1304     maSelection.nEndPara = maSelection.nStartPara;
1305     maSelection.nEndPos  = maSelection.nStartPos;
1306 }
1307
1308 void SvxUnoTextRangeBase::CollapseToEnd() throw()
1309 {
1310     CheckSelection( maSelection, mpEditSource.get() );
1311
1312     maSelection.nStartPara = maSelection.nEndPara;
1313     maSelection.nStartPos  = maSelection.nEndPos;
1314 }
1315
1316 bool SvxUnoTextRangeBase::IsCollapsed() throw()
1317 {
1318     CheckSelection( maSelection, mpEditSource.get() );
1319
1320     return ( maSelection.nStartPara == maSelection.nEndPara &&
1321              maSelection.nStartPos  == maSelection.nEndPos );
1322 }
1323
1324 bool SvxUnoTextRangeBase::GoLeft(sal_Int16 nCount, bool Expand) throw()
1325 {
1326     CheckSelection( maSelection, mpEditSource.get() );
1327
1328     //  #75098# use end position, as in Writer (start is anchor, end is cursor)
1329     sal_uInt16 nNewPos = maSelection.nEndPos;
1330     sal_Int32  nNewPar = maSelection.nEndPara;
1331
1332     bool bOk = true;
1333     SvxTextForwarder* pForwarder = nullptr;
1334     while ( nCount > nNewPos && bOk )
1335     {
1336         if ( nNewPar == 0 )
1337             bOk = false;
1338         else
1339         {
1340             if ( !pForwarder )
1341                 pForwarder = mpEditSource->GetTextForwarder();  // first here, it is necessary...
1342
1343             --nNewPar;
1344             nCount -= nNewPos + 1;
1345             nNewPos = pForwarder->GetTextLen( nNewPar );
1346         }
1347     }
1348
1349     if ( bOk )
1350     {
1351         nNewPos = nNewPos - nCount;
1352         maSelection.nStartPara = nNewPar;
1353         maSelection.nStartPos  = nNewPos;
1354     }
1355
1356     if (!Expand)
1357         CollapseToStart();
1358
1359     return bOk;
1360 }
1361
1362 bool SvxUnoTextRangeBase::GoRight(sal_Int16 nCount, bool Expand)  throw()
1363 {
1364     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
1365     if( pForwarder )
1366     {
1367         CheckSelection( maSelection, pForwarder );
1368
1369         sal_Int32 nNewPos = maSelection.nEndPos + nCount; //! Overflow???
1370         sal_Int32  nNewPar = maSelection.nEndPara;
1371
1372         bool bOk = true;
1373         sal_Int32 nParCount = pForwarder->GetParagraphCount();
1374         sal_Int32 nThisLen = pForwarder->GetTextLen( nNewPar );
1375         while ( nNewPos > nThisLen && bOk )
1376         {
1377             if ( nNewPar + 1 >= nParCount )
1378                 bOk = false;
1379             else
1380             {
1381                 nNewPos -= nThisLen+1;
1382                 ++nNewPar;
1383                 nThisLen = pForwarder->GetTextLen( nNewPar );
1384             }
1385         }
1386
1387         if (bOk)
1388         {
1389             maSelection.nEndPara = nNewPar;
1390             maSelection.nEndPos  = nNewPos;
1391         }
1392
1393         if (!Expand)
1394             CollapseToEnd();
1395
1396         return bOk;
1397     }
1398     return false;
1399 }
1400
1401 void SvxUnoTextRangeBase::GotoStart(bool Expand) throw()
1402 {
1403     maSelection.nStartPara = 0;
1404     maSelection.nStartPos  = 0;
1405
1406     if (!Expand)
1407         CollapseToStart();
1408 }
1409
1410 void SvxUnoTextRangeBase::GotoEnd(bool Expand) throw()
1411 {
1412     CheckSelection( maSelection, mpEditSource.get() );
1413
1414     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
1415     if( !pForwarder )
1416         return;
1417
1418     sal_Int32 nPar = pForwarder->GetParagraphCount();
1419     if (nPar)
1420         --nPar;
1421
1422     maSelection.nEndPara = nPar;
1423     maSelection.nEndPos  = pForwarder->GetTextLen( nPar );
1424
1425     if (!Expand)
1426         CollapseToEnd();
1427 }
1428
1429 // lang::XServiceInfo
1430 sal_Bool SAL_CALL SvxUnoTextRangeBase::supportsService( const OUString& ServiceName )
1431 {
1432     return cppu::supportsService( this, ServiceName );
1433 }
1434
1435 uno::Sequence< OUString > SAL_CALL SvxUnoTextRangeBase::getSupportedServiceNames()
1436 {
1437     return getSupportedServiceNames_Static();
1438 }
1439
1440 uno::Sequence< OUString > SvxUnoTextRangeBase::getSupportedServiceNames_Static()
1441 {
1442     return { "com.sun.star.style.CharacterProperties",
1443              "com.sun.star.style.CharacterPropertiesComplex",
1444              "com.sun.star.style.CharacterPropertiesAsian" };
1445 }
1446
1447 // XTextRangeCompare
1448 sal_Int16 SAL_CALL SvxUnoTextRangeBase::compareRegionStarts( const uno::Reference< text::XTextRange >& xR1, const uno::Reference< text::XTextRange >& xR2 )
1449 {
1450     SvxUnoTextRangeBase* pR1 = comphelper::getUnoTunnelImplementation<SvxUnoTextRangeBase>( xR1 );
1451     SvxUnoTextRangeBase* pR2 = comphelper::getUnoTunnelImplementation<SvxUnoTextRangeBase>( xR2 );
1452
1453     if( (pR1 == nullptr) || (pR2 == nullptr) )
1454         throw lang::IllegalArgumentException();
1455
1456     const ESelection& r1 = pR1->maSelection;
1457     const ESelection& r2 = pR2->maSelection;
1458
1459     if( r1.nStartPara == r2.nStartPara )
1460     {
1461         if( r1.nStartPos == r2.nStartPos )
1462             return 0;
1463         else
1464             return r1.nStartPos < r2.nStartPos ? 1 : -1;
1465     }
1466     else
1467     {
1468         return r1.nStartPara < r2.nStartPara ? 1 : -1;
1469     }
1470 }
1471
1472 sal_Int16 SAL_CALL SvxUnoTextRangeBase::compareRegionEnds( const uno::Reference< text::XTextRange >& xR1, const uno::Reference< text::XTextRange >& xR2 )
1473 {
1474     SvxUnoTextRangeBase* pR1 = comphelper::getUnoTunnelImplementation<SvxUnoTextRangeBase>( xR1 );
1475     SvxUnoTextRangeBase* pR2 = comphelper::getUnoTunnelImplementation<SvxUnoTextRangeBase>( xR2 );
1476
1477     if( (pR1 == nullptr) || (pR2 == nullptr) )
1478         throw lang::IllegalArgumentException();
1479
1480     const ESelection& r1 = pR1->maSelection;
1481     const ESelection& r2 = pR2->maSelection;
1482
1483     if( r1.nEndPara == r2.nEndPara )
1484     {
1485         if( r1.nEndPos == r2.nEndPos )
1486             return 0;
1487         else
1488             return r1.nEndPos < r2.nEndPos ? 1 : -1;
1489     }
1490     else
1491     {
1492         return r1.nEndPara < r2.nEndPara ? 1 : -1;
1493     }
1494 }
1495
1496 SvxUnoTextRange::SvxUnoTextRange(const SvxUnoTextBase& rParent, bool bPortion /* = false */)
1497 :SvxUnoTextRangeBase( rParent.GetEditSource(), bPortion ? ImplGetSvxTextPortionSvxPropertySet() : rParent.getPropertySet() ),
1498  mbPortion( bPortion )
1499 {
1500     xParentText =  static_cast<text::XText*>(const_cast<SvxUnoTextBase *>(&rParent));
1501 }
1502
1503 SvxUnoTextRange::~SvxUnoTextRange() throw()
1504 {
1505 }
1506
1507 uno::Any SAL_CALL SvxUnoTextRange::queryAggregation( const uno::Type & rType )
1508 {
1509     QUERYINT( text::XTextRange );
1510     else if( rType == cppu::UnoType<beans::XMultiPropertyStates>::get())
1511         return uno::makeAny(uno::Reference< beans::XMultiPropertyStates >(this));
1512     else if( rType == cppu::UnoType<beans::XPropertySet>::get())
1513         return uno::makeAny(uno::Reference< beans::XPropertySet >(this));
1514     else QUERYINT( beans::XPropertyState );
1515     else QUERYINT( text::XTextRangeCompare );
1516     else if( rType == cppu::UnoType<beans::XMultiPropertySet>::get())
1517         return uno::makeAny(uno::Reference< beans::XMultiPropertySet >(this));
1518     else QUERYINT( lang::XServiceInfo );
1519     else QUERYINT( lang::XTypeProvider );
1520     else QUERYINT( lang::XUnoTunnel );
1521     else
1522         return OWeakAggObject::queryAggregation( rType );
1523 }
1524
1525 uno::Any SAL_CALL SvxUnoTextRange::queryInterface( const uno::Type & rType )
1526 {
1527     return OWeakAggObject::queryInterface(rType);
1528 }
1529
1530 void SAL_CALL SvxUnoTextRange::acquire()
1531     throw( )
1532 {
1533     OWeakAggObject::acquire();
1534 }
1535
1536 void SAL_CALL SvxUnoTextRange::release()
1537     throw( )
1538 {
1539     OWeakAggObject::release();
1540 }
1541
1542 // XTypeProvider
1543
1544 namespace
1545 {
1546     struct theSvxUnoTextRangeTypes :
1547         public rtl::StaticWithInit<uno::Sequence<uno::Type>, theSvxUnoTextRangeTypes>
1548     {
1549         uno::Sequence<uno::Type> operator () ()
1550         {
1551             uno::Sequence< uno::Type > aTypeSequence;
1552
1553             aTypeSequence.realloc( 9 ); // !DANGER! keep this updated
1554             uno::Type* pTypes = aTypeSequence.getArray();
1555
1556             *pTypes++ = cppu::UnoType<text::XTextRange>::get();
1557             *pTypes++ = cppu::UnoType<beans::XPropertySet>::get();
1558             *pTypes++ = cppu::UnoType<beans::XMultiPropertySet>::get();
1559             *pTypes++ = cppu::UnoType<beans::XMultiPropertyStates>::get();
1560             *pTypes++ = cppu::UnoType<beans::XPropertyState>::get();
1561             *pTypes++ = cppu::UnoType<lang::XServiceInfo>::get();
1562             *pTypes++ = cppu::UnoType<lang::XTypeProvider>::get();
1563             *pTypes++ = cppu::UnoType<lang::XUnoTunnel>::get();
1564             *pTypes++ = cppu::UnoType<text::XTextRangeCompare>::get();
1565
1566             return aTypeSequence;
1567         }
1568     };
1569 }
1570
1571 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextRange::getTypes()
1572 {
1573     return theSvxUnoTextRangeTypes::get();
1574 }
1575
1576 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoTextRange::getImplementationId()
1577 {
1578     return css::uno::Sequence<sal_Int8>();
1579 }
1580
1581 // XTextRange
1582 uno::Reference< text::XText > SAL_CALL SvxUnoTextRange::getText()
1583 {
1584     return xParentText;
1585 }
1586
1587 // lang::XServiceInfo
1588 OUString SAL_CALL SvxUnoTextRange::getImplementationName()
1589 {
1590     return "SvxUnoTextRange";
1591 }
1592
1593
1594
1595
1596 SvxUnoTextBase::SvxUnoTextBase(const SvxItemPropertySet* _pSet)
1597     : SvxUnoTextRangeBase(_pSet)
1598 {
1599 }
1600
1601 SvxUnoTextBase::SvxUnoTextBase(const SvxEditSource* pSource, const SvxItemPropertySet* _pSet, uno::Reference < text::XText > const & xParent)
1602     : SvxUnoTextRangeBase(pSource, _pSet)
1603 {
1604     xParentText = xParent;
1605     ESelection aSelection;
1606     ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1607     SetSelection( aSelection );
1608 }
1609
1610 SvxUnoTextBase::SvxUnoTextBase(const SvxUnoTextBase& rText)
1611 :   SvxUnoTextRangeBase( rText )
1612 , text::XTextAppend()
1613 ,   text::XTextCopy()
1614 ,   container::XEnumerationAccess()
1615 ,   text::XTextRangeMover()
1616 ,   lang::XTypeProvider()
1617 {
1618     xParentText = rText.xParentText;
1619 }
1620
1621 SvxUnoTextBase::~SvxUnoTextBase() throw()
1622 {
1623 }
1624
1625 // XInterface
1626 uno::Any SAL_CALL SvxUnoTextBase::queryAggregation( const uno::Type & rType )
1627 {
1628     QUERYINT( text::XText );
1629     QUERYINT( text::XSimpleText );
1630     if( rType == cppu::UnoType<text::XTextRange>::get())
1631         return uno::makeAny(uno::Reference< text::XTextRange >(static_cast<text::XText*>(this)));
1632     QUERYINT(container::XEnumerationAccess );
1633     QUERYINT( container::XElementAccess );
1634     QUERYINT( beans::XMultiPropertyStates );
1635     QUERYINT( beans::XPropertySet );
1636     QUERYINT( beans::XMultiPropertySet );
1637     QUERYINT( beans::XPropertyState );
1638     QUERYINT( text::XTextRangeCompare );
1639     QUERYINT( lang::XServiceInfo );
1640     QUERYINT( text::XTextRangeMover );
1641     QUERYINT( text::XTextCopy );
1642     QUERYINT( text::XTextAppend );
1643     QUERYINT( text::XParagraphAppend );
1644     QUERYINT( text::XTextPortionAppend );
1645     QUERYINT( lang::XTypeProvider );
1646     QUERYINT( lang::XUnoTunnel );
1647
1648     return uno::Any();
1649 }
1650
1651 // XTypeProvider
1652
1653 namespace
1654 {
1655     struct theSvxUnoTextBaseTypes :
1656         public rtl::StaticWithInit<uno::Sequence<uno::Type>, theSvxUnoTextBaseTypes>
1657     {
1658         uno::Sequence<uno::Type> operator () ()
1659         {
1660             uno::Sequence< uno::Type > aTypeSequence;
1661
1662             aTypeSequence.realloc( 15 ); // !DANGER! keep this updated
1663             uno::Type* pTypes = aTypeSequence.getArray();
1664
1665             *pTypes++ = cppu::UnoType<text::XText>::get();
1666             *pTypes++ = cppu::UnoType<container::XEnumerationAccess>::get();
1667             *pTypes++ = cppu::UnoType<beans::XPropertySet>::get();
1668             *pTypes++ = cppu::UnoType<beans::XMultiPropertySet>::get();
1669             *pTypes++ = cppu::UnoType<beans::XMultiPropertyStates>::get();
1670             *pTypes++ = cppu::UnoType<beans::XPropertyState>::get();
1671             *pTypes++ = cppu::UnoType<text::XTextRangeMover>::get();
1672             *pTypes++ = cppu::UnoType<text::XTextAppend>::get();
1673             *pTypes++ = cppu::UnoType<text::XTextCopy>::get();
1674             *pTypes++ = cppu::UnoType<text::XParagraphAppend>::get();
1675             *pTypes++ = cppu::UnoType<text::XTextPortionAppend>::get();
1676             *pTypes++ = cppu::UnoType<lang::XServiceInfo>::get();
1677             *pTypes++ = cppu::UnoType<lang::XTypeProvider>::get();
1678             *pTypes++ = cppu::UnoType<lang::XUnoTunnel>::get();
1679             *pTypes++ = cppu::UnoType<text::XTextRangeCompare>::get();
1680
1681             return aTypeSequence;
1682         }
1683     };
1684 }
1685
1686 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextBase::getTypes()
1687 {
1688     return theSvxUnoTextBaseTypes::get();
1689 }
1690
1691 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoTextBase::getImplementationId()
1692 {
1693     return css::uno::Sequence<sal_Int8>();
1694 }
1695
1696 uno::Reference< text::XTextCursor > SvxUnoTextBase::createTextCursorBySelection( const ESelection& rSel )
1697 {
1698     SvxUnoTextCursor* pCursor = new SvxUnoTextCursor( *this );
1699     uno::Reference< text::XTextCursor >  xCursor( pCursor );
1700     pCursor->SetSelection( rSel );
1701     return xCursor;
1702 }
1703
1704 // XSimpleText
1705
1706 uno::Reference< text::XTextCursor > SAL_CALL SvxUnoTextBase::createTextCursor()
1707 {
1708     SolarMutexGuard aGuard;
1709     return new SvxUnoTextCursor( *this );
1710 }
1711
1712 uno::Reference< text::XTextCursor > SAL_CALL SvxUnoTextBase::createTextCursorByRange( const uno::Reference< text::XTextRange >& aTextPosition )
1713 {
1714     SolarMutexGuard aGuard;
1715
1716     uno::Reference< text::XTextCursor >  xCursor;
1717
1718     if( aTextPosition.is() )
1719     {
1720         SvxUnoTextRangeBase* pRange = comphelper::getUnoTunnelImplementation<SvxUnoTextRangeBase>( aTextPosition );
1721         if(pRange)
1722             xCursor = createTextCursorBySelection( pRange->GetSelection() );
1723     }
1724
1725     return xCursor;
1726 }
1727
1728 void SAL_CALL SvxUnoTextBase::insertString( const uno::Reference< text::XTextRange >& xRange, const OUString& aString, sal_Bool bAbsorb )
1729 {
1730     SolarMutexGuard aGuard;
1731
1732     if( !xRange.is() )
1733         return;
1734
1735     SvxUnoTextRangeBase* pRange = comphelper::getUnoTunnelImplementation<SvxUnoTextRange>( xRange );
1736     if(!pRange)
1737         return;
1738
1739     // setString on SvxUnoTextRangeBase instead of itself QuickInsertText
1740     // and UpdateData, so that the selection will be adjusted to
1741     // SvxUnoTextRangeBase. Actually all cursor objects of this Text must
1742     // to be statement to be adapted!
1743
1744     if (!bAbsorb)                   // do not replace -> append on tail
1745         pRange->CollapseToEnd();
1746
1747     pRange->setString( aString );
1748
1749     pRange->CollapseToEnd();
1750
1751     if (GetEditSource())
1752     {
1753         ESelection aSelection;
1754         ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1755         SetSelection( aSelection );
1756     }
1757 }
1758
1759 void SAL_CALL SvxUnoTextBase::insertControlCharacter( const uno::Reference< text::XTextRange >& xRange, sal_Int16 nControlCharacter, sal_Bool bAbsorb )
1760 {
1761     SolarMutexGuard aGuard;
1762
1763     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : nullptr;
1764
1765     if( !pForwarder )
1766         return;
1767
1768     ESelection aSelection;
1769     ::GetSelection( aSelection, pForwarder );
1770     SetSelection( aSelection );
1771
1772     switch( nControlCharacter )
1773     {
1774     case text::ControlCharacter::PARAGRAPH_BREAK:
1775     {
1776         insertString( xRange, "\x0D", bAbsorb );
1777
1778         return;
1779     }
1780     case text::ControlCharacter::LINE_BREAK:
1781     {
1782         SvxUnoTextRangeBase* pRange = comphelper::getUnoTunnelImplementation<SvxUnoTextRange>( xRange );
1783         if(pRange)
1784         {
1785             ESelection aRange = pRange->GetSelection();
1786
1787             if( bAbsorb )
1788             {
1789                 pForwarder->QuickInsertText( "", aRange );
1790
1791                 aRange.nEndPos = aRange.nStartPos;
1792                 aRange.nEndPara = aRange.nStartPara;
1793             }
1794             else
1795             {
1796                 aRange.nStartPara = aRange.nEndPara;
1797                 aRange.nStartPos = aRange.nEndPos;
1798             }
1799
1800             pForwarder->QuickInsertLineBreak( aRange );
1801             GetEditSource()->UpdateData();
1802
1803             aRange.nEndPos += 1;
1804             if( !bAbsorb )
1805                 aRange.nStartPos += 1;
1806
1807             pRange->SetSelection( aRange );
1808         }
1809         return;
1810     }
1811     case text::ControlCharacter::APPEND_PARAGRAPH:
1812     {
1813         SvxUnoTextRangeBase* pRange = comphelper::getUnoTunnelImplementation<SvxUnoTextRange>( xRange );
1814         if(pRange)
1815         {
1816             ESelection aRange = pRange->GetSelection();
1817 //              ESelection aOldSelection = aRange;
1818
1819             aRange.nStartPos  = pForwarder->GetTextLen( aRange.nStartPara );
1820
1821             aRange.nEndPara = aRange.nStartPara;
1822             aRange.nEndPos  = aRange.nStartPos;
1823
1824             pRange->SetSelection( aRange );
1825             pRange->setString( "\x0D" );
1826
1827             aRange.nStartPos = 0;
1828             aRange.nStartPara += 1;
1829             aRange.nEndPos = 0;
1830             aRange.nEndPara += 1;
1831
1832             pRange->SetSelection( aRange );
1833
1834             return;
1835         }
1836         [[fallthrough]];
1837     }
1838     default:
1839         throw lang::IllegalArgumentException();
1840     }
1841 }
1842
1843 // XText
1844 void SAL_CALL SvxUnoTextBase::insertTextContent( const uno::Reference< text::XTextRange >& xRange, const uno::Reference< text::XTextContent >& xContent, sal_Bool bAbsorb )
1845 {
1846     SolarMutexGuard aGuard;
1847
1848     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : nullptr;
1849     if (!pForwarder)
1850         return;
1851
1852     uno::Reference<beans::XPropertySet> xPropSet(xRange, uno::UNO_QUERY);
1853     if (!xPropSet.is())
1854         throw lang::IllegalArgumentException();
1855
1856     uno::Any aAny = xPropSet->getPropertyValue(UNO_TR_PROP_SELECTION);
1857     text::TextRangeSelection aSel = aAny.get<text::TextRangeSelection>();
1858     if (!bAbsorb)
1859         aSel.Start = aSel.End;
1860
1861     std::unique_ptr<SvxFieldData> pFieldData(SvxFieldData::Create(xContent));
1862     if (!pFieldData)
1863         throw lang::IllegalArgumentException();
1864
1865     SvxFieldItem aField( *pFieldData, EE_FEATURE_FIELD );
1866     pForwarder->QuickInsertField(aField, toESelection(aSel));
1867     GetEditSource()->UpdateData();
1868
1869     uno::Reference<beans::XPropertySet> xPropSetContent(xContent, uno::UNO_QUERY);
1870     if (!xContent.is())
1871         throw lang::IllegalArgumentException();
1872
1873     xPropSetContent->setPropertyValue(UNO_TC_PROP_ANCHOR, uno::makeAny(xRange));
1874
1875     aSel.End.PositionInParagraph += 1;
1876     aSel.Start.PositionInParagraph = aSel.End.PositionInParagraph;
1877     xPropSet->setPropertyValue(UNO_TR_PROP_SELECTION, uno::makeAny(aSel));
1878 }
1879
1880 void SAL_CALL SvxUnoTextBase::removeTextContent( const uno::Reference< text::XTextContent >& )
1881 {
1882 }
1883
1884 // XTextRange
1885
1886 uno::Reference< text::XText > SAL_CALL SvxUnoTextBase::getText()
1887 {
1888     SolarMutexGuard aGuard;
1889
1890     if (GetEditSource())
1891     {
1892         ESelection aSelection;
1893         ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1894         SetSelection( aSelection );
1895     }
1896
1897     return static_cast<text::XText*>(this);
1898 }
1899
1900 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::getStart()
1901 {
1902     return SvxUnoTextRangeBase::getStart();
1903 }
1904
1905 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::getEnd()
1906 {
1907     return SvxUnoTextRangeBase::getEnd();
1908 }
1909
1910 OUString SAL_CALL SvxUnoTextBase::getString()
1911 {
1912     return SvxUnoTextRangeBase::getString();
1913 }
1914
1915 void SAL_CALL SvxUnoTextBase::setString( const OUString& aString )
1916 {
1917     SvxUnoTextRangeBase::setString(aString);
1918 }
1919
1920
1921 // XEnumerationAccess
1922 uno::Reference< container::XEnumeration > SAL_CALL SvxUnoTextBase::createEnumeration()
1923 {
1924     SolarMutexGuard aGuard;
1925     if( maSelection == ESelection(0,0,0,0) || maSelection == ESelection(EE_PARA_MAX_COUNT,0,0,0) )
1926     {
1927         ESelection aSelection;
1928         ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1929         return new SvxUnoTextContentEnumeration(*this, aSelection);
1930     }
1931     else
1932     {
1933         return new SvxUnoTextContentEnumeration(*this, maSelection);
1934     }
1935 }
1936
1937 // XElementAccess ( container::XEnumerationAccess )
1938 uno::Type SAL_CALL SvxUnoTextBase::getElementType(  )
1939 {
1940     return cppu::UnoType<text::XTextRange>::get();
1941 }
1942
1943 sal_Bool SAL_CALL SvxUnoTextBase::hasElements(  )
1944 {
1945     SolarMutexGuard aGuard;
1946
1947     if(GetEditSource())
1948     {
1949         SvxTextForwarder* pForwarder = GetEditSource()->GetTextForwarder();
1950         if(pForwarder)
1951             return pForwarder->GetParagraphCount() != 0;
1952     }
1953
1954     return false;
1955 }
1956
1957 // text::XTextRangeMover
1958 void SAL_CALL SvxUnoTextBase::moveTextRange( const uno::Reference< text::XTextRange >&, sal_Int16 )
1959 {
1960 }
1961
1962 /// @throws lang::IllegalArgumentException
1963 /// @throws beans::UnknownPropertyException
1964 /// @throws uno::RuntimeException
1965 static void SvxPropertyValuesToItemSet(
1966         SfxItemSet &rItemSet,
1967         const uno::Sequence< beans::PropertyValue >& rPropertyValues,
1968         const SfxItemPropertySet *pPropSet,
1969         SvxTextForwarder *pForwarder /*needed for WID_NUMLEVEL*/,
1970         sal_Int32 nPara /*needed for WID_NUMLEVEL*/)
1971 {
1972     for (const beans::PropertyValue& rProp : rPropertyValues)
1973     {
1974         const SfxItemPropertySimpleEntry *pEntry = pPropSet->getPropertyMap().getByName( rProp.Name );
1975         if (!pEntry)
1976             throw beans::UnknownPropertyException( "Unknown property: " + rProp.Name, static_cast < cppu::OWeakObject * > ( nullptr ) );
1977         // Note: there is no need to take special care of the properties
1978         //      TextField (EE_FEATURE_FIELD) and
1979         //      TextPortionType (WID_PORTIONTYPE)
1980         //  since they are read-only and thus are already taken care of below.
1981
1982         if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
1983             // should be PropertyVetoException which is not yet defined for the new import API's functions
1984             throw uno::RuntimeException("Property is read-only: " + rProp.Name, static_cast < cppu::OWeakObject * > ( nullptr ) );
1985             //throw PropertyVetoException ("Property is read-only: " + rProp.Name, static_cast < cppu::OWeakObject * > ( 0 ) );
1986
1987         if (pEntry->nWID == WID_FONTDESC)
1988         {
1989             awt::FontDescriptor aDesc;
1990             if (rProp.Value >>= aDesc)
1991                 SvxUnoFontDescriptor::FillItemSet( aDesc, rItemSet );
1992         }
1993         else if (pEntry->nWID == WID_NUMLEVEL)
1994         {
1995             if (pForwarder)
1996             {
1997                 sal_Int16 nLevel = -1;
1998                 rProp.Value >>= nLevel;
1999
2000                 // #101004# Call interface method instead of unsafe cast
2001                 if (!pForwarder->SetDepth( nPara, nLevel ))
2002                     throw lang::IllegalArgumentException();
2003             }
2004         }
2005         else if (pEntry->nWID == WID_NUMBERINGSTARTVALUE )
2006         {
2007             if( pForwarder )
2008             {
2009                 sal_Int16 nStartValue = -1;
2010                 if( !(rProp.Value >>= nStartValue) )
2011                     throw lang::IllegalArgumentException();
2012
2013                 pForwarder->SetNumberingStartValue( nPara, nStartValue );
2014             }
2015         }
2016         else if (pEntry->nWID == WID_PARAISNUMBERINGRESTART )
2017         {
2018             if( pForwarder )
2019             {
2020                 bool bParaIsNumberingRestart = false;
2021                 if( !(rProp.Value >>= bParaIsNumberingRestart) )
2022                     throw lang::IllegalArgumentException();
2023
2024                 pForwarder->SetParaIsNumberingRestart( nPara, bParaIsNumberingRestart );
2025             }
2026         }
2027         else
2028             pPropSet->setPropertyValue( rProp.Name, rProp.Value, rItemSet );
2029     }
2030 }
2031
2032 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::finishParagraphInsert(
2033         const uno::Sequence< beans::PropertyValue >& /*rCharAndParaProps*/,
2034         const uno::Reference< text::XTextRange >& /*rTextRange*/ )
2035 {
2036     uno::Reference< text::XTextRange > xRet;
2037     return xRet;
2038 }
2039
2040 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::finishParagraph(
2041         const uno::Sequence< beans::PropertyValue >& rCharAndParaProps )
2042 {
2043     SolarMutexGuard aGuard;
2044
2045     uno::Reference< text::XTextRange > xRet;
2046     SvxEditSource *pEditSource = GetEditSource();
2047     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : nullptr;
2048     if (pTextForwarder)
2049     {
2050         sal_Int32 nParaCount = pTextForwarder->GetParagraphCount();
2051         DBG_ASSERT( nParaCount > 0, "paragraph count is 0 or negative" );
2052         pTextForwarder->AppendParagraph();
2053
2054         // set properties for the previously last paragraph
2055         sal_Int32 nPara = nParaCount - 1;
2056         ESelection aSel( nPara, 0, nPara, 0 );
2057         SfxItemSet aItemSet( *pTextForwarder->GetEmptyItemSetPtr() );
2058         SvxPropertyValuesToItemSet( aItemSet, rCharAndParaProps,
2059                 ImplGetSvxUnoOutlinerTextCursorSfxPropertySet(), pTextForwarder, nPara );
2060         pTextForwarder->QuickSetAttribs( aItemSet, aSel );
2061         pEditSource->UpdateData();
2062         SvxUnoTextRange* pRange = new SvxUnoTextRange( *this );
2063         xRet = pRange;
2064         pRange->SetSelection( aSel );
2065     }
2066     return xRet;
2067 }
2068
2069 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::insertTextPortion(
2070         const OUString& /*rText*/,
2071         const uno::Sequence< beans::PropertyValue >& /*rCharAndParaProps*/,
2072         const uno::Reference< text::XTextRange>& /*rTextRange*/ )
2073 {
2074     uno::Reference< text::XTextRange > xRet;
2075     return xRet;
2076 }
2077
2078 // css::text::XTextPortionAppend (new import API)
2079 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::appendTextPortion(
2080         const OUString& rText,
2081         const uno::Sequence< beans::PropertyValue >& rCharAndParaProps )
2082 {
2083     SolarMutexGuard aGuard;
2084
2085     SvxEditSource *pEditSource = GetEditSource();
2086     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : nullptr;
2087     uno::Reference< text::XTextRange > xRet;
2088     if (pTextForwarder)
2089     {
2090         sal_Int32 nParaCount = pTextForwarder->GetParagraphCount();
2091         DBG_ASSERT( nParaCount > 0, "paragraph count is 0 or negative" );
2092         sal_Int32 nPara = nParaCount - 1;
2093         SfxItemSet aSet( pTextForwarder->GetParaAttribs( nPara ) );
2094         sal_Int32 nStart = pTextForwarder->AppendTextPortion( nPara, rText, aSet );
2095         pEditSource->UpdateData();
2096         sal_Int32 nEnd   = pTextForwarder->GetTextLen( nPara );
2097
2098         // set properties for the new text portion
2099         ESelection aSel( nPara, nStart, nPara, nEnd );
2100         pTextForwarder->RemoveAttribs( aSel );
2101         pEditSource->UpdateData();
2102
2103         SfxItemSet aItemSet( *pTextForwarder->GetEmptyItemSetPtr() );
2104         SvxPropertyValuesToItemSet( aItemSet, rCharAndParaProps,
2105                 ImplGetSvxTextPortionSfxPropertySet(), pTextForwarder, nPara );
2106         pTextForwarder->QuickSetAttribs( aItemSet, aSel );
2107         SvxUnoTextRange* pRange = new SvxUnoTextRange( *this );
2108         xRet = pRange;
2109         pRange->SetSelection( aSel );
2110         for( const beans::PropertyValue& rProp : rCharAndParaProps )
2111             pRange->setPropertyValue( rProp.Name, rProp.Value );
2112     }
2113     return xRet;
2114 }
2115
2116 void SvxUnoTextBase::copyText(
2117     const uno::Reference< text::XTextCopy >& xSource )
2118 {
2119     SolarMutexGuard aGuard;
2120     uno::Reference< lang::XUnoTunnel > xUT( xSource, uno::UNO_QUERY );
2121     SvxEditSource *pEditSource = GetEditSource();
2122     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : nullptr;
2123     if( !pTextForwarder )
2124         return;
2125     if( xUT.is() )
2126     {
2127         SvxUnoTextBase* pSource = reinterpret_cast<SvxUnoTextBase*>(sal::static_int_cast<sal_uIntPtr>(
2128                                                                     xUT->getSomething( SvxUnoTextBase::getUnoTunnelId())));
2129         SvxEditSource *pSourceEditSource = pSource->GetEditSource();
2130         SvxTextForwarder *pSourceTextForwarder = pSourceEditSource ? pSourceEditSource->GetTextForwarder() : nullptr;
2131         if( pSourceTextForwarder )
2132         {
2133             pTextForwarder->CopyText( *pSourceTextForwarder );
2134             pEditSource->UpdateData();
2135         }
2136     }
2137     else
2138     {
2139         uno::Reference< text::XText > xSourceText( xSource, uno::UNO_QUERY );
2140         if( xSourceText.is() )
2141         {
2142             setString( xSourceText->getString() );
2143         }
2144     }
2145 }
2146
2147 // lang::XServiceInfo
2148 OUString SAL_CALL SvxUnoTextBase::getImplementationName()
2149 {
2150     return "SvxUnoTextBase";
2151 }
2152
2153 uno::Sequence< OUString > SAL_CALL SvxUnoTextBase::getSupportedServiceNames(  )
2154 {
2155     return getSupportedServiceNames_Static();
2156 }
2157
2158 uno::Sequence< OUString > SAL_CALL SvxUnoTextBase::getSupportedServiceNames_Static(  )
2159 {
2160     return comphelper::concatSequences(
2161         SvxUnoTextRangeBase::getSupportedServiceNames_Static(),
2162         std::initializer_list<std::u16string_view>{ u"com.sun.star.text.Text" });
2163 }
2164
2165 namespace
2166 {
2167     class theSvxUnoTextBaseUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSvxUnoTextBaseUnoTunnelId > {};
2168 }
2169
2170 const uno::Sequence< sal_Int8 > & SvxUnoTextBase::getUnoTunnelId() throw()
2171 {
2172     return theSvxUnoTextBaseUnoTunnelId::get().getSeq();
2173 }
2174
2175 sal_Int64 SAL_CALL SvxUnoTextBase::getSomething( const uno::Sequence< sal_Int8 >& rId )
2176 {
2177     if( isUnoTunnelId<SvxUnoTextBase>(rId) )
2178     {
2179         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
2180     }
2181     else
2182     {
2183         return SvxUnoTextRangeBase::getSomething( rId );
2184     }
2185 }
2186
2187 SvxUnoText::SvxUnoText( const SvxItemPropertySet* _pSet ) throw()
2188 : SvxUnoTextBase( _pSet )
2189 {
2190 }
2191
2192 SvxUnoText::SvxUnoText( const SvxEditSource* pSource, const SvxItemPropertySet* _pSet, uno::Reference < text::XText > const & xParent ) throw()
2193 : SvxUnoTextBase( pSource, _pSet, xParent )
2194 {
2195 }
2196
2197 SvxUnoText::SvxUnoText( const SvxUnoText& rText ) throw()
2198 : SvxUnoTextBase( rText )
2199 , cppu::OWeakAggObject()
2200 {
2201 }
2202
2203 SvxUnoText::~SvxUnoText() throw()
2204 {
2205 }
2206
2207 // uno::XInterface
2208 uno::Any SAL_CALL SvxUnoText::queryAggregation( const uno::Type & rType )
2209 {
2210     uno::Any aAny( SvxUnoTextBase::queryAggregation( rType ) );
2211     if( !aAny.hasValue() )
2212         aAny = OWeakAggObject::queryAggregation( rType );
2213
2214     return aAny;
2215 }
2216
2217 uno::Any SAL_CALL SvxUnoText::queryInterface( const uno::Type & rType )
2218 {
2219     return OWeakAggObject::queryInterface( rType );
2220 }
2221
2222 void SAL_CALL SvxUnoText::acquire() throw( )
2223 {
2224     OWeakAggObject::acquire();
2225 }
2226
2227 void SAL_CALL SvxUnoText::release() throw( )
2228 {
2229     OWeakAggObject::release();
2230 }
2231
2232 // lang::XTypeProvider
2233 uno::Sequence< uno::Type > SAL_CALL SvxUnoText::getTypes(  )
2234 {
2235     return SvxUnoTextBase::getTypes();
2236 }
2237
2238 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoText::getImplementationId(  )
2239 {
2240     return css::uno::Sequence<sal_Int8>();
2241 }
2242
2243 namespace
2244 {
2245     class theSvxUnoTextUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSvxUnoTextUnoTunnelId > {};
2246 }
2247
2248 const uno::Sequence< sal_Int8 > & SvxUnoText::getUnoTunnelId() throw()
2249 {
2250     return theSvxUnoTextUnoTunnelId::get().getSeq();
2251 }
2252
2253 sal_Int64 SAL_CALL SvxUnoText::getSomething( const uno::Sequence< sal_Int8 >& rId )
2254 {
2255     if( isUnoTunnelId<SvxUnoText>(rId) )
2256     {
2257         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
2258     }
2259     else
2260     {
2261         return SvxUnoTextBase::getSomething( rId );
2262     }
2263 }
2264
2265
2266 SvxDummyTextSource::~SvxDummyTextSource()
2267 {
2268 };
2269
2270 std::unique_ptr<SvxEditSource> SvxDummyTextSource::Clone() const
2271 {
2272     return std::unique_ptr<SvxEditSource>(new SvxDummyTextSource);
2273 }
2274
2275 SvxTextForwarder* SvxDummyTextSource::GetTextForwarder()
2276 {
2277     return this;
2278 }
2279
2280 void SvxDummyTextSource::UpdateData()
2281 {
2282 }
2283
2284 sal_Int32 SvxDummyTextSource::GetParagraphCount() const
2285 {
2286     return 0;
2287 }
2288
2289 sal_Int32 SvxDummyTextSource::GetTextLen( sal_Int32 ) const
2290 {
2291     return 0;
2292 }
2293
2294 OUString SvxDummyTextSource::GetText( const ESelection& ) const
2295 {
2296     return OUString();
2297 }
2298
2299 SfxItemSet SvxDummyTextSource::GetAttribs( const ESelection&, EditEngineAttribs ) const
2300 {
2301     // Very dangerous: The former implementation used a SfxItemPool created on the
2302     // fly which of course was deleted again ASAP. Thus, the returned SfxItemSet was using
2303     // a deleted Pool by design.
2304     return SfxItemSet(EditEngine::GetGlobalItemPool());
2305 }
2306
2307 SfxItemSet SvxDummyTextSource::GetParaAttribs( sal_Int32 ) const
2308 {
2309     return GetAttribs(ESelection());
2310 }
2311
2312 void SvxDummyTextSource::SetParaAttribs( sal_Int32, const SfxItemSet& )
2313 {
2314 }
2315
2316 void SvxDummyTextSource::RemoveAttribs( const ESelection& )
2317 {
2318 }
2319
2320 void SvxDummyTextSource::GetPortions( sal_Int32, std::vector<sal_Int32>& ) const
2321 {
2322 }
2323
2324 SfxItemState SvxDummyTextSource::GetItemState( const ESelection&, sal_uInt16 ) const
2325 {
2326     return SfxItemState::UNKNOWN;
2327 }
2328
2329 SfxItemState SvxDummyTextSource::GetItemState( sal_Int32, sal_uInt16 ) const
2330 {
2331     return SfxItemState::UNKNOWN;
2332 }
2333
2334 SfxItemPool* SvxDummyTextSource::GetPool() const
2335 {
2336     return nullptr;
2337 }
2338
2339 void SvxDummyTextSource::QuickInsertText( const OUString&, const ESelection& )
2340 {
2341 }
2342
2343 void SvxDummyTextSource::QuickInsertField( const SvxFieldItem&, const ESelection& )
2344 {
2345 }
2346
2347 void SvxDummyTextSource::QuickSetAttribs( const SfxItemSet&, const ESelection& )
2348 {
2349 }
2350
2351 void SvxDummyTextSource::QuickInsertLineBreak( const ESelection& )
2352 {
2353 };
2354
2355 OUString SvxDummyTextSource::CalcFieldValue( const SvxFieldItem&, sal_Int32, sal_Int32, std::optional<Color>&, std::optional<Color>& )
2356 {
2357     return OUString();
2358 }
2359
2360 void SvxDummyTextSource::FieldClicked( const SvxFieldItem& )
2361 {
2362 }
2363
2364 bool SvxDummyTextSource::IsValid() const
2365 {
2366     return false;
2367 }
2368
2369 LanguageType SvxDummyTextSource::GetLanguage( sal_Int32, sal_Int32 ) const
2370 {
2371     return LANGUAGE_DONTKNOW;
2372 }
2373
2374 sal_Int32 SvxDummyTextSource::GetFieldCount( sal_Int32 ) const
2375 {
2376     return 0;
2377 }
2378
2379 EFieldInfo SvxDummyTextSource::GetFieldInfo( sal_Int32, sal_uInt16 ) const
2380 {
2381     return EFieldInfo();
2382 }
2383
2384 EBulletInfo SvxDummyTextSource::GetBulletInfo( sal_Int32 ) const
2385 {
2386     return EBulletInfo();
2387 }
2388
2389 tools::Rectangle SvxDummyTextSource::GetCharBounds( sal_Int32, sal_Int32 ) const
2390 {
2391     return tools::Rectangle();
2392 }
2393
2394 tools::Rectangle SvxDummyTextSource::GetParaBounds( sal_Int32 ) const
2395 {
2396     return tools::Rectangle();
2397 }
2398
2399 MapMode SvxDummyTextSource::GetMapMode() const
2400 {
2401     return MapMode();
2402 }
2403
2404 OutputDevice* SvxDummyTextSource::GetRefDevice() const
2405 {
2406     return nullptr;
2407 }
2408
2409 bool SvxDummyTextSource::GetIndexAtPoint( const Point&, sal_Int32&, sal_Int32& ) const
2410 {
2411     return false;
2412 }
2413
2414 bool SvxDummyTextSource::GetWordIndices( sal_Int32, sal_Int32, sal_Int32&, sal_Int32& ) const
2415 {
2416     return false;
2417 }
2418
2419 bool SvxDummyTextSource::GetAttributeRun( sal_Int32&, sal_Int32&, sal_Int32, sal_Int32, bool ) const
2420 {
2421     return false;
2422 }
2423
2424 sal_Int32 SvxDummyTextSource::GetLineCount( sal_Int32 ) const
2425 {
2426     return 0;
2427 }
2428
2429 sal_Int32 SvxDummyTextSource::GetLineLen( sal_Int32, sal_Int32 ) const
2430 {
2431     return 0;
2432 }
2433
2434 void SvxDummyTextSource::GetLineBoundaries( /*out*/sal_Int32 &rStart, /*out*/sal_Int32 &rEnd, sal_Int32 /*nParagraph*/, sal_Int32 /*nLine*/ ) const
2435 {
2436     rStart = rEnd = 0;
2437 }
2438
2439 sal_Int32 SvxDummyTextSource::GetLineNumberAtIndex( sal_Int32 /*nPara*/, sal_Int32 /*nIndex*/ ) const
2440 {
2441     return 0;
2442 }
2443
2444 bool SvxDummyTextSource::QuickFormatDoc( bool )
2445 {
2446     return false;
2447 }
2448
2449 sal_Int16 SvxDummyTextSource::GetDepth( sal_Int32 ) const
2450 {
2451     return -1;
2452 }
2453
2454 bool SvxDummyTextSource::SetDepth( sal_Int32, sal_Int16 nNewDepth )
2455 {
2456     return nNewDepth == 0;
2457 }
2458
2459 bool SvxDummyTextSource::Delete( const ESelection& )
2460 {
2461     return false;
2462 }
2463
2464 bool SvxDummyTextSource::InsertText( const OUString&, const ESelection& )
2465 {
2466     return false;
2467 }
2468
2469 const SfxItemSet * SvxDummyTextSource::GetEmptyItemSetPtr()
2470 {
2471     return nullptr;
2472 }
2473
2474 void SvxDummyTextSource::AppendParagraph()
2475 {
2476 }
2477
2478 sal_Int32 SvxDummyTextSource::AppendTextPortion( sal_Int32, const OUString &, const SfxItemSet & )
2479 {
2480     return 0;
2481 }
2482
2483 void  SvxDummyTextSource::CopyText(const SvxTextForwarder& )
2484 {
2485 }
2486
2487 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */