editeng/source/uno/unoforou.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <algorithm>
  22 #include <svl/style.hxx>
  23 #include <com/sun/star/i18n/WordType.hpp>
  24
  25 #include <svl/itemset.hxx>
  26 #include <editeng/editeng.hxx>
  27 #include <editeng/editdata.hxx>
  28 #include <editeng/outliner.hxx>
  29 #include <editeng/unoedhlp.hxx>
  30 #include <svl/poolitem.hxx>
  31 #include <vcl/wrkwin.hxx>
  32 #include <editeng/eeitem.hxx>
  33
  34 #include <editeng/unoforou.hxx>
  35 #include <editeng/unofored.hxx>
  36 #include <editeng/outlobj.hxx>
  37 #include <unofored_internal.hxx>
  38
  39 using namespace ::com::sun::star;
  40
  41
  42
  43 SvxOutlinerForwarder::SvxOutlinerForwarder( Outliner& rOutl, bool bOutlText /* = false */ ) :
  44     rOutliner( rOutl ),
  45     bOutlinerText( bOutlText ),
  46     mpAttribsCache( NULL ),
  47     mpParaAttribsCache( NULL ),
  48     mnParaAttribsCache( 0 )
  49 {
  50 }
  51
  52 SvxOutlinerForwarder::~SvxOutlinerForwarder()
  53 {
  54     flushCache();
  55 }
  56
  57 sal_Int32 SvxOutlinerForwarder::GetParagraphCount() const
  58 {
  59     return rOutliner.GetParagraphCount();
  60 }
  61
  62 sal_Int32 SvxOutlinerForwarder::GetTextLen( sal_Int32 nParagraph ) const
  63 {
  64     return rOutliner.GetEditEngine().GetTextLen( nParagraph );
  65 }
  66
  67 OUString SvxOutlinerForwarder::GetText( const ESelection& rSel ) const
  68 {
  69     //! GetText (ESelection) should probably also be in the Outliner
  70     // in the time being use as the hack for the EditEngine:
  71     EditEngine* pEditEngine = const_cast<EditEngine*>(&rOutliner.GetEditEngine());
  72     return pEditEngine->GetText( rSel, LINEEND_LF );
  73 }
  74
  75 static SfxItemSet ImplOutlinerForwarderGetAttribs( const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib, EditEngine& rEditEngine )
  76 {
  77     if( rSel.nStartPara == rSel.nEndPara )
  78     {
  79         GetAttribsFlags nFlags = GetAttribsFlags::NONE;
  80
  81         switch( nOnlyHardAttrib )
  82         {
  83         case EditEngineAttribs_All:
  84             nFlags = GetAttribsFlags::ALL;
  85             break;
  86         case EditEngineAttribs_HardAndPara:
  87             nFlags = GetAttribsFlags::PARAATTRIBS|GetAttribsFlags::CHARATTRIBS;
  88             break;
  89         case EditEngineAttribs_OnlyHard:
  90             nFlags = GetAttribsFlags::CHARATTRIBS;
  91             break;
  92         default:
  93             OSL_FAIL("unknown flags for SvxOutlinerForwarder::GetAttribs");
  94         }
  95         return rEditEngine.GetAttribs( rSel.nStartPara, rSel.nStartPos, rSel.nEndPos, nFlags );
  96     }
  97     else
  98     {
  99         return rEditEngine.GetAttribs( rSel, nOnlyHardAttrib );
 100     }
 101 }
 102
 103 SfxItemSet SvxOutlinerForwarder::GetAttribs( const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib ) const
 104 {
 105     if( mpAttribsCache && ( EditEngineAttribs_All == nOnlyHardAttrib ) )
 106     {
 107         // have we the correct set in cache?
 108         if( const_cast<SvxOutlinerForwarder*>(this)->maAttribCacheSelection.IsEqual(rSel) )
 109         {
 110             // yes! just return the cache
 111             return *mpAttribsCache;
 112         }
 113         else
 114         {
 115             // no, we need delete the old cache
 116             delete mpAttribsCache;
 117             mpAttribsCache = NULL;
 118         }
 119     }
 120
 121     //! Does it not exist on the Outliner?
 122     //! and why is the GetAttribs on the EditEngine not a const?
 123     EditEngine& rEditEngine = (EditEngine&)rOutliner.GetEditEngine();
 124
 125     SfxItemSet aSet( ImplOutlinerForwarderGetAttribs( rSel, nOnlyHardAttrib, rEditEngine ) );
 126
 127     if( EditEngineAttribs_All == nOnlyHardAttrib )
 128     {
 129         mpAttribsCache = new SfxItemSet( aSet );
 130         maAttribCacheSelection = rSel;
 131     }
 132
 133     SfxStyleSheet* pStyle = rEditEngine.GetStyleSheet( rSel.nStartPara );
 134     if( pStyle )
 135         aSet.SetParent( &(pStyle->GetItemSet() ) );
 136
 137     return aSet;
 138 }
 139
 140 SfxItemSet SvxOutlinerForwarder::GetParaAttribs( sal_Int32 nPara ) const
 141 {
 142     if( mpParaAttribsCache )
 143     {
 144         // have we the correct set in cache?
 145         if( nPara == mnParaAttribsCache )
 146         {
 147             // yes! just return the cache
 148             return *mpParaAttribsCache;
 149         }
 150         else
 151         {
 152             // no, we need delete the old cache
 153             delete mpParaAttribsCache;
 154             mpParaAttribsCache = NULL;
 155         }
 156     }
 157
 158     mpParaAttribsCache = new SfxItemSet( rOutliner.GetParaAttribs( nPara ) );
 159     mnParaAttribsCache = nPara;
 160
 161     EditEngine& rEditEngine = (EditEngine&)rOutliner.GetEditEngine();
 162
 163     SfxStyleSheet* pStyle = rEditEngine.GetStyleSheet( nPara );
 164     if( pStyle )
 165         mpParaAttribsCache->SetParent( &(pStyle->GetItemSet() ) );
 166
 167     return *mpParaAttribsCache;
 168 }
 169
 170 void SvxOutlinerForwarder::SetParaAttribs( sal_Int32 nPara, const SfxItemSet& rSet )
 171 {
 172     flushCache();
 173
 174     const SfxItemSet* pOldParent = rSet.GetParent();
 175     if( pOldParent )
 176         const_cast<SfxItemSet*>(&rSet)->SetParent( NULL );
 177
 178     rOutliner.SetParaAttribs( nPara, rSet );
 179
 180     if( pOldParent )
 181         const_cast<SfxItemSet*>(&rSet)->SetParent( pOldParent );
 182 }
 183
 184 void SvxOutlinerForwarder::RemoveAttribs( const ESelection& rSelection, bool bRemoveParaAttribs, sal_uInt16 nWhich )
 185 {
 186     rOutliner.RemoveAttribs( rSelection, bRemoveParaAttribs, nWhich );
 187 }
 188
 189 SfxItemPool* SvxOutlinerForwarder::GetPool() const
 190 {
 191     return rOutliner.GetEmptyItemSet().GetPool();
 192 }
 193
 194 void SvxOutlinerForwarder::GetPortions( sal_Int32 nPara, std::vector<sal_Int32>& rList ) const
 195 {
 196     ((EditEngine&)rOutliner.GetEditEngine()).GetPortions( nPara, rList );
 197 }
 198
 199 void SvxOutlinerForwarder::QuickInsertText( const OUString& rText, const ESelection& rSel )
 200 {
 201     flushCache();
 202     if( rText.isEmpty() )
 203     {
 204         rOutliner.QuickDelete( rSel );
 205     }
 206     else
 207     {
 208         rOutliner.QuickInsertText( rText, rSel );
 209     }
 210 }
 211
 212 void SvxOutlinerForwarder::QuickInsertLineBreak( const ESelection& rSel )
 213 {
 214     flushCache();
 215     rOutliner.QuickInsertLineBreak( rSel );
 216 }
 217
 218 void SvxOutlinerForwarder::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 219 {
 220     flushCache();
 221     rOutliner.QuickInsertField( rFld, rSel );
 222 }
 223
 224 void SvxOutlinerForwarder::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 225 {
 226     flushCache();
 227     rOutliner.QuickSetAttribs( rSet, rSel );
 228 }
 229
 230 OUString SvxOutlinerForwarder::CalcFieldValue( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, Color*& rpTxtColor, Color*& rpFldColor )
 231 {
 232     return rOutliner.CalcFieldValue( rField, nPara, nPos, rpTxtColor, rpFldColor );
 233 }
 234
 235 void SvxOutlinerForwarder::FieldClicked( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos )
 236 {
 237     rOutliner.FieldClicked( rField, nPara, nPos );
 238 }
 239
 240 bool SvxOutlinerForwarder::IsValid() const
 241 {
 242     // cannot reliably query outliner state
 243     // while in the middle of an update
 244     return rOutliner.GetUpdateMode();
 245 }
 246
 247 SfxItemState SvxOutlinerForwarder::GetItemState( const ESelection& rSel, sal_uInt16 nWhich ) const
 248 {
 249     return GetSvxEditEngineItemState( (EditEngine&)rOutliner.GetEditEngine(), rSel, nWhich );
 250 }
 251
 252 SfxItemState SvxOutlinerForwarder::GetItemState( sal_Int32 nPara, sal_uInt16 nWhich ) const
 253 {
 254     const SfxItemSet& rSet = rOutliner.GetParaAttribs( nPara );
 255     return rSet.GetItemState( nWhich );
 256 }
 257
 258
 259 void SvxOutlinerForwarder::flushCache()
 260 {
 261     if( mpAttribsCache )
 262     {
 263         delete mpAttribsCache;
 264         mpAttribsCache = NULL;
 265     }
 266
 267     if( mpParaAttribsCache )
 268     {
 269         delete mpParaAttribsCache;
 270         mpParaAttribsCache = NULL;
 271     }
 272 }
 273
 274 LanguageType SvxOutlinerForwarder::GetLanguage( sal_Int32 nPara, sal_Int32 nIndex ) const
 275 {
 276     return rOutliner.GetLanguage(nPara, nIndex);
 277 }
 278
 279 sal_Int32 SvxOutlinerForwarder::GetFieldCount( sal_Int32 nPara ) const
 280 {
 281     return rOutliner.GetEditEngine().GetFieldCount(nPara);
 282 }
 283
 284 EFieldInfo SvxOutlinerForwarder::GetFieldInfo( sal_Int32 nPara, sal_uInt16 nField ) const
 285 {
 286     return rOutliner.GetEditEngine().GetFieldInfo( nPara, nField );
 287 }
 288
 289 EBulletInfo SvxOutlinerForwarder::GetBulletInfo( sal_Int32 nPara ) const
 290 {
 291     return rOutliner.GetBulletInfo( nPara );
 292 }
 293
 294 Rectangle SvxOutlinerForwarder::GetCharBounds( sal_Int32 nPara, sal_Int32 nIndex ) const
 295 {
 296     // EditEngine's 'internal' methods like GetCharacterBounds()
 297     // don't rotate for vertical text.
 298     Size aSize( rOutliner.CalcTextSize() );
 299     ::std::swap( aSize.Width(), aSize.Height() );
 300     bool bIsVertical( rOutliner.IsVertical() );
 301
 302     // #108900# Handle virtual position one-past-the end of the string
 303     if( nIndex >= GetTextLen(nPara) )
 304     {
 305         Rectangle aLast;
 306
 307         if( nIndex )
 308         {
 309             // use last character, if possible
 310             aLast = rOutliner.GetEditEngine().GetCharacterBounds( EPosition(nPara, nIndex-1) );
 311
 312             // move at end of this last character, make one pixel wide
 313             aLast.Move( aLast.Right() - aLast.Left(), 0 );
 314             aLast.SetSize( Size(1, aLast.GetHeight()) );
 315
 316             // take care for CTL
 317             aLast = SvxEditSourceHelper::EEToUserSpace( aLast, aSize, bIsVertical );
 318         }
 319         else
 320         {
 321             // #109864# Bounds must lie within the paragraph
 322             aLast = GetParaBounds( nPara );
 323
 324             // #109151# Don't use paragraph height, but line height
 325             // instead. aLast is already CTL-correct
 326             if( bIsVertical)
 327                 aLast.SetSize( Size( rOutliner.GetLineHeight(nPara,0), 1 ) );
 328             else
 329                 aLast.SetSize( Size( 1, rOutliner.GetLineHeight(nPara,0) ) );
 330         }
 331
 332         return aLast;
 333     }
 334     else
 335     {
 336         return SvxEditSourceHelper::EEToUserSpace( rOutliner.GetEditEngine().GetCharacterBounds( EPosition(nPara, nIndex) ),
 337                                                    aSize, bIsVertical );
 338     }
 339 }
 340
 341 Rectangle SvxOutlinerForwarder::GetParaBounds( sal_Int32 nPara ) const
 342 {
 343     Point aPnt = rOutliner.GetDocPosTopLeft( nPara );
 344     Size aSize = rOutliner.CalcTextSize();
 345
 346     if( rOutliner.IsVertical() )
 347     {
 348         // Hargl. Outliner's 'external' methods return the rotated
 349         // dimensions, 'internal' methods like GetTextHeight( n )
 350         // don't rotate.
 351         sal_uLong nWidth = rOutliner.GetTextHeight( nPara );
 352
 353         return Rectangle( aSize.Width() - aPnt.Y() - nWidth, 0, aSize.Width() - aPnt.Y(), aSize.Height() );
 354     }
 355     else
 356     {
 357         sal_uLong nHeight = rOutliner.GetTextHeight( nPara );
 358
 359         return Rectangle( 0, aPnt.Y(), aSize.Width(), aPnt.Y() + nHeight );
 360     }
 361 }
 362
 363 MapMode SvxOutlinerForwarder::GetMapMode() const
 364 {
 365     return rOutliner.GetRefMapMode();
 366 }
 367
 368 OutputDevice* SvxOutlinerForwarder::GetRefDevice() const
 369 {
 370     return rOutliner.GetRefDevice();
 371 }
 372
 373 bool SvxOutlinerForwarder::GetIndexAtPoint( const Point& rPos, sal_Int32& nPara, sal_Int32& nIndex ) const
 374 {
 375     Size aSize( rOutliner.CalcTextSize() );
 376     ::std::swap( aSize.Width(), aSize.Height() );
 377     Point aEEPos( SvxEditSourceHelper::UserSpaceToEE( rPos,
 378                                                       aSize,
 379                                                       rOutliner.IsVertical() ));
 380
 381     EPosition aDocPos = rOutliner.GetEditEngine().FindDocPosition( aEEPos );
 382
 383     nPara = aDocPos.nPara;
 384     nIndex = aDocPos.nIndex;
 385
 386     return true;
 387 }
 388
 389 bool SvxOutlinerForwarder::GetWordIndices( sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart, sal_Int32& nEnd ) const
 390 {
 391     ESelection aRes = rOutliner.GetEditEngine().GetWord( ESelection(nPara, nIndex, nPara, nIndex), com::sun::star::i18n::WordType::DICTIONARY_WORD );
 392
 393     if( aRes.nStartPara == nPara &&
 394         aRes.nStartPara == aRes.nEndPara )
 395     {
 396         nStart = aRes.nStartPos;
 397         nEnd = aRes.nEndPos;
 398
 399         return true;
 400     }
 401
 402     return false;
 403 }
 404
 405 bool SvxOutlinerForwarder::GetAttributeRun( sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara, sal_Int32 nIndex, bool bInCell ) const
 406 {
 407     return SvxEditSourceHelper::GetAttributeRun( nStartIndex, nEndIndex, rOutliner.GetEditEngine(), nPara, nIndex, bInCell );
 408 }
 409
 410 sal_Int32 SvxOutlinerForwarder::GetLineCount( sal_Int32 nPara ) const
 411 {
 412     return rOutliner.GetLineCount(nPara);
 413 }
 414
 415 sal_Int32 SvxOutlinerForwarder::GetLineLen( sal_Int32 nPara, sal_Int32 nLine ) const
 416 {
 417     return rOutliner.GetLineLen(nPara, nLine);
 418 }
 419
 420 void SvxOutlinerForwarder::GetLineBoundaries( /*out*/sal_Int32 &rStart, /*out*/sal_Int32 &rEnd, sal_Int32 nPara, sal_Int32 nLine ) const
 421 {
 422     return rOutliner.GetEditEngine().GetLineBoundaries( rStart, rEnd, nPara, nLine );
 423 }
 424
 425 sal_Int32 SvxOutlinerForwarder::GetLineNumberAtIndex( sal_Int32 nPara, sal_Int32 nIndex ) const
 426 {
 427     return rOutliner.GetEditEngine().GetLineNumberAtIndex( nPara, nIndex );
 428 }
 429
 430 bool SvxOutlinerForwarder::QuickFormatDoc( bool )
 431 {
 432     rOutliner.QuickFormatDoc();
 433
 434     return true;
 435 }
 436
 437 bool SvxOutlinerForwarder::Delete( const ESelection& rSelection )
 438 {
 439     flushCache();
 440     rOutliner.QuickDelete( rSelection );
 441     rOutliner.QuickFormatDoc();
 442
 443     return true;
 444 }
 445
 446 bool SvxOutlinerForwarder::InsertText( const OUString& rStr, const ESelection& rSelection )
 447 {
 448     flushCache();
 449     rOutliner.QuickInsertText( rStr, rSelection );
 450     rOutliner.QuickFormatDoc();
 451
 452     return true;
 453 }
 454
 455 sal_Int16 SvxOutlinerForwarder::GetDepth( sal_Int32 nPara ) const
 456 {
 457     DBG_ASSERT( 0 <= nPara && nPara < GetParagraphCount(), "SvxOutlinerForwarder::GetDepth: Invalid paragraph index");
 458
 459     Paragraph* pPara = rOutliner.GetParagraph( nPara );
 460
 461     sal_Int16 nLevel = -1;
 462
 463     if( pPara )
 464         nLevel = rOutliner.GetDepth( nPara );
 465
 466     return nLevel;
 467 }
 468
 469 bool SvxOutlinerForwarder::SetDepth( sal_Int32 nPara, sal_Int16 nNewDepth )
 470 {
 471     DBG_ASSERT( 0 <= nPara && nPara < GetParagraphCount(), "SvxOutlinerForwarder::SetDepth: Invalid paragraph index");
 472
 473     if( (nNewDepth >= -1) && (nNewDepth <= 9) && (0 <= nPara && nPara < GetParagraphCount()) )
 474     {
 475         Paragraph* pPara = rOutliner.GetParagraph( nPara );
 476         if( pPara )
 477         {
 478             rOutliner.SetDepth( pPara, nNewDepth );
 479
 480 //          const bool bOutlinerText = pSdrObject && (pSdrObject->GetObjInventor() == SdrInventor) && (pSdrObject->GetObjIdentifier() == OBJ_OUTLINETEXT);
 481             if( bOutlinerText )
 482                 rOutliner.SetLevelDependendStyleSheet( nPara );
 483
 484             return true;
 485         }
 486     }
 487
 488     return false;
 489 }
 490
 491 sal_Int32 SvxOutlinerForwarder::GetNumberingStartValue( sal_Int32 nPara )
 492 {
 493     if( 0 <= nPara && nPara < GetParagraphCount() )
 494     {
 495         return rOutliner.GetNumberingStartValue( nPara );
 496     }
 497     else
 498     {
 499         OSL_FAIL( "SvxOutlinerForwarder::GetNumberingStartValue)(), Invalid paragraph index");
 500         return -1;
 501     }
 502 }
 503
 504 void SvxOutlinerForwarder::SetNumberingStartValue(  sal_Int32 nPara, sal_Int32 nNumberingStartValue )
 505 {
 506     if( 0 <= nPara && nPara < GetParagraphCount() )
 507     {
 508         rOutliner.SetNumberingStartValue( nPara, nNumberingStartValue );
 509     }
 510     else
 511     {
 512         OSL_FAIL( "SvxOutlinerForwarder::SetNumberingStartValue)(), Invalid paragraph index");
 513     }
 514 }
 515
 516 bool SvxOutlinerForwarder::IsParaIsNumberingRestart( sal_Int32 nPara )
 517 {
 518     if( 0 <= nPara && nPara < GetParagraphCount() )
 519     {
 520         return rOutliner.IsParaIsNumberingRestart( nPara );
 521     }
 522     else
 523     {
 524         OSL_FAIL( "SvxOutlinerForwarder::IsParaIsNumberingRestart)(), Invalid paragraph index");
 525         return false;
 526     }
 527 }
 528
 529 void SvxOutlinerForwarder::SetParaIsNumberingRestart(  sal_Int32 nPara, bool bParaIsNumberingRestart )
 530 {
 531     if( 0 <= nPara && nPara < GetParagraphCount() )
 532     {
 533         rOutliner.SetParaIsNumberingRestart( nPara, bParaIsNumberingRestart );
 534     }
 535     else
 536     {
 537         OSL_FAIL( "SvxOutlinerForwarder::SetParaIsNumberingRestart)(), Invalid paragraph index");
 538     }
 539 }
 540
 541 const SfxItemSet * SvxOutlinerForwarder::GetEmptyItemSetPtr()
 542 {
 543     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 544     return &rEditEngine.GetEmptyItemSet();
 545 }
 546
 547 void SvxOutlinerForwarder::AppendParagraph()
 548 {
 549     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 550     rEditEngine.InsertParagraph( rEditEngine.GetParagraphCount(), OUString() );
 551 }
 552
 553 sal_Int32 SvxOutlinerForwarder::AppendTextPortion( sal_Int32 nPara, const OUString &rText, const SfxItemSet & /*rSet*/ )
 554 {
 555     sal_Int32 nLen = 0;
 556
 557     EditEngine& rEditEngine = const_cast< EditEngine& >( rOutliner.GetEditEngine() );
 558     sal_Int32 nParaCount = rEditEngine.GetParagraphCount();
 559     DBG_ASSERT( 0 <= nPara && nPara < nParaCount, "paragraph index out of bounds" );
 560     if (0 <= nPara && nPara < nParaCount)
 561     {
 562         nLen = rEditEngine.GetTextLen( nPara );
 563         rEditEngine.QuickInsertText( rText, ESelection( nPara, nLen, nPara, nLen ) );
 564     }
 565
 566     return nLen;
 567 }
 568
 569 void  SvxOutlinerForwarder::CopyText(const SvxTextForwarder& rSource)
 570 {
 571     const SvxOutlinerForwarder* pSourceForwarder = dynamic_cast< const SvxOutlinerForwarder* >( &rSource );
 572     if( !pSourceForwarder )
 573         return;
 574     OutlinerParaObject* pNewOutlinerParaObject = pSourceForwarder->rOutliner.CreateParaObject();
 575     rOutliner.SetText( *pNewOutlinerParaObject );
 576     delete pNewOutlinerParaObject;
 577 }
 578
 579
 580
 581
 582 sal_Int32 SvxTextForwarder::GetNumberingStartValue( sal_Int32 )
 583 {
 584     return -1;
 585 }
 586
 587 void SvxTextForwarder::SetNumberingStartValue( sal_Int32, sal_Int32 )
 588 {
 589 }
 590
 591 bool SvxTextForwarder::IsParaIsNumberingRestart( sal_Int32  )
 592 {
 593     return false;
 594 }
 595
 596 void SvxTextForwarder::SetParaIsNumberingRestart( sal_Int32, bool )
 597 {
 598 }
 599
 600
 601
 602 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */