editeng/source/uno/unoforou.cxx

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