editeng/source/uno/unotext2.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 <sal/config.h>
  21
  22 #include <initializer_list>
  23 #include <string_view>
  24
  25 #include <o3tl/safeint.hxx>
  26 #include <vcl/svapp.hxx>
  27
  28 #include <editeng/unotext.hxx>
  29 #include <comphelper/sequence.hxx>
  30 #include <cppuhelper/supportsservice.hxx>
  31
  32 using namespace ::cppu;
  33 using namespace ::com::sun::star;
  34
  35 #define QUERYINT( xint ) \
  36     if( rType == cppu::UnoType<xint>::get() ) \
  37         return uno::Any(uno::Reference< xint >(this))
  38
  39
  40 // SvxUnoTextContentEnumeration
  41
  42
  43 SvxUnoTextContentEnumeration::SvxUnoTextContentEnumeration( const SvxUnoTextBase& rText, const ESelection& rSel ) noexcept
  44 {
  45     mxParentText = const_cast<SvxUnoTextBase*>(&rText);
  46     if( rText.GetEditSource() )
  47         mpEditSource = rText.GetEditSource()->Clone();
  48     mnNextParagraph = 0;
  49
  50     if (!mpEditSource)
  51         return;
  52
  53     const SvxTextForwarder* pTextForwarder = rText.GetEditSource()->GetTextForwarder();
  54     const sal_Int32 maxParaIndex = std::min( rSel.nEndPara + 1, pTextForwarder->GetParagraphCount() );
  55
  56     for( sal_Int32 currentPara = rSel.nStartPara; currentPara < maxParaIndex; currentPara++ )
  57     {
  58         const SvxUnoTextRangeBaseVec& rRanges( mpEditSource->getRanges() );
  59         rtl::Reference<SvxUnoTextContent> pContent;
  60         sal_Int32 nStartPos = 0;
  61         sal_Int32 nEndPos = pTextForwarder->GetTextLen( currentPara );
  62         if( currentPara == rSel.nStartPara )
  63             nStartPos = std::max(nStartPos, rSel.nStartPos);
  64         if( currentPara == rSel.nEndPara )
  65             nEndPos = std::min(nEndPos, rSel.nEndPos);
  66         ESelection aCurrentParaSel( currentPara, nStartPos, currentPara, nEndPos );
  67         for (auto const& elemRange : rRanges)
  68         {
  69             if (pContent)
  70                 break;
  71             SvxUnoTextContent* pIterContent = dynamic_cast< SvxUnoTextContent* >( elemRange );
  72             if( pIterContent && (pIterContent->mnParagraph == currentPara) )
  73             {
  74                 ESelection aIterSel = pIterContent->GetSelection();
  75                 if( aIterSel == aCurrentParaSel )
  76                 {
  77                     pContent = pIterContent;
  78                     maContents.emplace_back(pContent );
  79                 }
  80             }
  81         }
  82         if( pContent == nullptr )
  83         {
  84             pContent = new SvxUnoTextContent( rText, currentPara );
  85             pContent->SetSelection( aCurrentParaSel );
  86             maContents.emplace_back(pContent );
  87         }
  88     }
  89 }
  90
  91 SvxUnoTextContentEnumeration::~SvxUnoTextContentEnumeration() noexcept
  92 {
  93 }
  94
  95 // container::XEnumeration
  96 sal_Bool SAL_CALL SvxUnoTextContentEnumeration::hasMoreElements()
  97 {
  98     SolarMutexGuard aGuard;
  99     if( mpEditSource && !maContents.empty() )
 100         return o3tl::make_unsigned(mnNextParagraph) < maContents.size();
 101     else
 102         return false;
 103 }
 104
 105 uno::Any SvxUnoTextContentEnumeration::nextElement()
 106 {
 107     SolarMutexGuard aGuard;
 108
 109     if(!hasMoreElements())
 110         throw container::NoSuchElementException();
 111
 112     uno::Reference< text::XTextContent > xRef( maContents.at(mnNextParagraph) );
 113     mnNextParagraph++;
 114     return uno::Any( xRef );
 115 }
 116
 117
 118
 119
 120 SvxUnoTextContent::SvxUnoTextContent( const SvxUnoTextBase& rText, sal_Int32 nPara ) noexcept
 121 :   SvxUnoTextRangeBase(rText)
 122 ,   mnParagraph(nPara)
 123 ,   mrParentText(rText)
 124 ,   mbDisposing( false )
 125 {
 126     mxParentText = const_cast<SvxUnoTextBase*>(&rText);
 127 }
 128
 129 SvxUnoTextContent::SvxUnoTextContent( const SvxUnoTextContent& rContent ) noexcept
 130 :   SvxUnoTextRangeBase(rContent)
 131 ,   text::XTextContent()
 132 ,   container::XEnumerationAccess()
 133 ,   lang::XTypeProvider()
 134 ,   cppu::OWeakAggObject()
 135 ,   mrParentText(rContent.mrParentText)
 136 ,   mbDisposing( false )
 137 {
 138     mxParentText = rContent.mxParentText;
 139     mnParagraph  = rContent.mnParagraph;
 140     SetSelection( rContent.GetSelection() );
 141 }
 142
 143 SvxUnoTextContent::~SvxUnoTextContent() noexcept
 144 {
 145 }
 146
 147 // uno::XInterface
 148 uno::Any SAL_CALL SvxUnoTextContent::queryAggregation( const uno::Type & rType )
 149 {
 150     QUERYINT( text::XTextRange );
 151     else QUERYINT( beans::XMultiPropertyStates );
 152     else QUERYINT( beans::XPropertySet );
 153     else QUERYINT( beans::XMultiPropertySet );
 154     else QUERYINT( beans::XPropertyState );
 155     else QUERYINT( text::XTextContent );
 156     else QUERYINT( text::XTextRangeCompare );
 157     else QUERYINT( lang::XComponent );
 158     else QUERYINT( container::XEnumerationAccess );
 159     else QUERYINT( container::XElementAccess );
 160     else QUERYINT( lang::XServiceInfo );
 161     else QUERYINT( lang::XTypeProvider );
 162     else QUERYINT( lang::XUnoTunnel );
 163     else
 164         return OWeakAggObject::queryAggregation( rType );
 165 }
 166
 167 uno::Any SAL_CALL SvxUnoTextContent::queryInterface( const uno::Type & rType )
 168 {
 169     return OWeakAggObject::queryInterface(rType);
 170 }
 171
 172 void SAL_CALL SvxUnoTextContent::acquire() noexcept
 173 {
 174     OWeakAggObject::acquire();
 175 }
 176
 177 void SAL_CALL SvxUnoTextContent::release() noexcept
 178 {
 179     OWeakAggObject::release();
 180 }
 181
 182 // XTypeProvider
 183
 184 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextContent::getTypes()
 185 {
 186     static const uno::Sequence< uno::Type > TYPES {
 187             cppu::UnoType<text::XTextRange>::get(),
 188             cppu::UnoType<beans::XPropertySet>::get(),
 189             cppu::UnoType<beans::XMultiPropertySet>::get(),
 190             cppu::UnoType<beans::XMultiPropertyStates>::get(),
 191             cppu::UnoType<beans::XPropertyState>::get(),
 192             cppu::UnoType<text::XTextRangeCompare>::get(),
 193             cppu::UnoType<text::XTextContent>::get(),
 194             cppu::UnoType<container::XEnumerationAccess>::get(),
 195             cppu::UnoType<lang::XServiceInfo>::get(),
 196             cppu::UnoType<lang::XTypeProvider>::get(),
 197             cppu::UnoType<lang::XUnoTunnel>::get() };
 198     return TYPES;
 199 }
 200
 201 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoTextContent::getImplementationId()
 202 {
 203     return css::uno::Sequence<sal_Int8>();
 204 }
 205
 206 // text::XTextRange
 207
 208 uno::Reference< text::XText > SAL_CALL SvxUnoTextContent::getText()
 209 {
 210     return mxParentText;
 211 }
 212
 213 // text::XTextContent
 214 void SAL_CALL SvxUnoTextContent::attach( const uno::Reference< text::XTextRange >& )
 215 {
 216 }
 217
 218 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextContent::getAnchor()
 219 {
 220     return mxParentText;
 221 }
 222
 223 // XComponent
 224
 225 void SAL_CALL SvxUnoTextContent::dispose()
 226 {
 227     SolarMutexGuard aGuard;
 228
 229     if( mbDisposing )
 230         return; // caught a recursion
 231
 232     mbDisposing = true;
 233
 234     lang::EventObject aEvt;
 235     aEvt.Source = *static_cast<OWeakAggObject*>(this);
 236     {
 237         std::unique_lock aMutexGuard(maDisposeContainerMutex);
 238         maDisposeListeners.disposeAndClear(aMutexGuard, aEvt);
 239     }
 240
 241     if( mxParentText.is() )
 242         mxParentText->removeTextContent( this );
 243 }
 244
 245 void SAL_CALL SvxUnoTextContent::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 246 {
 247     std::unique_lock aGuard(maDisposeContainerMutex);
 248     maDisposeListeners.addInterface(aGuard, xListener);
 249 }
 250
 251 void SAL_CALL SvxUnoTextContent::removeEventListener( const uno::Reference< lang::XEventListener >& aListener )
 252 {
 253    std::unique_lock aGuard(maDisposeContainerMutex);
 254    maDisposeListeners.removeInterface(aGuard, aListener);
 255 }
 256
 257 // XEnumerationAccess
 258
 259 uno::Reference< container::XEnumeration > SAL_CALL SvxUnoTextContent::createEnumeration()
 260 {
 261     SolarMutexGuard aGuard;
 262
 263     return new SvxUnoTextRangeEnumeration( mrParentText, mnParagraph, maSelection );
 264 }
 265
 266 // XElementAccess ( container::XEnumerationAccess )
 267
 268 uno::Type SAL_CALL SvxUnoTextContent::getElementType()
 269 {
 270     return cppu::UnoType<text::XTextRange>::get();
 271 }
 272
 273 sal_Bool SAL_CALL SvxUnoTextContent::hasElements()
 274 {
 275     SolarMutexGuard aGuard;
 276
 277     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : nullptr;
 278     if( pForwarder )
 279     {
 280         std::vector<sal_Int32> aPortions;
 281         pForwarder->GetPortions( mnParagraph, aPortions );
 282         return !aPortions.empty();
 283     }
 284     else
 285     {
 286         return false;
 287     }
 288 }
 289
 290 // XPropertySet
 291
 292 void SAL_CALL SvxUnoTextContent::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 293 {
 294     _setPropertyValue( aPropertyName, aValue, mnParagraph );
 295 }
 296
 297 uno::Any SAL_CALL SvxUnoTextContent::getPropertyValue( const OUString& PropertyName )
 298 {
 299     return _getPropertyValue( PropertyName, mnParagraph );
 300 }
 301
 302 // XMultiPropertySet
 303 void SAL_CALL SvxUnoTextContent::setPropertyValues( const uno::Sequence< OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues )
 304 {
 305     _setPropertyValues( aPropertyNames, aValues, mnParagraph );
 306 }
 307
 308 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextContent::getPropertyValues( const uno::Sequence< OUString >& aPropertyNames )
 309 {
 310     return _getPropertyValues( aPropertyNames, mnParagraph );
 311 }
 312
 313 /*// XTolerantMultiPropertySet
 314 uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL SvxUnoTextContent::setPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues ) throw (lang::IllegalArgumentException, uno::RuntimeException)
 315 {
 316     return _setPropertyValuesTolerant(aPropertyNames, aValues, mnParagraph);
 317 }
 318
 319 uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL SvxUnoTextContent::getPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames ) throw (uno::RuntimeException)
 320 {
 321     return _getPropertyValuesTolerant(aPropertyNames, mnParagraph);
 322 }
 323
 324 uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SvxUnoTextContent::getDirectPropertyValuesTolerant( const uno::Sequence< OUString >& aPropertyNames )
 325     throw (uno::RuntimeException)
 326 {
 327     return _getDirectPropertyValuesTolerant(aPropertyNames, mnParagraph);
 328 }*/
 329
 330 // beans::XPropertyState
 331 beans::PropertyState SAL_CALL SvxUnoTextContent::getPropertyState( const OUString& PropertyName )
 332 {
 333     return _getPropertyState( PropertyName, mnParagraph );
 334 }
 335
 336 uno::Sequence< beans::PropertyState > SAL_CALL SvxUnoTextContent::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
 337 {
 338     return _getPropertyStates( aPropertyName, mnParagraph );
 339 }
 340
 341 void SAL_CALL SvxUnoTextContent::setPropertyToDefault( const OUString& PropertyName )
 342 {
 343     _setPropertyToDefault( PropertyName, mnParagraph );
 344 }
 345
 346 // lang::XServiceInfo
 347
 348 OUString SAL_CALL SvxUnoTextContent::getImplementationName()
 349 {
 350     return "SvxUnoTextContent";
 351 }
 352
 353 uno::Sequence< OUString > SAL_CALL SvxUnoTextContent::getSupportedServiceNames()
 354 {
 355     return comphelper::concatSequences(
 356         SvxUnoTextRangeBase::getSupportedServiceNames(),
 357         std::initializer_list<std::u16string_view>{ u"com.sun.star.style.ParagraphProperties",
 358                                           u"com.sun.star.style.ParagraphPropertiesComplex",
 359                                           u"com.sun.star.style.ParagraphPropertiesAsian",
 360                                           u"com.sun.star.text.TextContent",
 361                                           u"com.sun.star.text.Paragraph" });
 362 }
 363
 364
 365
 366
 367 SvxUnoTextRangeEnumeration::SvxUnoTextRangeEnumeration(const SvxUnoTextBase& rParentText, sal_Int32 nParagraph, const ESelection& rSel)
 368 :   mxParentText(  const_cast<SvxUnoTextBase*>(&rParentText) ),
 369     mnNextPortion( 0 )
 370 {
 371     if (rParentText.GetEditSource())
 372         mpEditSource = rParentText.GetEditSource()->Clone();
 373
 374     if( !(mpEditSource && mpEditSource->GetTextForwarder() && (nParagraph == rSel.nStartPara && nParagraph == rSel.nEndPara)) )
 375         return;
 376
 377     std::vector<sal_Int32> aPortions;
 378     mpEditSource->GetTextForwarder()->GetPortions( nParagraph, aPortions );
 379     for( size_t aPortionIndex = 0; aPortionIndex < aPortions.size(); aPortionIndex++ )
 380     {
 381         sal_uInt16 nStartPos = 0;
 382         if ( aPortionIndex > 0 )
 383             nStartPos = aPortions.at( aPortionIndex - 1 );
 384         if( nStartPos > rSel.nEndPos )
 385             continue;
 386         sal_uInt16 nEndPos = aPortions.at( aPortionIndex );
 387         if( nEndPos < rSel.nStartPos )
 388             continue;
 389
 390         nStartPos = std::max<int>(nStartPos, rSel.nStartPos);
 391         nEndPos = std::min<sal_uInt16>(nEndPos, rSel.nEndPos);
 392         ESelection aSel( nParagraph, nStartPos, nParagraph, nEndPos );
 393
 394         const SvxUnoTextRangeBaseVec& rRanges( mpEditSource->getRanges() );
 395         rtl::Reference<SvxUnoTextRange> pRange;
 396         for (auto const& elemRange : rRanges)
 397         {
 398             if (pRange)
 399                 break;
 400             SvxUnoTextRange* pIterRange = dynamic_cast< SvxUnoTextRange* >( elemRange );
 401             if( pIterRange && pIterRange->mbPortion && (aSel == pIterRange->maSelection) )
 402                 pRange = pIterRange;
 403         }
 404         if( pRange == nullptr )
 405         {
 406             pRange = new SvxUnoTextRange( rParentText, true );
 407             pRange->SetSelection( aSel );
 408         }
 409         maPortions.emplace_back(pRange );
 410     }
 411 }
 412
 413 SvxUnoTextRangeEnumeration::~SvxUnoTextRangeEnumeration() noexcept
 414 {
 415 }
 416
 417 // container::XEnumeration
 418
 419 sal_Bool SAL_CALL SvxUnoTextRangeEnumeration::hasMoreElements()
 420 {
 421     SolarMutexGuard aGuard;
 422
 423     return !maPortions.empty() && mnNextPortion < maPortions.size();
 424 }
 425
 426 uno::Any SAL_CALL SvxUnoTextRangeEnumeration::nextElement()
 427 {
 428     SolarMutexGuard aGuard;
 429
 430     if( maPortions.empty() || mnNextPortion >= maPortions.size() )
 431         throw container::NoSuchElementException();
 432
 433     uno::Reference< text::XTextRange > xRange = maPortions.at(mnNextPortion);
 434     mnNextPortion++;
 435     return uno::Any( xRange );
 436 }
 437
 438 SvxUnoTextCursor::SvxUnoTextCursor( const SvxUnoTextBase& rText ) noexcept
 439 :   SvxUnoTextRangeBase(rText),
 440     mxParentText( const_cast<SvxUnoTextBase*>(&rText) )
 441 {
 442 }
 443
 444 SvxUnoTextCursor::SvxUnoTextCursor( const SvxUnoTextCursor& rCursor ) noexcept
 445 :   SvxUnoTextRangeBase(rCursor)
 446 ,   text::XTextCursor()
 447 ,   lang::XTypeProvider()
 448 ,   cppu::OWeakAggObject()
 449 ,   mxParentText(rCursor.mxParentText)
 450 {
 451 }
 452
 453 SvxUnoTextCursor::~SvxUnoTextCursor() noexcept
 454 {
 455 }
 456
 457 // Comment out automatically - [getIdlClass(es) or queryInterface]
 458 // Please use the XTypeProvider!
 459 //sal_Bool SvxUnoTextCursor::queryInterface( uno::Uik aUIK, Reference< uno::XInterface > & xRef)
 460 uno::Any SAL_CALL SvxUnoTextCursor::queryAggregation( const uno::Type & rType )
 461 {
 462     if( rType == cppu::UnoType<text::XTextRange>::get())
 463         return uno::Any(uno::Reference< text::XTextRange >(static_cast<SvxUnoTextRangeBase *>(this)));
 464     else QUERYINT( text::XTextCursor );
 465     else QUERYINT( beans::XMultiPropertyStates );
 466     else QUERYINT( beans::XPropertySet );
 467     else QUERYINT( beans::XMultiPropertySet );
 468     else QUERYINT( beans::XPropertyState );
 469     else QUERYINT( text::XTextRangeCompare );
 470     else QUERYINT( lang::XServiceInfo );
 471     else QUERYINT( lang::XTypeProvider );
 472     else QUERYINT( lang::XUnoTunnel );
 473     else
 474         return OWeakAggObject::queryAggregation( rType );
 475 }
 476
 477 uno::Any SAL_CALL SvxUnoTextCursor::queryInterface( const uno::Type & rType )
 478 {
 479     return OWeakAggObject::queryInterface(rType);
 480 }
 481
 482 void SAL_CALL SvxUnoTextCursor::acquire() noexcept
 483 {
 484     OWeakAggObject::acquire();
 485 }
 486
 487 void SAL_CALL SvxUnoTextCursor::release() noexcept
 488 {
 489     OWeakAggObject::release();
 490 }
 491
 492 // XTypeProvider
 493 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextCursor::getTypes()
 494 {
 495     static const uno::Sequence< uno::Type > TYPES {
 496             cppu::UnoType<text::XTextRange>::get(),
 497              cppu::UnoType<text::XTextCursor>::get(),
 498              cppu::UnoType<beans::XPropertySet>::get(),
 499              cppu::UnoType<beans::XMultiPropertySet>::get(),
 500              cppu::UnoType<beans::XMultiPropertyStates>::get(),
 501              cppu::UnoType<beans::XPropertyState>::get(),
 502              cppu::UnoType<text::XTextRangeCompare>::get(),
 503              cppu::UnoType<lang::XServiceInfo>::get(),
 504              cppu::UnoType<lang::XTypeProvider>::get(),
 505              cppu::UnoType<lang::XUnoTunnel>::get() };
 506     return TYPES;
 507 }
 508
 509 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoTextCursor::getImplementationId()
 510 {
 511     return css::uno::Sequence<sal_Int8>();
 512 }
 513
 514 // text::XTextCursor
 515 void SAL_CALL SvxUnoTextCursor::collapseToStart()
 516 {
 517     SolarMutexGuard aGuard;
 518     CollapseToStart();
 519 }
 520
 521 void SAL_CALL SvxUnoTextCursor::collapseToEnd()
 522 {
 523     SolarMutexGuard aGuard;
 524     CollapseToEnd();
 525 }
 526
 527 sal_Bool SAL_CALL SvxUnoTextCursor::isCollapsed()
 528 {
 529     SolarMutexGuard aGuard;
 530     return IsCollapsed();
 531 }
 532
 533 sal_Bool SAL_CALL SvxUnoTextCursor::goLeft( sal_Int16 nCount, sal_Bool bExpand )
 534 {
 535     SolarMutexGuard aGuard;
 536     return GoLeft( nCount, bExpand );
 537 }
 538
 539 sal_Bool SAL_CALL SvxUnoTextCursor::goRight( sal_Int16 nCount, sal_Bool bExpand )
 540 {
 541     SolarMutexGuard aGuard;
 542     return GoRight( nCount, bExpand );
 543 }
 544
 545 void SAL_CALL SvxUnoTextCursor::gotoStart( sal_Bool bExpand )
 546 {
 547     SolarMutexGuard aGuard;
 548     GotoStart( bExpand );
 549 }
 550
 551 void SAL_CALL SvxUnoTextCursor::gotoEnd( sal_Bool bExpand )
 552 {
 553     SolarMutexGuard aGuard;
 554     GotoEnd( bExpand );
 555 }
 556
 557 void SAL_CALL SvxUnoTextCursor::gotoRange( const uno::Reference< text::XTextRange >& xRange, sal_Bool bExpand )
 558 {
 559     if( !xRange.is() )
 560         return;
 561
 562     SvxUnoTextRangeBase* pRange = comphelper::getFromUnoTunnel<SvxUnoTextRangeBase>( xRange );
 563
 564     if( !pRange )
 565         return;
 566
 567     ESelection aNewSel = pRange->GetSelection();
 568
 569     if( bExpand )
 570     {
 571         const ESelection& rOldSel = GetSelection();
 572         aNewSel.nStartPara = rOldSel.nStartPara;
 573         aNewSel.nStartPos  = rOldSel.nStartPos;
 574     }
 575
 576     SetSelection( aNewSel );
 577 }
 578
 579 // text::XTextRange (rest in SvxTextRange)
 580 uno::Reference< text::XText > SAL_CALL SvxUnoTextCursor::getText()
 581 {
 582     return mxParentText;
 583 }
 584
 585 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextCursor::getStart()
 586 {
 587     return SvxUnoTextRangeBase::getStart();
 588 }
 589
 590 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextCursor::getEnd()
 591 {
 592     return SvxUnoTextRangeBase::getEnd();
 593 }
 594
 595 OUString SAL_CALL SvxUnoTextCursor::getString()
 596 {
 597     return SvxUnoTextRangeBase::getString();
 598 }
 599
 600 void SAL_CALL SvxUnoTextCursor::setString( const OUString& aString )
 601 {
 602     SvxUnoTextRangeBase::setString(aString);
 603 }
 604 // lang::XServiceInfo
 605 OUString SAL_CALL SvxUnoTextCursor::getImplementationName()
 606 {
 607     return "SvxUnoTextCursor";
 608 }
 609
 610 sal_Bool SAL_CALL SvxUnoTextCursor::supportsService( const OUString& ServiceName )
 611 {
 612     return cppu::supportsService( this, ServiceName );
 613 }
 614
 615 uno::Sequence< OUString > SAL_CALL SvxUnoTextCursor::getSupportedServiceNames()
 616 {
 617     return comphelper::concatSequences(
 618         SvxUnoTextRangeBase::getSupportedServiceNames(),
 619         std::initializer_list<std::u16string_view>{ u"com.sun.star.style.ParagraphProperties",
 620                                           u"com.sun.star.style.ParagraphPropertiesComplex",
 621                                           u"com.sun.star.style.ParagraphPropertiesAsian",
 622                                           u"com.sun.star.text.TextCursor" });
 623 }
 624
 625
 626 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */