sw/source/core/undo/docundo.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: docundo.cxx,v $
  10  * $Revision: 1.26 $
  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_sw.hxx"
  33
  34 #include <svx/svdmodel.hxx>
  35
  36 #include <vcl/wrkwin.hxx>
  37 #include <doc.hxx>
  38 #include <pam.hxx>
  39 #include <ndtxt.hxx>
  40 #include <swundo.hxx>           // fuer die UndoIds
  41 #include <undobj.hxx>
  42 #include <rolbck.hxx>
  43 #include <docary.hxx>
  44 #ifndef _UNDO_HRC
  45 #include <undo.hrc>
  46 #endif
  47
  48
  49 using namespace ::com::sun::star;
  50
  51
  52 USHORT SwDoc::nUndoActions = UNDO_ACTION_COUNT;         // anzahl von Undo-Action
  53
  54 // the undo array should never grow beyond this limit:
  55 #define UNDO_ACTION_LIMIT (USHRT_MAX - 1000)
  56
  57
  58 SV_IMPL_PTRARR( SwUndoIds, SwUndoIdAndNamePtr )
  59
  60 //#define _SHOW_UNDORANGE
  61 #ifdef _SHOW_UNDORANGE
  62
  63
  64 class UndoArrStatus : public WorkWindow
  65 {
  66     USHORT nUndo, nUndoNds;
  67     virtual void Paint( const Rectangle& );
  68 public:
  69     UndoArrStatus();
  70     void Set( USHORT, USHORT );
  71 };
  72 static UndoArrStatus* pUndoMsgWin = 0;
  73
  74
  75 UndoArrStatus::UndoArrStatus()
  76     : WorkWindow( APP_GETAPPWINDOW() ), nUndo(0), nUndoNds(0)
  77 {
  78     SetSizePixel( Size( 200, 100 ));
  79     SetFont( Font( "Courier", Size( 0, 10 )) );
  80     Show();
  81 }
  82
  83
  84 void UndoArrStatus::Set( USHORT n1, USHORT n2 )
  85 {
  86     nUndo = n1; nUndoNds = n2;
  87     Invalidate();
  88 }
  89
  90
  91 void UndoArrStatus::Paint( const Rectangle& )
  92 {
  93     String s;
  94     DrawRect( Rectangle( Point(0,0), GetOutputSize() ));
  95     ( s = "Undos: " ) += nUndo;
  96     DrawText( Point( 0, 0 ), s );
  97     ( s = "UndoNodes: " ) += nUndoNds;
  98     DrawText( Point( 0, 15 ), s );
  99 }
 100
 101 #endif
 102
 103 void SwDoc::SetUndoNoResetModified()
 104 {
 105     nUndoSavePos = USHRT_MAX;
 106 }
 107
 108 bool SwDoc::IsUndoNoResetModified() const
 109 {
 110     return USHRT_MAX == nUndoSavePos;
 111 }
 112
 113 void SwDoc::DoUndo(bool bUn)
 114 {
 115     mbUndo = bUn;
 116
 117     SdrModel* pSdrModel = GetDrawModel();
 118     if( pSdrModel )
 119         pSdrModel->EnableUndo(bUn);
 120 }
 121
 122 bool SwDoc::DoesUndo() const
 123 {
 124     return mbUndo;
 125 }
 126
 127 void SwDoc::DoGroupUndo(bool bUn)
 128 {
 129     mbGroupUndo = bUn;
 130 }
 131
 132 bool SwDoc::DoesGroupUndo() const
 133 {
 134     return mbGroupUndo;
 135 }
 136
 137 sal_uInt16 SwDoc::GetUndoActionCount()
 138 {
 139     return nUndoActions;
 140 }
 141
 142 void SwDoc::SetUndoActionCount( sal_uInt16 nNew )
 143 {
 144     nUndoActions = nNew;
 145 }
 146
 147 const SwNodes* SwDoc::GetUndoNds() const
 148 {
 149     return &aUndoNodes;
 150 }
 151
 152 void SwDoc::AppendUndo( SwUndo* pUndo )
 153 {
 154     if( nsRedlineMode_t::REDLINE_NONE == pUndo->GetRedlineMode() )
 155         pUndo->SetRedlineMode( GetRedlineMode() );
 156
 157     // Unfortunately, the silly SvPtrArr can only store a little less than
 158     // USHRT_MAX elements. Of course it doesn't see any necessity for asserting
 159     // or even doing error handling. pUndos should definitely be replaced by an
 160     // STL container that doesn't have this problem. cf #95884#
 161     DBG_ASSERT( pUndos->Count() < USHRT_MAX - 16,
 162                 "Writer will crash soon. I apologize for the inconvenience." );
 163
 164     pUndos->Insert( pUndo, nUndoPos );
 165     ++nUndoPos;
 166     switch( pUndo->GetId() )
 167     {
 168     case UNDO_START:            ++nUndoSttEnd;
 169                             break;
 170
 171     case UNDO_END:                  ASSERT( nUndoSttEnd, "Undo-Ende ohne Start" );
 172                             --nUndoSttEnd;
 173                             // kein break !!!
 174     default:
 175         if( pUndos->Count() != nUndoPos && UNDO_END != pUndo->GetId() )
 176             ClearRedo();
 177         else {
 178             ASSERT( pUndos->Count() == nUndoPos || UNDO_END == pUndo->GetId(),
 179                     "Redo history not deleted!" );
 180         }
 181         if( !nUndoSttEnd )
 182             ++nUndoCnt;
 183         break;
 184     }
 185
 186 #ifdef _SHOW_UNDORANGE
 187     // zur Anzeige der aktuellen Undo-Groessen
 188     if( !pUndoMsgWin )
 189             pUndoMsgWin = new UndoArrStatus;
 190     pUndoMsgWin->Set( pUndos->Count(), aUndoNodes.Count() );
 191 #endif
 192
 193     // noch eine offene Klammerung, kann man sich den Rest schenken
 194     if( nUndoSttEnd )
 195         return;
 196
 197     // folgende Array-Grenzen muessen ueberwacht werden:
 198     //  - Undo,                         Grenze: fester Wert oder USHRT_MAX - 1000
 199     //  - UndoNodes,            Grenze:  USHRT_MAX - 1000
 200     //  - AttrHistory       Grenze:  USHRT_MAX - 1000
 201     // (defined in UNDO_ACTION_LIMIT at the top of this file)
 202
 203     USHORT nEnde = UNDO_ACTION_LIMIT;
 204
 205 // nur zum Testen der neuen DOC-Member
 206 #ifndef PRODUCT
 207 {
 208     SwUndoId nId = UNDO_EMPTY;
 209     USHORT nUndosCnt = 0, nSttEndCnt = 0;
 210     for( USHORT nCnt = 0; nCnt < nUndoPos; ++nCnt )
 211     {
 212         if( UNDO_START == ( nId = (*pUndos)[ nCnt ]->GetId()) )
 213             ++nSttEndCnt;
 214         else if( UNDO_END == nId )
 215             --nSttEndCnt;
 216         if( !nSttEndCnt )
 217             ++nUndosCnt;
 218     }
 219     ASSERT( nSttEndCnt == nUndoSttEnd, "Start-Ende Count ungleich" );
 220     ASSERT( nUndosCnt == nUndoCnt, "Undo Count ungleich" );
 221 }
 222 #endif
 223
 224     if( SwDoc::nUndoActions < nUndoCnt )
 225         // immer 1/10 loeschen
 226         //JP 23.09.95: oder wenn neu eingestellt wurde um die Differenz
 227         //JP 29.5.2001: Task #83891#: remove only the overlapping actions
 228         DelUndoObj( nUndoCnt - SwDoc::nUndoActions );
 229     else
 230     {
 231         USHORT nUndosCnt = nUndoCnt;
 232             // immer 1/10 loeschen bis der "Ausloeser" behoben ist
 233         while( aUndoNodes.Count() && nEnde < aUndoNodes.Count() )
 234             DelUndoObj( nUndosCnt / 10 );
 235     }
 236 }
 237
 238
 239
 240 void SwDoc::ClearRedo()
 241 {
 242     if( DoesUndo() && nUndoPos != pUndos->Count() )
 243     {
 244 //?? why ??             if( !nUndoSttEnd )
 245         {
 246             // setze UndoCnt auf den neuen Wert
 247             SwUndo* pUndo;
 248             for( USHORT nCnt = pUndos->Count(); nUndoPos < nCnt; --nUndoCnt )
 249                 // Klammerung ueberspringen
 250                 if( UNDO_END == (pUndo = (*pUndos)[ --nCnt ])->GetId() )
 251                     nCnt = nCnt - ((SwUndoEnd*)pUndo)->GetSttOffset();
 252         }
 253
 254         // loesche die Undo-Aktionen (immer von hinten !)
 255         pUndos->DeleteAndDestroy( nUndoPos, pUndos->Count() - nUndoPos );
 256     }
 257 }
 258
 259
 260     // loescht die gesamten UndoObjecte
 261 void SwDoc::DelAllUndoObj()
 262 {
 263     ClearRedo();
 264
 265     DoUndo( FALSE );
 266
 267     // Offene Undo-Klammerungen erhalten !!
 268     SwUndo* pUndo;
 269     USHORT nSize = pUndos->Count();
 270     while( nSize )
 271         if( UNDO_START != ( pUndo = (*pUndos)[ --nSize ] )->GetId() ||
 272             ((SwUndoStart*)pUndo)->GetEndOffset() )
 273             // keine offenen Gruppierung ?
 274             pUndos->DeleteAndDestroy( nSize, 1 );
 275
 276     nUndoCnt = 0;
 277     nUndoPos = pUndos->Count();
 278
 279 /*
 280     while( nUndoPos )
 281         aUndos.DelDtor( --nUndoPos, 1 );
 282     nUndoCnt = nUndoSttEnd = nUndoPos = 0;
 283 */
 284     nUndoSavePos = USHRT_MAX;
 285     DoUndo( TRUE );
 286 }
 287
 288
 289     // loescht alle UndoObjecte vom Anfang bis zum angegebenen Ende
 290 BOOL SwDoc::DelUndoObj( USHORT nEnde )
 291 {
 292     if( !nEnde )                                        // sollte mal 0 uebergeben werden,
 293     {
 294         if( !pUndos->Count() )
 295             return FALSE;
 296         ++nEnde;                        // dann korrigiere es auf 1
 297     }
 298
 299     DoUndo( FALSE );
 300
 301     // pruefe erstmal, wo das Ende steht
 302     SwUndoId nId = UNDO_EMPTY;
 303     USHORT nSttEndCnt = 0;
 304     USHORT nCnt;
 305
 306     for( nCnt = 0; nEnde && nCnt < nUndoPos; ++nCnt )
 307     {
 308         if( UNDO_START == ( nId = (*pUndos)[ nCnt ]->GetId() ))
 309             ++nSttEndCnt;
 310         else if( UNDO_END == nId )
 311             --nSttEndCnt;
 312         if( !nSttEndCnt )
 313             --nEnde, --nUndoCnt;
 314     }
 315
 316     ASSERT( nCnt < nUndoPos || nUndoPos == pUndos->Count(),
 317             "Undo-Del-Ende liegt in einer Redo-Aktion" );
 318
 319     // dann setze ab Ende bis Undo-Ende bei allen Undo-Objecte die Werte um
 320     nSttEndCnt = nCnt;                  // Position merken
 321     if( nUndoSavePos < nSttEndCnt )             // SavePos wird aufgegeben
 322         nUndoSavePos = USHRT_MAX;
 323     else if( nUndoSavePos != USHRT_MAX )
 324         nUndoSavePos = nUndoSavePos - nSttEndCnt;
 325
 326     while( nSttEndCnt )
 327         pUndos->DeleteAndDestroy( --nSttEndCnt, 1 );
 328     nUndoPos = pUndos->Count();
 329
 330     DoUndo( TRUE );
 331     return TRUE;
 332 }
 333
 334 /**************** UNDO ******************/
 335
 336 void SwDoc::setUndoNoModifiedPosition( SwUndoNoModifiedPosition nNew )
 337 {
 338     nUndoSavePos = nNew;
 339     if( !pUndos->Count() || nUndoSavePos > pUndos->Count() - 1 )
 340         nUndoSavePos = USHRT_MAX;
 341 }
 342
 343 SwUndoNoModifiedPosition SwDoc::getUndoNoModifiedPosition() const
 344 {
 345     return nUndoSavePos;
 346 }
 347
 348
 349 bool SwDoc::HasUndoId(SwUndoId eId) const
 350 {
 351     USHORT nSize = nUndoPos;
 352     SwUndo * pUndo;
 353     while( nSize-- )
 354         if( ( pUndo = (*pUndos)[nSize])->GetId() == eId ||
 355             ( UNDO_START == pUndo->GetId() &&
 356                 ((SwUndoStart*)pUndo)->GetUserId() == eId )
 357             || ( UNDO_END == pUndo->GetId() &&
 358                 ((SwUndoEnd*)pUndo)->GetUserId() == eId ) )
 359         {
 360             return TRUE;
 361         }
 362
 363     return FALSE;
 364 }
 365
 366
 367 bool SwDoc::Undo( SwUndoIter& rUndoIter )
 368 {
 369     if ( (rUndoIter.GetId()!=0) && (!HasUndoId(rUndoIter.GetId())) )
 370     {
 371         rUndoIter.bWeiter = FALSE;
 372         return FALSE;
 373     }
 374     if( !nUndoPos )
 375     {
 376         rUndoIter.bWeiter = FALSE;
 377         return FALSE;
 378     }
 379
 380     SwUndo *pUndo = (*pUndos)[ --nUndoPos ];
 381
 382     RedlineMode_t eOld = GetRedlineMode();
 383     RedlineMode_t eTmpMode = (RedlineMode_t)pUndo->GetRedlineMode();
 384     if( (nsRedlineMode_t::REDLINE_SHOW_MASK & eTmpMode) != (nsRedlineMode_t::REDLINE_SHOW_MASK & eOld) &&
 385         UNDO_START != pUndo->GetId() && UNDO_END != pUndo->GetId() )
 386         SetRedlineMode( eTmpMode );
 387
 388     SetRedlineMode_intern((RedlineMode_t)(eTmpMode | nsRedlineMode_t::REDLINE_IGNORE));
 389     // Undo ausfuehren
 390
 391     // zum spaeteren ueberpruefen
 392     SwUndoId nAktId = pUndo->GetId();
 393     //JP 11.05.98: FlyFormate ueber die EditShell selektieren, nicht aus dem
 394     //                          Undo heraus
 395     switch( nAktId )
 396     {
 397     case UNDO_START:
 398     case UNDO_END:
 399     case UNDO_INSDRAWFMT:
 400         break;
 401
 402     default:
 403         rUndoIter.ClearSelections();
 404     }
 405
 406     pUndo->Undo( rUndoIter );
 407
 408     SetRedlineMode( eOld );
 409
 410     // Besonderheit von Undo-Replace (interne History)
 411     if( UNDO_REPLACE == nAktId && ((SwUndoReplace*)pUndo)->nAktPos )
 412     {
 413         ++nUndoPos;
 414         return TRUE;
 415     }
 416
 417     // Objekt aus History entfernen und zerstoeren
 418     if( nUndoPos && !rUndoIter.bWeiter &&
 419         UNDO_START == ( pUndo = (*pUndos)[ nUndoPos-1 ] )->GetId() )
 420         --nUndoPos;
 421
 422     // JP 29.10.96: Start und End setzen kein Modify-Flag.
 423     //                          Sonst gibt es Probleme mit der autom. Aufnahme von Ausnahmen
 424     //                          bei der Autokorrektur
 425     if( UNDO_START != nAktId && UNDO_END != nAktId )
 426         SetModified();          // default: immer setzen, kann zurueck gesetzt werden
 427
 428     // ist die History leer und wurde nicht wegen Speichermangel
 429     // verworfen, so kann das Dokument als unveraendert gelten
 430     if( nUndoSavePos == nUndoPos )
 431         ResetModified();
 432
 433     return TRUE;
 434 }
 435
 436
 437 // setzt Undoklammerung auf, liefert nUndoId der Klammerung
 438
 439
 440 SwUndoId SwDoc::StartUndo( SwUndoId eUndoId, const SwRewriter * pRewriter )
 441 {
 442     if( !mbUndo )
 443         return UNDO_EMPTY;
 444
 445     if( !eUndoId )
 446         eUndoId = UNDO_START;
 447
 448     SwUndoStart * pUndo = new SwUndoStart( eUndoId );
 449
 450     if (pRewriter)
 451         pUndo->SetRewriter(*pRewriter);
 452
 453     AppendUndo(pUndo);
 454
 455     return eUndoId;
 456 }
 457 // schliesst Klammerung der nUndoId, nicht vom UI benutzt
 458
 459
 460 SwUndoId SwDoc::EndUndo(SwUndoId eUndoId, const SwRewriter * pRewriter)
 461 {
 462     USHORT nSize = nUndoPos;
 463     if( !mbUndo || !nSize-- )
 464         return UNDO_EMPTY;
 465
 466     if( UNDO_START == eUndoId || !eUndoId )
 467         eUndoId = UNDO_END;
 468
 469     SwUndo* pUndo = (*pUndos)[ nSize ];
 470     if( UNDO_START == pUndo->GetId() )
 471     {
 472         // leere Start/End-Klammerung ??
 473         pUndos->DeleteAndDestroy( nSize );
 474         --nUndoPos;
 475         --nUndoSttEnd;
 476         return UNDO_EMPTY;
 477     }
 478
 479     // exist above any redo objects? If yes, delete them
 480     if( nUndoPos != pUndos->Count() )
 481     {
 482         // setze UndoCnt auf den neuen Wert
 483         for( USHORT nCnt = pUndos->Count(); nUndoPos < nCnt; --nUndoCnt )
 484             // Klammerung ueberspringen
 485             if( UNDO_END == (pUndo = (*pUndos)[ --nCnt ])->GetId() )
 486                 nCnt = nCnt - ((SwUndoEnd*)pUndo)->GetSttOffset();
 487
 488         pUndos->DeleteAndDestroy( nUndoPos, pUndos->Count() - nUndoPos );
 489     }
 490
 491     // suche den Anfang dieser Klammerung
 492     SwUndoId nId = UNDO_EMPTY;
 493     while( nSize )
 494         if( UNDO_START == ( nId = (pUndo = (*pUndos)[ --nSize ] )->GetId()) &&
 495             !((SwUndoStart*)pUndo)->GetEndOffset() )
 496             break;              // Start gefunden
 497
 498     if( nId != UNDO_START )
 499     {
 500         // kann eigentlich nur beim Abspielen von Macros passieren, die
 501         // Undo/Redo/Repeat benutzen und die eine exitierende Selection
 502         // durch Einfuegen loeschen
 503         ASSERT( !this, "kein entsprechendes Ende gefunden" );
 504         // kein entsprechenden Start gefunden -> Ende nicht einfuegen
 505         // und die Member am Doc updaten
 506
 507         nUndoSttEnd = 0;
 508         nUndoCnt = 0;
 509         // setze UndoCnt auf den neuen Wert
 510         SwUndo* pTmpUndo;
 511         for( USHORT nCnt = 0; nCnt < pUndos->Count(); ++nCnt, ++nUndoCnt )
 512             // Klammerung ueberspringen
 513             if( UNDO_START == (pTmpUndo = (*pUndos)[ nCnt ])->GetId() )
 514                 nCnt = nCnt + ((SwUndoStart*)pTmpUndo)->GetEndOffset();
 515         return UNDO_EMPTY;
 516
 517     }
 518
 519     // Klammerung um eine einzelne Action muss nicht sein!
 520     // Aussnahme: es ist eine eigene ID definiert
 521     if(  2 == pUndos->Count() - nSize &&
 522         (UNDO_END == eUndoId || eUndoId == (*pUndos)[ nSize+1 ]->GetId() ))
 523     {
 524         pUndos->DeleteAndDestroy( nSize );
 525         nUndoPos = pUndos->Count();
 526         if( !--nUndoSttEnd )
 527         {
 528             ++nUndoCnt;
 529             if( SwDoc::nUndoActions < nUndoCnt )
 530                 // immer 1/10 loeschen
 531                 //JP 23.09.95: oder wenn neu eingestellt wurde um die Differenz
 532                 //JP 29.5.2001: Task #83891#: remove only the overlapping actions
 533                 DelUndoObj( nUndoCnt - SwDoc::nUndoActions );
 534             else
 535             {
 536                 USHORT nEnde = USHRT_MAX - 1000;
 537                 USHORT nUndosCnt = nUndoCnt;
 538                     // immer 1/10 loeschen bis der "Ausloeser" behoben ist
 539                 while( aUndoNodes.Count() && nEnde < aUndoNodes.Count() )
 540                     DelUndoObj( nUndosCnt / 10 );
 541             }
 542         }
 543         return eUndoId;
 544     }
 545
 546     // setze die Klammerung am Start/End-Undo
 547     nSize = pUndos->Count() - nSize;
 548     ((SwUndoStart*)pUndo)->SetEndOffset( nSize );
 549
 550     SwUndoEnd* pUndoEnd = new SwUndoEnd( eUndoId );
 551     pUndoEnd->SetSttOffset( nSize );
 552
 553 // nur zum Testen der Start/End-Verpointerung vom Start/End Undo
 554 #ifndef PRODUCT
 555     {
 556         USHORT nEndCnt = 1, nCnt = pUndos->Count();
 557         SwUndoId nTmpId = UNDO_EMPTY;
 558         while( nCnt )
 559         {
 560             if( UNDO_START == ( nTmpId = (*pUndos)[ --nCnt ]->GetId()) )
 561             {
 562                 if( !nEndCnt ) // falls mal ein Start ohne Ende vorhanden ist
 563                     continue;
 564                 --nEndCnt;
 565                 if( !nEndCnt )          // hier ist der Anfang
 566                     break;
 567             }
 568             else if( UNDO_END == nTmpId )
 569                 ++nEndCnt;
 570             else if( !nEndCnt )
 571                 break;
 572         }
 573         ASSERT( nCnt == pUndos->Count() - nSize,
 574                 "Start-Ende falsch geklammert" );
 575     }
 576 #endif
 577
 578     if (pRewriter)
 579     {
 580         ((SwUndoStart *) pUndo)->SetRewriter(*pRewriter);
 581         pUndoEnd->SetRewriter(*pRewriter);
 582     }
 583     else
 584         pUndoEnd->SetRewriter(((SwUndoStart *) pUndo)->GetRewriter());
 585
 586     AppendUndo( pUndoEnd );
 587     return eUndoId;
 588 }
 589
 590 // liefert die Id der letzten Undofaehigen Aktion zurueck oder 0
 591 // fuellt ggf. VARARR mit User-UndoIds
 592
 593 String SwDoc::GetUndoIdsStr( String* pStr, SwUndoIds *pUndoIds) const
 594 {
 595     String aTmpStr;
 596
 597     if (pStr != NULL)
 598     {
 599         GetUndoIds( pStr, pUndoIds);
 600         aTmpStr = *pStr;
 601     }
 602     else
 603         GetUndoIds( &aTmpStr, pUndoIds);
 604
 605     return aTmpStr;
 606 }
 607
 608 /*-- 24.11.2004 16:11:21---------------------------------------------------
 609
 610   -----------------------------------------------------------------------*/
 611 sal_Bool SwDoc::RestoreInvisibleContent()
 612 {
 613     sal_Bool bRet = sal_False;
 614     if(nUndoPos > 0 )
 615     {
 616         SwUndo * pUndo = (*pUndos)[ nUndoPos - 1 ];
 617         if( ( pUndo->GetId() == UNDO_END &&
 618             static_cast<SwUndoEnd *>(pUndo)->GetUserId() == UNDO_UI_DELETE_INVISIBLECNTNT) )
 619         {
 620             SwPaM aPam( GetNodes().GetEndOfPostIts() );
 621             SwUndoIter aUndoIter( &aPam );
 622             do
 623             {
 624                 Undo( aUndoIter );
 625             }
 626             while ( aUndoIter.IsNextUndo() );
 627             ClearRedo();
 628             bRet = sal_True;
 629         }
 630     }
 631     return bRet;
 632 }
 633
 634
 635 /**
 636    Returns id and comment for a certain undo object in an undo stack.
 637
 638    Remark: In the following the object type referred to is always the
 639    effective object type. If an UNDO_START or UNDO_END has a user type
 640    it is referred to as this type.
 641
 642    If the queried object is an UNDO_END and has no user id the result
 643    is taken from the first object that is not an UNDO_END nor an
 644    UNDO_START preceeding the queried object.
 645
 646    If the queried object is an UNDO_START and has no user id the
 647    result is taken from the first object that is not an UNDO_END nor
 648    an UNDO_START preceeding the UNDO_END object belonging to the
 649    queried object.
 650
 651    In all other cases the result is taken from the queried object.
 652
 653    @param rUndos           the undo stack
 654    @param nPos             position of the undo object to query
 655
 656    @return SwUndoIdAndName object containing the query result
 657  */
 658 SwUndoIdAndName * lcl_GetUndoIdAndName(const SwUndos & rUndos, sal_uInt16 nPos )
 659 {
 660     SwUndo * pUndo = rUndos[ nPos ];
 661     SwUndoId nId = UNDO_EMPTY;
 662     String sStr("??", RTL_TEXTENCODING_ASCII_US);
 663
 664     ASSERT( nPos < rUndos.Count(), "nPos out of range");
 665
 666     switch (pUndo->GetId())
 667     {
 668     case UNDO_START:
 669         {
 670             SwUndoStart * pUndoStart = (SwUndoStart *) pUndo;
 671             nId = pUndoStart->GetUserId();
 672
 673             if (nId <= UNDO_END)
 674             {
 675                 /**
 676                    Start at the according UNDO_END.  Search backwards
 677                    for first objects that is not a UNDO_END.
 678                  */
 679                 int nTmpPos = nPos + pUndoStart->GetEndOffset();
 680                 int nSubstitute = -1;
 681
 682                 SwUndo * pTmpUndo;
 683                 do
 684                 {
 685                     nTmpPos--;
 686                     pTmpUndo = rUndos[ static_cast<USHORT>(nTmpPos) ];
 687
 688                     if (pTmpUndo->GetEffectiveId() > UNDO_END)
 689                         nSubstitute = nTmpPos;
 690                 }
 691                 while (nSubstitute < 0 && nTmpPos > nPos);
 692
 693                 if (nSubstitute >= 0)
 694                 {
 695                     SwUndo * pSubUndo = rUndos[ static_cast<USHORT>(nSubstitute) ];
 696                     nId = pSubUndo->GetEffectiveId();
 697                     sStr = pSubUndo->GetComment();
 698                 }
 699             }
 700             else
 701                 sStr = pUndo->GetComment();
 702         }
 703
 704         break;
 705
 706     case UNDO_END:
 707         {
 708             SwUndoEnd * pUndoEnd = (SwUndoEnd *) pUndo;
 709             nId = pUndoEnd->GetUserId();
 710
 711             if (nId <= UNDO_END)
 712             {
 713                 /**
 714                    Start at this UNDO_END.  Search backwards
 715                    for first objects that is not a UNDO_END.
 716                  */
 717
 718                 int nTmpPos = nPos;
 719                 int nUndoStart = nTmpPos - pUndoEnd->GetSttOffset();
 720                 int nSubstitute = -1;
 721
 722                 if (nTmpPos > 0)
 723                 {
 724                     SwUndo * pTmpUndo;
 725
 726                     do
 727                     {
 728                         nTmpPos--;
 729                         pTmpUndo = rUndos[ static_cast<USHORT>(nTmpPos) ];
 730
 731                         if (pTmpUndo->GetEffectiveId() > UNDO_END)
 732                             nSubstitute = nTmpPos;
 733                     }
 734                     while (nSubstitute < 0 && nTmpPos > nUndoStart);
 735
 736                     if (nSubstitute >= 0)
 737                     {
 738                         SwUndo * pSubUndo = rUndos[ static_cast<USHORT>(nSubstitute) ];
 739                         nId = pSubUndo->GetEffectiveId();
 740                         sStr = pSubUndo->GetComment();
 741                     }
 742                 }
 743             }
 744             else
 745                 sStr = pUndo->GetComment();
 746         }
 747
 748         break;
 749
 750     default:
 751         nId = pUndo->GetId();
 752         sStr = pUndo->GetComment();
 753     }
 754
 755     return new SwUndoIdAndName(nId, &sStr);
 756 }
 757
 758 SwUndoId SwDoc::GetUndoIds( String* pStr, SwUndoIds *pUndoIds) const
 759 {
 760     int nTmpPos = nUndoPos - 1;
 761     SwUndoId nId = UNDO_EMPTY;
 762
 763     while (nTmpPos >= 0)
 764     {
 765         SwUndo * pUndo = (*pUndos)[ static_cast<USHORT>(nTmpPos) ];
 766
 767         SwUndoIdAndName * pIdAndName = lcl_GetUndoIdAndName( *pUndos, static_cast<sal_uInt16>(nTmpPos) );
 768
 769         if (nTmpPos == nUndoPos - 1)
 770         {
 771             nId = pIdAndName->GetUndoId();
 772
 773             if (pStr)
 774                 *pStr = *pIdAndName->GetUndoStr();
 775         }
 776
 777         if (pUndoIds)
 778             pUndoIds->Insert(pIdAndName, pUndoIds->Count());
 779         else
 780             break;
 781
 782         if (pUndo->GetId() == UNDO_END)
 783             nTmpPos -= ((SwUndoEnd *) pUndo)->GetSttOffset();
 784
 785         nTmpPos--;
 786     }
 787
 788     return nId;
 789 }
 790
 791 bool SwDoc::HasTooManyUndos() const
 792 {
 793     // AppendUndo checks the UNDO_ACTION_LIMIT, unless there's a nested undo.
 794     // So HasTooManyUndos() may only occur when undos are nested; else
 795     // AppendUndo has some sort of bug.
 796     DBG_ASSERT( (nUndoSttEnd != 0) || (pUndos->Count() < UNDO_ACTION_LIMIT),
 797                 "non-nested undos should have been handled in AppendUndo" );
 798     return (pUndos->Count() >= UNDO_ACTION_LIMIT);
 799 }
 800
 801
 802 /**************** REDO ******************/
 803
 804
 805 bool SwDoc::Redo( SwUndoIter& rUndoIter )
 806 {
 807     if( rUndoIter.GetId() && !HasUndoId( rUndoIter.GetId() ) )
 808     {
 809         rUndoIter.bWeiter = FALSE;
 810         return FALSE;
 811     }
 812     if( nUndoPos == pUndos->Count() )
 813     {
 814         rUndoIter.bWeiter = FALSE;
 815         return FALSE;
 816     }
 817
 818     SwUndo *pUndo = (*pUndos)[ nUndoPos++ ];
 819
 820     RedlineMode_t eOld = GetRedlineMode();
 821     RedlineMode_t eTmpMode = (RedlineMode_t)pUndo->GetRedlineMode();
 822     if( (nsRedlineMode_t::REDLINE_SHOW_MASK & eTmpMode) != (nsRedlineMode_t::REDLINE_SHOW_MASK & eOld) &&
 823         UNDO_START != pUndo->GetId() && UNDO_END != pUndo->GetId() )
 824         SetRedlineMode( eTmpMode );
 825     SetRedlineMode_intern( (RedlineMode_t)(eTmpMode | nsRedlineMode_t::REDLINE_IGNORE));
 826
 827     //JP 11.05.98: FlyFormate ueber die EditShell selektieren, nicht aus dem
 828     //                          Undo heraus
 829     if( UNDO_START != pUndo->GetId() && UNDO_END != pUndo->GetId() )
 830         rUndoIter.ClearSelections();
 831
 832     pUndo->Redo( rUndoIter );
 833
 834     SetRedlineMode( eOld );
 835
 836     // Besonderheit von Undo-Replace (interne History)
 837     if( UNDO_REPLACE == pUndo->GetId() &&
 838         USHRT_MAX != ((SwUndoReplace*)pUndo)->nAktPos )
 839     {
 840         --nUndoPos;
 841         return TRUE;
 842     }
 843
 844     if( rUndoIter.bWeiter && nUndoPos >= pUndos->Count() )
 845         rUndoIter.bWeiter = FALSE;
 846
 847     // ist die History leer und wurde nicht wegen Speichermangel
 848     // verworfen, so kann das Dokument als unveraendert gelten
 849     if( nUndoSavePos == nUndoPos )
 850         ResetModified();
 851     else
 852         SetModified();
 853     return TRUE;
 854 }
 855
 856
 857 // liefert die Id der letzten Redofaehigen Aktion zurueck oder 0
 858 // fuellt ggf. VARARR mit User-RedoIds
 859
 860 String SwDoc::GetRedoIdsStr( String* pStr, SwUndoIds *pRedoIds ) const
 861 {
 862     String aTmpStr;
 863
 864     if (pStr != NULL)
 865     {
 866         GetRedoIds( pStr, pRedoIds );
 867         aTmpStr = *pStr;
 868     }
 869     else
 870         GetRedoIds( &aTmpStr, pRedoIds );
 871
 872
 873     return aTmpStr;
 874 }
 875
 876
 877 SwUndoId SwDoc::GetRedoIds( String* pStr, SwUndoIds *pRedoIds ) const
 878 {
 879     sal_uInt16 nTmpPos = nUndoPos;
 880     SwUndoId nId = UNDO_EMPTY;
 881
 882     while (nTmpPos < pUndos->Count())
 883     {
 884         SwUndo * pUndo = (*pUndos)[nTmpPos];
 885
 886         SwUndoIdAndName * pIdAndName = lcl_GetUndoIdAndName(*pUndos, nTmpPos);
 887
 888         if (nTmpPos == nUndoPos)
 889         {
 890             nId = pIdAndName->GetUndoId();
 891
 892             if (pStr)
 893                 *pStr = *pIdAndName->GetUndoStr();
 894         }
 895
 896         if (pRedoIds)
 897             pRedoIds->Insert(pIdAndName, pRedoIds->Count());
 898         else
 899             break;
 900
 901         if (pUndo->GetId() == UNDO_START)
 902             nTmpPos = nTmpPos + ((SwUndoStart *) pUndo)->GetEndOffset();
 903
 904         nTmpPos++;
 905     }
 906
 907     return nId;
 908 }
 909
 910 /**************** REPEAT ******************/
 911
 912
 913 bool SwDoc::Repeat( SwUndoIter& rUndoIter, sal_uInt16 nRepeatCnt )
 914 {
 915     if( rUndoIter.GetId() && !HasUndoId( rUndoIter.GetId() ) )
 916     {
 917         rUndoIter.bWeiter = FALSE;
 918         return FALSE;
 919     }
 920     USHORT nSize = nUndoPos;
 921     if( !nSize )
 922     {
 923         rUndoIter.bWeiter = FALSE;
 924         return FALSE;
 925     }
 926
 927     // dann suche jetzt ueber die End/Start-Gruppen die gueltige Repeat-Aktion
 928     SwUndo *pUndo = (*pUndos)[ --nSize ];
 929     if( UNDO_END == pUndo->GetId() )
 930         nSize = nSize - ((SwUndoEnd*)pUndo)->GetSttOffset();
 931
 932     USHORT nEndCnt = nUndoPos;
 933     BOOL bOneUndo = nSize + 1 == nUndoPos;
 934
 935     SwPaM* pTmpCrsr = rUndoIter.pAktPam;
 936     SwUndoId nId = UNDO_EMPTY;
 937
 938     if( pTmpCrsr != pTmpCrsr->GetNext() || !bOneUndo )  // Undo-Klammerung aufbauen
 939     {
 940         if (pUndo->GetId() == UNDO_END)
 941         {
 942             SwUndoStart * pStartUndo =
 943                 (SwUndoStart *) (*pUndos)[nSize];
 944
 945             nId = pStartUndo->GetUserId();
 946         }
 947
 948         StartUndo( nId, NULL );
 949     }
 950     do {                // dann durchlaufe mal den gesamten Ring
 951         for( USHORT nRptCnt = nRepeatCnt; nRptCnt > 0; --nRptCnt )
 952         {
 953             rUndoIter.pLastUndoObj = 0;
 954             for( USHORT nCnt = nSize; nCnt < nEndCnt; ++nCnt )
 955                 (*pUndos)[ nCnt ]->Repeat( rUndoIter );         // Repeat ausfuehren
 956         }
 957     } while( pTmpCrsr !=
 958         ( rUndoIter.pAktPam = (SwPaM*)rUndoIter.pAktPam->GetNext() ));
 959     if( pTmpCrsr != pTmpCrsr->GetNext() || !bOneUndo )
 960         EndUndo( nId, NULL );
 961
 962     return TRUE;
 963 }
 964
 965 // liefert die Id der letzten Repeatfaehigen Aktion zurueck oder 0
 966 // fuellt ggf. VARARR mit User-RedoIds
 967
 968 String SwDoc::GetRepeatIdsStr(String* pStr, SwUndoIds *pRepeatIds) const
 969 {
 970     String aTmpStr;
 971     SwUndoId nId;
 972
 973     if ( pStr != NULL)
 974     {
 975         nId = GetRepeatIds(pStr, pRepeatIds);
 976         aTmpStr = *pStr;
 977     }
 978     else
 979         nId = GetRepeatIds(&aTmpStr, pRepeatIds);
 980
 981     if (nId <= UNDO_END)
 982         return String();
 983
 984     return aTmpStr;
 985 }
 986
 987 SwUndoId SwDoc::GetRepeatIds(String* pStr, SwUndoIds *pRepeatIds) const
 988 {
 989     SwUndoId nRepeatId = GetUndoIds( pStr, pRepeatIds );
 990     if( REPEAT_START <= nRepeatId && REPEAT_END > nRepeatId )
 991         return nRepeatId;
 992     return UNDO_EMPTY;
 993 }
 994
 995
 996 SwUndo* SwDoc::RemoveLastUndo( SwUndoId eUndoId )
 997 {
 998     SwUndo* pUndo = (*pUndos)[ nUndoPos - 1 ];
 999     if( eUndoId == pUndo->GetId() && nUndoPos == pUndos->Count() )
1000     {
1001         if( !nUndoSttEnd )
1002             --nUndoCnt;
1003         --nUndoPos;
1004         pUndos->Remove( nUndoPos, 1 );
1005     }
1006     else
1007     {
1008         pUndo = 0;
1009         ASSERT( !this, "falsches Undo-Object" );
1010     }
1011     return pUndo;
1012 }
1013
1014 SwUndoIdAndName::SwUndoIdAndName( SwUndoId nId, const String* pStr )
1015     : eUndoId( nId ), pUndoStr( pStr ? new String( *pStr ) : 0 )
1016 {
1017 }
1018
1019 SwUndoIdAndName::~SwUndoIdAndName()
1020 {
1021     delete pUndoStr;
1022 }
1023
1024
1025