sc/source/ui/undo/undobase.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <vcl/virdev.hxx>
  21
  22 #include "undobase.hxx"
  23 #include "refundo.hxx"
  24 #include "docsh.hxx"
  25 #include "tabvwsh.hxx"
  26 #include "undoolk.hxx"
  27 #include "undodraw.hxx"
  28 #include "dbdata.hxx"
  29 #include "attrib.hxx"
  30 #include "queryparam.hxx"
  31 #include "subtotalparam.hxx"
  32 #include "globstr.hrc"
  33
  34 // STATIC DATA -----------------------------------------------------------
  35
  36 TYPEINIT1(ScSimpleUndo,     SfxUndoAction);
  37 TYPEINIT1(ScBlockUndo,      ScSimpleUndo);
  38 TYPEINIT1(ScMultiBlockUndo, ScSimpleUndo);
  39 TYPEINIT1(ScMoveUndo,       ScSimpleUndo);
  40 TYPEINIT1(ScDBFuncUndo,     ScSimpleUndo);
  41 TYPEINIT1(ScUndoWrapper,    SfxUndoAction);
  42
  43 ScSimpleUndo::ScSimpleUndo( ScDocShell* pDocSh ) :
  44     pDocShell( pDocSh ),
  45     pDetectiveUndo( NULL )
  46 {
  47 }
  48
  49 ScSimpleUndo::~ScSimpleUndo()
  50 {
  51     delete pDetectiveUndo;
  52 }
  53
  54 bool ScSimpleUndo::SetViewMarkData( const ScMarkData& rMarkData )
  55 {
  56     if ( IsPaintLocked() )
  57         return false;
  58
  59     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
  60     if ( !pViewShell )
  61         return false;
  62
  63     pViewShell->SetMarkData( rMarkData );
  64     return true;
  65 }
  66
  67 bool ScSimpleUndo::Merge( SfxUndoAction *pNextAction )
  68 {
  69     // A SdrUndoGroup for updating detective arrows can belong
  70     // to each Undo-Action.
  71     // DetectiveRefresh is always called next,
  72     // the SdrUndoGroup is encapsulated in a ScUndoDraw action.
  73     // AddUndoAction is only called with bTryMerg=sal_True
  74     // for automatic update.
  75
  76     if ( !pDetectiveUndo && pNextAction->ISA(ScUndoDraw) )
  77     {
  78         // Take SdrUndoAction from ScUndoDraw Action,
  79         // ScUndoDraw is later deleted by the UndoManager
  80
  81         ScUndoDraw* pCalcUndo = (ScUndoDraw*)pNextAction;
  82         pDetectiveUndo = pCalcUndo->GetDrawUndo();
  83         pCalcUndo->ForgetDrawUndo();
  84         return sal_True;
  85     }
  86
  87     return false;
  88 }
  89
  90 void ScSimpleUndo::BeginUndo()
  91 {
  92     pDocShell->SetInUndo( sal_True );
  93
  94     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
  95     if (pViewShell)
  96         pViewShell->HideAllCursors();       // for example due to merged cells
  97
  98     //  detective updates happened last, must be undone first
  99     if (pDetectiveUndo)
 100         pDetectiveUndo->Undo();
 101 }
 102
 103 void ScSimpleUndo::EndUndo()
 104 {
 105     pDocShell->SetDocumentModified();
 106
 107     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 108     if (pViewShell)
 109     {
 110         pViewShell->UpdateAutoFillMark();
 111         pViewShell->UpdateInputHandler();
 112         pViewShell->ShowAllCursors();
 113     }
 114
 115     pDocShell->SetInUndo( false );
 116 }
 117
 118 void ScSimpleUndo::BeginRedo()
 119 {
 120     pDocShell->SetInUndo( sal_True );   //! own Flag for Redo?
 121
 122     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 123     if (pViewShell)
 124         pViewShell->HideAllCursors();       // for example due to merged cells
 125 }
 126
 127 void ScSimpleUndo::EndRedo()
 128 {
 129     if (pDetectiveUndo)
 130         pDetectiveUndo->Redo();
 131
 132     pDocShell->SetDocumentModified();
 133
 134     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 135     if (pViewShell)
 136     {
 137         pViewShell->UpdateAutoFillMark();
 138         pViewShell->UpdateInputHandler();
 139         pViewShell->ShowAllCursors();
 140     }
 141
 142     pDocShell->SetInUndo( false );
 143 }
 144
 145 void ScSimpleUndo::BroadcastChanges( const ScRange& rRange )
 146 {
 147     ScDocument* pDoc = pDocShell->GetDocument();
 148     pDoc->CellContentModified();
 149
 150     ScHint aHint(SC_HINT_DATACHANGED, ScAddress());
 151     ScAddress& rPos = aHint.GetAddress();
 152     for (SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); ++nTab)
 153     {
 154         rPos.SetTab(nTab);
 155         for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
 156         {
 157             rPos.SetCol(nCol);
 158             for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)
 159             {
 160                 rPos.SetRow(nRow);
 161                 pDoc->Broadcast(aHint);
 162             }
 163         }
 164     }
 165
 166     pDoc->BroadcastUno(SfxSimpleHint(SC_HINT_DATACHANGED));
 167 }
 168
 169 void ScSimpleUndo::ShowTable( SCTAB nTab )
 170 {
 171     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 172     if (pViewShell)
 173         pViewShell->SetTabNo( nTab );
 174 }
 175
 176 void ScSimpleUndo::ShowTable( const ScRange& rRange )
 177 {
 178     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 179     if (pViewShell)
 180     {
 181         SCTAB nStart = rRange.aStart.Tab();
 182         SCTAB nEnd   = rRange.aEnd.Tab();
 183         SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 184         if ( nTab < nStart || nTab > nEnd )                     // if not in range:
 185             pViewShell->SetTabNo( nStart );                     // at beginning of the range
 186     }
 187 }
 188
 189 ScBlockUndo::ScBlockUndo( ScDocShell* pDocSh, const ScRange& rRange,
 190                                             ScBlockUndoMode eBlockMode ) :
 191     ScSimpleUndo( pDocSh ),
 192     aBlockRange( rRange ),
 193     eMode( eBlockMode )
 194 {
 195     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 196 }
 197
 198 ScBlockUndo::~ScBlockUndo()
 199 {
 200     DeleteSdrUndoAction( pDrawUndo );
 201 }
 202
 203 void ScBlockUndo::BeginUndo()
 204 {
 205     ScSimpleUndo::BeginUndo();
 206     EnableDrawAdjust( pDocShell->GetDocument(), false );
 207 }
 208
 209 void ScBlockUndo::EndUndo()
 210 {
 211     if (eMode == SC_UNDO_AUTOHEIGHT)
 212         AdjustHeight();
 213
 214     EnableDrawAdjust( pDocShell->GetDocument(), sal_True );
 215     DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );
 216
 217     ShowBlock();
 218     ScSimpleUndo::EndUndo();
 219 }
 220
 221 void ScBlockUndo::EndRedo()
 222 {
 223     if (eMode == SC_UNDO_AUTOHEIGHT)
 224         AdjustHeight();
 225
 226     ShowBlock();
 227     ScSimpleUndo::EndRedo();
 228 }
 229
 230 sal_Bool ScBlockUndo::AdjustHeight()
 231 {
 232     ScDocument* pDoc = pDocShell->GetDocument();
 233
 234     VirtualDevice aVirtDev;
 235     Fraction aZoomX( 1, 1 );
 236     Fraction aZoomY = aZoomX;
 237     double nPPTX, nPPTY;
 238     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 239     if (pViewShell)
 240     {
 241         ScViewData* pData = pViewShell->GetViewData();
 242         nPPTX = pData->GetPPTX();
 243         nPPTY = pData->GetPPTY();
 244         aZoomX = pData->GetZoomX();
 245         aZoomY = pData->GetZoomY();
 246     }
 247     else
 248     {
 249         // Leave zoom at 100
 250         nPPTX = ScGlobal::nScreenPPTX;
 251         nPPTY = ScGlobal::nScreenPPTY;
 252     }
 253
 254     sal_Bool bRet = pDoc->SetOptimalHeight( aBlockRange.aStart.Row(), aBlockRange.aEnd.Row(),
 255 /*!*/                                   aBlockRange.aStart.Tab(), 0, &aVirtDev,
 256                                         nPPTX, nPPTY, aZoomX, aZoomY, false );
 257
 258     if (bRet)
 259         pDocShell->PostPaint( 0,      aBlockRange.aStart.Row(), aBlockRange.aStart.Tab(),
 260                               MAXCOL, MAXROW,                   aBlockRange.aEnd.Tab(),
 261                               PAINT_GRID | PAINT_LEFT );
 262
 263     return bRet;
 264 }
 265
 266 void ScBlockUndo::ShowBlock()
 267 {
 268     if ( IsPaintLocked() )
 269         return;
 270
 271     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 272     if (pViewShell)
 273     {
 274         ShowTable( aBlockRange );       // with multiple sheets in range each of them is good
 275         pViewShell->MoveCursorAbs( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
 276                                    SC_FOLLOW_JUMP, false, false );
 277         SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 278         ScRange aRange = aBlockRange;
 279         aRange.aStart.SetTab( nTab );
 280         aRange.aEnd.SetTab( nTab );
 281         pViewShell->MarkRange( aRange );
 282
 283         // not through SetMarkArea to MarkData, due to possibly lacking paint
 284     }
 285 }
 286
 287 ScMultiBlockUndo::ScMultiBlockUndo(
 288     ScDocShell* pDocSh, const ScRangeList& rRanges, ScBlockUndoMode eBlockMode) :
 289     ScSimpleUndo(pDocSh),
 290     maBlockRanges(rRanges),
 291     meMode(eBlockMode)
 292 {
 293     mpDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 294 }
 295
 296 ScMultiBlockUndo::~ScMultiBlockUndo()
 297 {
 298     DeleteSdrUndoAction( mpDrawUndo );
 299 }
 300
 301 void ScMultiBlockUndo::BeginUndo()
 302 {
 303     ScSimpleUndo::BeginUndo();
 304     EnableDrawAdjust(pDocShell->GetDocument(), false);
 305 }
 306
 307 void ScMultiBlockUndo::EndUndo()
 308 {
 309     if (meMode == SC_UNDO_AUTOHEIGHT)
 310         AdjustHeight();
 311
 312     EnableDrawAdjust(pDocShell->GetDocument(), true);
 313     DoSdrUndoAction(mpDrawUndo, pDocShell->GetDocument());
 314
 315     ShowBlock();
 316     ScSimpleUndo::EndUndo();
 317 }
 318
 319 void ScMultiBlockUndo::EndRedo()
 320 {
 321     if (meMode == SC_UNDO_AUTOHEIGHT)
 322         AdjustHeight();
 323
 324     ShowBlock();
 325     ScSimpleUndo::EndRedo();
 326 }
 327
 328 void ScMultiBlockUndo::AdjustHeight()
 329 {
 330     ScDocument* pDoc = pDocShell->GetDocument();
 331
 332     VirtualDevice aVirtDev;
 333     Fraction aZoomX( 1, 1 );
 334     Fraction aZoomY = aZoomX;
 335     double nPPTX, nPPTY;
 336     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 337     if (pViewShell)
 338     {
 339         ScViewData* pData = pViewShell->GetViewData();
 340         nPPTX = pData->GetPPTX();
 341         nPPTY = pData->GetPPTY();
 342         aZoomX = pData->GetZoomX();
 343         aZoomY = pData->GetZoomY();
 344     }
 345     else
 346     {
 347         // Leave zoom at 100
 348         nPPTX = ScGlobal::nScreenPPTX;
 349         nPPTY = ScGlobal::nScreenPPTY;
 350     }
 351
 352     for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 353     {
 354         const ScRange& r = *maBlockRanges[i];
 355         bool bRet = pDoc->SetOptimalHeight(
 356             r.aStart.Row(), r.aEnd.Row(), r.aStart.Tab(), 0, &aVirtDev,
 357             nPPTX, nPPTY, aZoomX, aZoomY, false);
 358
 359         if (bRet)
 360             pDocShell->PostPaint(
 361                 0, r.aStart.Row(), r.aStart.Tab(), MAXCOL, MAXROW, r.aEnd.Tab(),
 362                 PAINT_GRID | PAINT_LEFT);
 363     }
 364 }
 365
 366 void ScMultiBlockUndo::ShowBlock()
 367 {
 368     if ( IsPaintLocked() )
 369         return;
 370
 371     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 372     if (!pViewShell)
 373         return;
 374
 375     if (maBlockRanges.empty())
 376         return;
 377
 378     // Move to the sheet of the first range.
 379     ScRange aRange = *maBlockRanges.front();
 380     ShowTable(aRange);
 381     pViewShell->MoveCursorAbs(
 382         aRange.aStart.Col(), aRange.aStart.Row(), SC_FOLLOW_JUMP, false, false);
 383     SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 384     aRange.aStart.SetTab(nTab);
 385     aRange.aEnd.SetTab(nTab);
 386     pViewShell->MarkRange(aRange, false, false);
 387
 388     for (size_t i = 1, n = maBlockRanges.size(); i < n; ++i)
 389     {
 390         aRange = *maBlockRanges[i];
 391         aRange.aStart.SetTab(nTab);
 392         aRange.aEnd.SetTab(nTab);
 393         pViewShell->MarkRange(aRange, false, true);
 394     }
 395 }
 396
 397 ScMoveUndo::ScMoveUndo( ScDocShell* pDocSh, ScDocument* pRefDoc, ScRefUndoData* pRefData,
 398                                                 ScMoveUndoMode eRefMode ) :
 399     ScSimpleUndo( pDocSh ),
 400     pRefUndoDoc( pRefDoc ),
 401     pRefUndoData( pRefData ),
 402     eMode( eRefMode )
 403 {
 404     ScDocument* pDoc = pDocShell->GetDocument();
 405     if (pRefUndoData)
 406         pRefUndoData->DeleteUnchanged(pDoc);
 407     pDrawUndo = GetSdrUndoAction( pDoc );
 408 }
 409
 410 ScMoveUndo::~ScMoveUndo()
 411 {
 412     delete pRefUndoData;
 413     delete pRefUndoDoc;
 414     DeleteSdrUndoAction( pDrawUndo );
 415 }
 416
 417 void ScMoveUndo::UndoRef()
 418 {
 419     ScDocument* pDoc = pDocShell->GetDocument();
 420     ScRange aRange(0,0,0, MAXCOL,MAXROW,pRefUndoDoc->GetTableCount()-1);
 421     pRefUndoDoc->CopyToDocument( aRange, IDF_FORMULA, false, pDoc, NULL, false );
 422     if (pRefUndoData)
 423         pRefUndoData->DoUndo( pDoc, (eMode == SC_UNDO_REFFIRST) );
 424         // HACK: ScDragDropUndo is the only one with REFFIRST.
 425         // If not, results possibly in a too frequent adjustment
 426         // of ChartRefs. Not that pretty, but not too bad either..
 427 }
 428
 429 void ScMoveUndo::BeginUndo()
 430 {
 431     ScSimpleUndo::BeginUndo();
 432
 433     EnableDrawAdjust( pDocShell->GetDocument(), false );
 434
 435     if (pRefUndoDoc && eMode == SC_UNDO_REFFIRST)
 436         UndoRef();
 437 }
 438
 439 void ScMoveUndo::EndUndo()
 440 {
 441     DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );     // must also be called when pointer is null
 442
 443     if (pRefUndoDoc && eMode == SC_UNDO_REFLAST)
 444         UndoRef();
 445
 446     EnableDrawAdjust( pDocShell->GetDocument(), sal_True );
 447
 448     ScSimpleUndo::EndUndo();
 449 }
 450
 451 ScDBFuncUndo::ScDBFuncUndo( ScDocShell* pDocSh, const ScRange& rOriginal, SdrUndoAction* pDrawUndo ) :
 452     ScSimpleUndo( pDocSh ),
 453     aOriginalRange( rOriginal ),
 454     mpDrawUndo( pDrawUndo )
 455 {
 456     pAutoDBRange = pDocSh->GetOldAutoDBRange();
 457 }
 458
 459 ScDBFuncUndo::~ScDBFuncUndo()
 460 {
 461     DeleteSdrUndoAction( mpDrawUndo );
 462     delete pAutoDBRange;
 463 }
 464
 465 void ScDBFuncUndo::SetDrawUndoAction( SdrUndoAction* pDrawUndo )
 466 {
 467     DeleteSdrUndoAction( mpDrawUndo );
 468     mpDrawUndo = pDrawUndo;
 469 }
 470
 471 void ScDBFuncUndo::BeginUndo()
 472 {
 473     ScSimpleUndo::BeginUndo();
 474     DoSdrUndoAction( mpDrawUndo, pDocShell->GetDocument() );
 475 }
 476
 477 void ScDBFuncUndo::EndUndo()
 478 {
 479     ScSimpleUndo::EndUndo();
 480
 481     if ( pAutoDBRange )
 482     {
 483         ScDocument* pDoc = pDocShell->GetDocument();
 484         SCTAB nTab = pDoc->GetVisibleTab();
 485         ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
 486         if (pNoNameData )
 487         {
 488             SCCOL nRangeX1;
 489             SCROW nRangeY1;
 490             SCCOL nRangeX2;
 491             SCROW nRangeY2;
 492             SCTAB nRangeTab;
 493             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 494             pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 495
 496             *pNoNameData = *pAutoDBRange;
 497
 498             if ( pAutoDBRange->HasAutoFilter() )
 499             {
 500                 // restore AutoFilter buttons
 501                 pAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 502                 pDoc->ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
 503                 pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
 504             }
 505         }
 506     }
 507 }
 508
 509 void ScDBFuncUndo::BeginRedo()
 510 {
 511     RedoSdrUndoAction( mpDrawUndo );
 512     if ( pAutoDBRange )
 513     {
 514         // move the database range to this function's position again (see ScDocShell::GetDBData)
 515
 516         ScDocument* pDoc = pDocShell->GetDocument();
 517         ScDBData* pNoNameData = pDoc->GetAnonymousDBData(aOriginalRange.aStart.Tab());
 518         if ( pNoNameData )
 519         {
 520
 521             SCCOL nRangeX1;
 522             SCROW nRangeY1;
 523             SCCOL nRangeX2;
 524             SCROW nRangeY2;
 525             SCTAB nRangeTab;
 526             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 527             pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 528
 529             pNoNameData->SetSortParam( ScSortParam() );
 530             pNoNameData->SetQueryParam( ScQueryParam() );
 531             pNoNameData->SetSubTotalParam( ScSubTotalParam() );
 532
 533             pNoNameData->SetArea( aOriginalRange.aStart.Tab(),
 534                                   aOriginalRange.aStart.Col(), aOriginalRange.aStart.Row(),
 535                                   aOriginalRange.aEnd.Col(), aOriginalRange.aEnd.Row() );
 536
 537             pNoNameData->SetByRow( sal_True );
 538             pNoNameData->SetAutoFilter( false );
 539             // header is always set with the operation in redo
 540         }
 541     }
 542
 543     ScSimpleUndo::BeginRedo();
 544 }
 545
 546 void ScDBFuncUndo::EndRedo()
 547 {
 548     ScSimpleUndo::EndRedo();
 549 }
 550
 551 ScUndoWrapper::ScUndoWrapper( SfxUndoAction* pUndo ) :
 552     pWrappedUndo( pUndo )
 553 {
 554 }
 555
 556 ScUndoWrapper::~ScUndoWrapper()
 557 {
 558     delete pWrappedUndo;
 559 }
 560
 561 void ScUndoWrapper::ForgetWrappedUndo()
 562 {
 563     pWrappedUndo = NULL;    // don't delete in dtor - pointer must be stored outside
 564 }
 565
 566 OUString ScUndoWrapper::GetComment() const
 567 {
 568     if (pWrappedUndo)
 569         return pWrappedUndo->GetComment();
 570     return OUString();
 571 }
 572
 573 OUString ScUndoWrapper::GetRepeatComment(SfxRepeatTarget& rTarget) const
 574 {
 575     if (pWrappedUndo)
 576         return pWrappedUndo->GetRepeatComment(rTarget);
 577     return OUString();
 578 }
 579
 580 sal_uInt16 ScUndoWrapper::GetId() const
 581 {
 582     if (pWrappedUndo)
 583         return pWrappedUndo->GetId();
 584     else
 585         return 0;
 586 }
 587
 588 void ScUndoWrapper::SetLinkToSfxLinkUndoAction(SfxLinkUndoAction* pSfxLinkUndoAction)
 589 {
 590     if (pWrappedUndo)
 591         pWrappedUndo->SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
 592     else
 593         SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
 594 }
 595
 596 bool ScUndoWrapper::Merge( SfxUndoAction* pNextAction )
 597 {
 598     if (pWrappedUndo)
 599         return pWrappedUndo->Merge(pNextAction);
 600     else
 601         return false;
 602 }
 603
 604 void ScUndoWrapper::Undo()
 605 {
 606     if (pWrappedUndo)
 607         pWrappedUndo->Undo();
 608 }
 609
 610 void ScUndoWrapper::Redo()
 611 {
 612     if (pWrappedUndo)
 613         pWrappedUndo->Redo();
 614 }
 615
 616 void ScUndoWrapper::Repeat(SfxRepeatTarget& rTarget)
 617 {
 618     if (pWrappedUndo)
 619         pWrappedUndo->Repeat(rTarget);
 620 }
 621
 622 bool ScUndoWrapper::CanRepeat(SfxRepeatTarget& rTarget) const
 623 {
 624     if (pWrappedUndo)
 625         return pWrappedUndo->CanRepeat(rTarget);
 626     else
 627         return false;
 628 }
 629
 630 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */