svtools/source/undo/undo.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: undo.cxx,v $
  10  * $Revision: 1.11 $
  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_svtools.hxx"
  33
  34 #include <com/sun/star/uno/Exception.hpp>
  35
  36 #include <tools/debug.hxx>
  37
  38 #include <svtools/undo.hxx>
  39
  40 using ::com::sun::star::uno::Exception;
  41
  42 // STATIC DATA -----------------------------------------------------------
  43
  44 DBG_NAME(SfxUndoAction)
  45
  46 //========================================================================
  47
  48 TYPEINIT0(SfxUndoAction);
  49 TYPEINIT0(SfxListUndoAction);
  50 TYPEINIT0(SfxLinkUndoAction);
  51 TYPEINIT0(SfxRepeatTarget);
  52
  53 //------------------------------------------------------------------------
  54
  55 SfxRepeatTarget::~SfxRepeatTarget()
  56 {
  57 }
  58
  59 //------------------------------------------------------------------------
  60
  61 BOOL SfxUndoAction::IsLinked()
  62 {
  63     return bLinked;
  64 }
  65
  66 //------------------------------------------------------------------------
  67
  68 void SfxUndoAction::SetLinked( BOOL bIsLinked )
  69 {
  70     bLinked = bIsLinked;
  71 }
  72
  73 //------------------------------------------------------------------------
  74
  75 SfxUndoAction::~SfxUndoAction()
  76 {
  77     DBG_DTOR(SfxUndoAction, 0);
  78     DBG_ASSERT( !IsLinked(), "Gelinkte Action geloescht" );
  79 }
  80
  81
  82 SfxUndoAction::SfxUndoAction()
  83 {
  84     DBG_CTOR(SfxUndoAction, 0);
  85     SetLinked( FALSE );
  86 }
  87
  88 //------------------------------------------------------------------------
  89
  90 BOOL SfxUndoAction::Merge( SfxUndoAction * )
  91 {
  92     DBG_CHKTHIS(SfxUndoAction, 0);
  93     return FALSE;
  94 }
  95
  96 //------------------------------------------------------------------------
  97
  98 XubString SfxUndoAction::GetComment() const
  99 {
 100     DBG_CHKTHIS(SfxUndoAction, 0);
 101     return XubString();
 102 }
 103
 104 //------------------------------------------------------------------------
 105
 106
 107 USHORT SfxUndoAction::GetId() const
 108 {
 109     DBG_CHKTHIS(SfxUndoAction, 0);
 110     return 0;
 111 }
 112
 113 //------------------------------------------------------------------------
 114
 115 XubString SfxUndoAction::GetRepeatComment(SfxRepeatTarget&) const
 116 {
 117     DBG_CHKTHIS(SfxUndoAction, 0);
 118     return GetComment();
 119 }
 120
 121 //------------------------------------------------------------------------
 122
 123
 124 void SfxUndoAction::Undo()
 125 {
 126     // die sind nur konzeptuell pure virtual
 127     DBG_ERROR( "pure virtual function called: SfxUndoAction::Undo()" );
 128 }
 129
 130 //------------------------------------------------------------------------
 131
 132 void SfxUndoAction::Redo()
 133 {
 134     // die sind nur konzeptuell pure virtual
 135     DBG_ERROR( "pure virtual function called: SfxUndoAction::Redo()" );
 136 }
 137
 138 //------------------------------------------------------------------------
 139
 140 void SfxUndoAction::Repeat(SfxRepeatTarget&)
 141 {
 142     // die sind nur konzeptuell pure virtual
 143     DBG_ERROR( "pure virtual function called: SfxUndoAction::Repeat()" );
 144 }
 145
 146 //------------------------------------------------------------------------
 147
 148
 149 BOOL SfxUndoAction::CanRepeat(SfxRepeatTarget&) const
 150 {
 151     return TRUE;
 152 }
 153
 154 //========================================================================
 155
 156
 157 SfxUndoManager::SfxUndoManager( USHORT nMaxUndoActionCount )
 158  : pFatherUndoArray(0)
 159  , mbUndoEnabled( true )
 160 {
 161     pUndoArray=new SfxUndoArray(nMaxUndoActionCount);
 162     pActUndoArray=pUndoArray;
 163
 164 }
 165
 166 //------------------------------------------------------------------------
 167
 168
 169 SfxUndoManager::~SfxUndoManager()
 170 {
 171     delete pUndoArray;
 172 }
 173
 174 //------------------------------------------------------------------------
 175
 176 void SfxUndoManager::EnableUndo( bool bEnable )
 177 {
 178     mbUndoEnabled = bEnable;
 179 }
 180
 181 //------------------------------------------------------------------------
 182
 183
 184 void SfxUndoManager::SetMaxUndoActionCount( USHORT nMaxUndoActionCount )
 185 {
 186     // Remove entries from the pActUndoArray when we have to reduce
 187     // the number of entries due to a lower nMaxUndoActionCount.
 188     // Both redo and undo action entries will be removed until we reached the
 189     // new nMaxUndoActionCount.
 190
 191     long nNumToDelete = pActUndoArray->aUndoActions.Count() - nMaxUndoActionCount;
 192     if ( nNumToDelete > 0 )
 193     {
 194         while ( nNumToDelete > 0 )
 195         {
 196             USHORT nPos = pActUndoArray->aUndoActions.Count();
 197             if ( nPos > pActUndoArray->nCurUndoAction )
 198             {
 199                 if ( !pActUndoArray->aUndoActions[nPos-1]->IsLinked() )
 200                 {
 201                     delete pActUndoArray->aUndoActions[nPos-1];
 202                     pActUndoArray->aUndoActions.Remove( nPos-1 );
 203                     --nNumToDelete;
 204                 }
 205             }
 206
 207             if ( nNumToDelete > 0 && pActUndoArray->nCurUndoAction > 0 )
 208             {
 209                 if ( !pActUndoArray->aUndoActions[0]->IsLinked() )
 210                 {
 211                     delete pActUndoArray->aUndoActions[0];
 212                     pActUndoArray->aUndoActions.Remove(0);
 213                     --pActUndoArray->nCurUndoAction;
 214                     --nNumToDelete;
 215                 }
 216             }
 217
 218             if ( nPos == pActUndoArray->aUndoActions.Count() )
 219                 break; // Cannot delete more entries
 220         }
 221     }
 222
 223     pActUndoArray->nMaxUndoActions = nMaxUndoActionCount;
 224 }
 225
 226 //------------------------------------------------------------------------
 227
 228 USHORT SfxUndoManager::GetMaxUndoActionCount() const
 229 {
 230     return pActUndoArray->nMaxUndoActions;
 231 }
 232
 233 //------------------------------------------------------------------------
 234
 235 void SfxUndoManager::Clear()
 236 {
 237     while ( pActUndoArray->aUndoActions.Count() )
 238     {
 239         SfxUndoAction *pAction=
 240             pActUndoArray->aUndoActions[pActUndoArray->aUndoActions.Count() - 1];
 241         pActUndoArray->aUndoActions.Remove( pActUndoArray->aUndoActions.Count() - 1 );
 242         delete pAction;
 243     }
 244
 245     pActUndoArray->nCurUndoAction = 0;
 246 }
 247
 248 //------------------------------------------------------------------------
 249
 250 void SfxUndoManager::ClearRedo()
 251 {
 252     while ( pActUndoArray->aUndoActions.Count() > pActUndoArray->nCurUndoAction )
 253     {
 254         SfxUndoAction *pAction=
 255             pActUndoArray->aUndoActions[pActUndoArray->aUndoActions.Count() - 1];
 256         pActUndoArray->aUndoActions.Remove( pActUndoArray->aUndoActions.Count() - 1 );
 257         delete pAction;
 258     }
 259 }
 260
 261 //------------------------------------------------------------------------
 262
 263 void SfxUndoManager::AddUndoAction( SfxUndoAction *pAction, BOOL bTryMerge )
 264 {
 265     if( mbUndoEnabled )
 266     {
 267         // Redo-Actions loeschen
 268         for ( USHORT nPos = pActUndoArray->aUndoActions.Count();
 269               nPos > pActUndoArray->nCurUndoAction; --nPos )
 270             delete pActUndoArray->aUndoActions[nPos-1];
 271
 272         pActUndoArray->aUndoActions.Remove(
 273             pActUndoArray->nCurUndoAction,
 274             pActUndoArray->aUndoActions.Count() - pActUndoArray->nCurUndoAction );
 275
 276         if ( pActUndoArray->nMaxUndoActions )
 277         {
 278             SfxUndoAction *pTmpAction = pActUndoArray->nCurUndoAction ?
 279                 pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction-1] : 0;
 280
 281             if ( !bTryMerge || !(pTmpAction && pTmpAction->Merge(pAction)) )
 282             {
 283                 // auf Max-Anzahl anpassen
 284                 if( pActUndoArray == pUndoArray )
 285                     while( pActUndoArray->aUndoActions.Count() >=
 286                            pActUndoArray->nMaxUndoActions &&
 287                            !pActUndoArray->aUndoActions[0]->IsLinked() )
 288                     {
 289                         delete pActUndoArray->aUndoActions[0];
 290                         pActUndoArray->aUndoActions.Remove(0);
 291                         --pActUndoArray->nCurUndoAction;
 292                     }
 293
 294                 // neue Action anh"angen
 295                 const SfxUndoAction* pTemp = pAction;
 296                 pActUndoArray->aUndoActions.Insert(
 297                     pTemp, pActUndoArray->nCurUndoAction++ );
 298                 return;
 299             }
 300         }
 301     }
 302     delete pAction;
 303 }
 304
 305 //------------------------------------------------------------------------
 306
 307 USHORT SfxUndoManager::GetUndoActionCount() const
 308 {
 309     return pActUndoArray->nCurUndoAction;
 310 }
 311
 312 //------------------------------------------------------------------------
 313
 314 XubString SfxUndoManager::GetUndoActionComment( USHORT nNo ) const
 315 {
 316     DBG_ASSERT( nNo < pActUndoArray->nCurUndoAction, "svtools::SfxUndoManager::GetUndoActionComment(), illegal id!" );
 317     if( nNo < pActUndoArray->nCurUndoAction )
 318     {
 319         return pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction-1-nNo]->GetComment(); //!
 320     }
 321     else
 322     {
 323         XubString aEmpty;
 324         return aEmpty;
 325     }
 326 }
 327
 328 //------------------------------------------------------------------------
 329
 330 USHORT SfxUndoManager::GetUndoActionId( USHORT nNo ) const
 331 {
 332     DBG_ASSERT( nNo < pActUndoArray->nCurUndoAction, "svtools::SfxUndoManager::GetUndoActionId(), illegal id!" );
 333     if( nNo < pActUndoArray->nCurUndoAction )
 334     {
 335         return pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction-1-nNo]->GetId(); //!
 336     }
 337     else
 338     {
 339         return 0;
 340     }
 341 }
 342
 343 //------------------------------------------------------------------------
 344
 345 SfxUndoAction* SfxUndoManager::GetUndoAction( USHORT nNo ) const
 346 {
 347     DBG_ASSERT( nNo < pActUndoArray->nCurUndoAction, "svtools::SfxUndoManager::GetUndoAction(), illegal id!" );
 348     if( nNo < pActUndoArray->nCurUndoAction )
 349     {
 350         return pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction-1-nNo]; //!
 351     }
 352     else
 353     {
 354         return 0;
 355     }
 356 }
 357
 358 //------------------------------------------------------------------------
 359
 360 /** clears the redo stack and removes the top undo action */
 361 void SfxUndoManager::RemoveLastUndoAction()
 362 {
 363     DBG_ASSERT( pActUndoArray->nCurUndoAction, "svtools::SfxUndoManager::RemoveLastUndoAction(), no action to remove?!" );
 364     if( pActUndoArray->nCurUndoAction )
 365     {
 366         pActUndoArray->nCurUndoAction--;
 367
 368         // delete redo-actions and top action
 369         USHORT nPos;
 370         for ( nPos = pActUndoArray->aUndoActions.Count(); nPos > pActUndoArray->nCurUndoAction; --nPos )
 371             delete pActUndoArray->aUndoActions[nPos-1];
 372
 373         pActUndoArray->aUndoActions.Remove(
 374             pActUndoArray->nCurUndoAction,
 375             pActUndoArray->aUndoActions.Count() - pActUndoArray->nCurUndoAction );
 376     }
 377 }
 378
 379 //------------------------------------------------------------------------
 380
 381 BOOL SfxUndoManager::Undo( USHORT )
 382 {
 383     bool bUndoWasEnabled =      mbUndoEnabled;
 384     mbUndoEnabled = false;
 385
 386     BOOL bRet = FALSE;
 387
 388     try
 389     {
 390         DBG_ASSERT( pActUndoArray == pUndoArray, "svtools::SfxUndoManager::Undo(), LeaveListAction() not yet called!" );
 391         if ( pActUndoArray->nCurUndoAction )
 392         {
 393             Undo( *pActUndoArray->aUndoActions[ --pActUndoArray->nCurUndoAction ] );
 394             bRet = TRUE;
 395         }
 396     }
 397     catch( Exception& e )
 398     {
 399         mbUndoEnabled = bUndoWasEnabled;
 400         throw e;
 401     }
 402     mbUndoEnabled = bUndoWasEnabled;
 403     return bRet;
 404 }
 405
 406 //------------------------------------------------------------------------
 407
 408 void SfxUndoManager::Undo( SfxUndoAction &rAction )
 409 {
 410     bool bUndoWasEnabled =      mbUndoEnabled;
 411     mbUndoEnabled = false;
 412     try
 413     {
 414         rAction.Undo();
 415     }
 416     catch( Exception& e )
 417     {
 418         mbUndoEnabled = bUndoWasEnabled;
 419         throw e;
 420     }
 421
 422     mbUndoEnabled = bUndoWasEnabled;
 423 }
 424
 425 //------------------------------------------------------------------------
 426
 427 USHORT SfxUndoManager::GetRedoActionCount() const
 428 {
 429     return pActUndoArray->aUndoActions.Count() - pActUndoArray->nCurUndoAction; //!
 430 }
 431
 432 //------------------------------------------------------------------------
 433
 434 XubString SfxUndoManager::GetRedoActionComment( USHORT nNo ) const
 435 {
 436     return pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction+nNo]->GetComment(); //!
 437 }
 438
 439 //------------------------------------------------------------------------
 440
 441 USHORT SfxUndoManager::GetRedoActionId( USHORT nNo ) const
 442 {
 443     return pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction+nNo]->GetId(); //!
 444 }
 445
 446 //------------------------------------------------------------------------
 447
 448 BOOL SfxUndoManager::Redo( USHORT )
 449 {
 450     bool bUndoWasEnabled =      mbUndoEnabled;
 451     mbUndoEnabled = false;
 452
 453     BOOL bRet = FALSE;
 454
 455     try
 456     {
 457         if ( pActUndoArray->aUndoActions.Count() > pActUndoArray->nCurUndoAction )
 458         {
 459             Redo( *pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction++] );
 460             bRet = TRUE;
 461         }
 462     }
 463     catch( Exception& e )
 464     {
 465         mbUndoEnabled = bUndoWasEnabled;
 466         throw e;
 467     }
 468
 469     mbUndoEnabled = bUndoWasEnabled;
 470     return bRet;
 471 }
 472
 473 //------------------------------------------------------------------------
 474
 475 void SfxUndoManager::Redo( SfxUndoAction &rAction )
 476 {
 477     bool bUndoWasEnabled =      mbUndoEnabled;
 478     mbUndoEnabled = false;
 479
 480     try
 481     {
 482         rAction.Redo();
 483     }
 484     catch( Exception& e )
 485     {
 486         mbUndoEnabled = bUndoWasEnabled;
 487         throw e;
 488     }
 489
 490     mbUndoEnabled = bUndoWasEnabled;
 491 }
 492
 493 //------------------------------------------------------------------------
 494
 495 USHORT SfxUndoManager::GetRepeatActionCount() const
 496 {
 497     return pActUndoArray->aUndoActions.Count();
 498 }
 499
 500 //------------------------------------------------------------------------
 501
 502 XubString SfxUndoManager::GetRepeatActionComment( SfxRepeatTarget &rTarget, USHORT nNo ) const
 503 {
 504     return pActUndoArray->aUndoActions[ pActUndoArray->aUndoActions.Count() - 1 - nNo ]
 505         ->GetRepeatComment(rTarget);
 506 }
 507
 508 //------------------------------------------------------------------------
 509
 510 BOOL SfxUndoManager::Repeat( SfxRepeatTarget &rTarget, USHORT /*nFrom*/, USHORT /*nCount*/ )
 511 {
 512     if ( pActUndoArray->aUndoActions.Count() )
 513     {
 514         Repeat( rTarget, *pActUndoArray->aUndoActions[ pActUndoArray->aUndoActions.Count() - 1 ] );
 515         return TRUE;
 516     }
 517
 518     return FALSE;
 519 }
 520
 521 //------------------------------------------------------------------------
 522
 523 void SfxUndoManager::Repeat( SfxRepeatTarget &rTarget, SfxUndoAction &rAction )
 524 {
 525     if ( rAction.CanRepeat(rTarget) )
 526         rAction.Repeat(rTarget);
 527 }
 528
 529 //------------------------------------------------------------------------
 530
 531 BOOL SfxUndoManager::CanRepeat( SfxRepeatTarget &rTarget, SfxUndoAction &rAction ) const
 532 {
 533     return rAction.CanRepeat(rTarget);
 534 }
 535
 536 //------------------------------------------------------------------------
 537
 538 BOOL SfxUndoManager::CanRepeat( SfxRepeatTarget &rTarget, USHORT nNo ) const
 539 {
 540     if ( pActUndoArray->aUndoActions.Count() > nNo )
 541     {
 542         USHORT nActionNo = pActUndoArray->aUndoActions.Count() - 1 - nNo;
 543         return pActUndoArray->aUndoActions[nActionNo]->CanRepeat(rTarget);
 544     }
 545
 546     return FALSE;
 547 }
 548
 549 //------------------------------------------------------------------------
 550
 551 void SfxUndoManager::EnterListAction(
 552     const XubString& rComment, const XubString &rRepeatComment, USHORT nId )
 553
 554 /*      [Beschreibung]
 555
 556     Fuegt eine ListUndoAction ein und setzt dessen UndoArray als aktuelles.
 557 */
 558
 559 {
 560     if( !mbUndoEnabled )
 561         return;
 562
 563     if ( !pUndoArray->nMaxUndoActions )
 564         return;
 565
 566     pFatherUndoArray=pActUndoArray;
 567     SfxListUndoAction *pAction=new SfxListUndoAction(
 568         rComment, rRepeatComment, nId, pActUndoArray);
 569     AddUndoAction( pAction );
 570     pActUndoArray=pAction;
 571 }
 572
 573 //------------------------------------------------------------------------
 574
 575 void SfxUndoManager::LeaveListAction()
 576
 577 /*      [Beschreibung]
 578
 579     Verlaesst die aktuelle ListAction und geht eine Ebene nach oben.
 580 */
 581 {
 582     if ( !mbUndoEnabled )
 583         return;
 584
 585     if ( !pUndoArray->nMaxUndoActions )
 586         return;
 587
 588     if( pActUndoArray == pUndoArray )
 589     {
 590         DBG_ERROR( "svtools::SfxUndoManager::LeaveListAction(), called without calling EnterListAction()!" );
 591         return;
 592     }
 593
 594     DBG_ASSERT(pActUndoArray->pFatherUndoArray,"svtools::SfxUndoManager::LeaveListAction(), no father undo array!?");
 595
 596     SfxUndoArray* pTmp=pActUndoArray;
 597     pActUndoArray=pActUndoArray->pFatherUndoArray;
 598
 599     // If no undo action where added, delete the undo list action
 600     SfxUndoAction *pTmpAction= pActUndoArray->aUndoActions[pActUndoArray->nCurUndoAction-1];
 601     if(!pTmp->nCurUndoAction)
 602     {
 603         pActUndoArray->aUndoActions.Remove( --pActUndoArray->nCurUndoAction);
 604         delete pTmpAction;
 605     }
 606     else
 607     {
 608         // if the undo array has no comment, try to get it from its children
 609         SfxListUndoAction* pList = dynamic_cast< SfxListUndoAction * >( pTmpAction );
 610         if( pList && pList->GetComment().Len() == 0 )
 611         {
 612             USHORT n;
 613             for( n = 0; n < pList->aUndoActions.Count(); n++ )
 614             {
 615                 if( pList->aUndoActions[n]->GetComment().Len() )
 616                 {
 617                     pList->SetComment( pList->aUndoActions[n]->GetComment() );
 618                     break;
 619                 }
 620             }
 621         }
 622     }
 623 }
 624
 625 //------------------------------------------------------------------------
 626
 627 USHORT SfxListUndoAction::GetId() const
 628 {
 629     return nId;
 630 }
 631
 632 //------------------------------------------------------------------------
 633
 634 XubString SfxListUndoAction::GetComment() const
 635 {
 636     return aComment;
 637 }
 638
 639 //------------------------------------------------------------------------
 640
 641 void SfxListUndoAction::SetComment( const UniString& rComment )
 642 {
 643     aComment = rComment;
 644 }
 645
 646 //------------------------------------------------------------------------
 647
 648 XubString SfxListUndoAction::GetRepeatComment(SfxRepeatTarget &) const
 649 {
 650     return aRepeatComment;
 651 }
 652
 653
 654 //------------------------------------------------------------------------
 655
 656 SfxListUndoAction::SfxListUndoAction
 657 (
 658     const XubString &rComment,
 659     const XubString rRepeatComment,
 660     USHORT Id,
 661     SfxUndoArray *pFather
 662 )
 663 : nId(Id), aComment(rComment), aRepeatComment(rRepeatComment)
 664 {
 665     pFatherUndoArray = pFather;
 666     nMaxUndoActions = USHRT_MAX;
 667 }
 668
 669 //------------------------------------------------------------------------
 670
 671 void SfxListUndoAction::Undo()
 672 {
 673     for(INT16 i=nCurUndoAction-1;i>=0;i--)
 674         aUndoActions[i]->Undo();
 675     nCurUndoAction=0;
 676 }
 677
 678 //------------------------------------------------------------------------
 679
 680 void SfxListUndoAction::Redo()
 681 {
 682     for(USHORT i=nCurUndoAction;i<aUndoActions.Count();i++)
 683         aUndoActions[i]->Redo();
 684     nCurUndoAction = aUndoActions.Count();
 685 }
 686
 687 //------------------------------------------------------------------------
 688
 689 void SfxListUndoAction::Repeat(SfxRepeatTarget&rTarget)
 690 {
 691     for(USHORT i=0;i<nCurUndoAction;i++)
 692         aUndoActions[i]->Repeat(rTarget);
 693 }
 694
 695 //------------------------------------------------------------------------
 696
 697 BOOL SfxListUndoAction::CanRepeat(SfxRepeatTarget&r)  const
 698 {
 699     for(USHORT i=0;i<nCurUndoAction;i++)
 700         if(!aUndoActions[i]->CanRepeat(r))
 701             return FALSE;
 702     return TRUE;
 703 }
 704
 705 //------------------------------------------------------------------------
 706
 707 BOOL SfxListUndoAction::Merge( SfxUndoAction *pNextAction )
 708 {
 709     return aUndoActions.Count() && aUndoActions[aUndoActions.Count()-1]->Merge( pNextAction );
 710 }
 711
 712 //------------------------------------------------------------------------
 713
 714 SfxLinkUndoAction::SfxLinkUndoAction(SfxUndoManager *pManager)
 715 /*      [Beschreibung]
 716
 717     Richtet eine LinkAction ein, die auf einen weiteren UndoManager zeigt.
 718     Holt sich als zugehoerige Action des weiteren UndoManagers dessen
 719     aktuelle Action.
 720 */
 721
 722 {
 723     pUndoManager = pManager;
 724     if ( pManager->GetMaxUndoActionCount() )
 725     {
 726         USHORT nPos = pManager->GetUndoActionCount()-1;
 727         pAction = pManager->pActUndoArray->aUndoActions[nPos];
 728         pAction->SetLinked();
 729     }
 730     else
 731         pAction = 0;
 732 }
 733
 734 //------------------------------------------------------------------------
 735
 736 void SfxLinkUndoAction::Undo()
 737 {
 738     if ( pAction )
 739         pUndoManager->Undo(1);
 740 }
 741
 742 //------------------------------------------------------------------------
 743
 744 void SfxLinkUndoAction::Redo()
 745 {
 746     if ( pAction )
 747         pUndoManager->Redo(1);
 748 }
 749
 750 //------------------------------------------------------------------------
 751
 752
 753 BOOL SfxLinkUndoAction::CanRepeat(SfxRepeatTarget& r) const
 754 {
 755     return pAction && pUndoManager->CanRepeat(r,*pAction);
 756 }
 757
 758
 759 //------------------------------------------------------------------------
 760
 761
 762 void SfxLinkUndoAction::Repeat(SfxRepeatTarget&r)
 763 {
 764     if ( pAction )
 765         pUndoManager->Repeat(r,*pAction);
 766 }
 767
 768
 769 //------------------------------------------------------------------------
 770
 771 XubString SfxLinkUndoAction::GetComment() const
 772 {
 773     if ( pAction )
 774         return pAction->GetComment();
 775     else
 776         return XubString();
 777 }
 778
 779
 780 //------------------------------------------------------------------------
 781
 782 XubString SfxLinkUndoAction::GetRepeatComment(SfxRepeatTarget&r) const
 783 {
 784     if ( pAction )
 785         return pAction->GetRepeatComment(r);
 786     else
 787         return XubString();
 788 }
 789
 790 //------------------------------------------------------------------------
 791
 792 SfxLinkUndoAction::~SfxLinkUndoAction()
 793 {
 794     if( pAction )
 795         pAction->SetLinked( FALSE );
 796 }
 797
 798
 799 //------------------------------------------------------------------------
 800
 801 SfxUndoArray::~SfxUndoArray()
 802 {
 803     while ( aUndoActions.Count() )
 804     {
 805         SfxUndoAction *pAction =
 806             aUndoActions[ aUndoActions.Count() - 1 ];
 807         aUndoActions.Remove( aUndoActions.Count() - 1 );
 808         delete pAction;
 809     }
 810 }
 811
 812
 813 USHORT SfxLinkUndoAction::GetId() const
 814 {
 815       return pAction ? pAction->GetId() : 0;
 816 }
 817
 818
 819