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