svx/source/unoedit/unoforou.cxx

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