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 sal_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::ShowTable( SCTAB nTab )
 146 {
 147     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 148     if (pViewShell)
 149         pViewShell->SetTabNo( nTab );
 150 }
 151
 152 void ScSimpleUndo::ShowTable( const ScRange& rRange )
 153 {
 154     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 155     if (pViewShell)
 156     {
 157         SCTAB nStart = rRange.aStart.Tab();
 158         SCTAB nEnd   = rRange.aEnd.Tab();
 159         SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 160         if ( nTab < nStart || nTab > nEnd )                     // if not in range:
 161             pViewShell->SetTabNo( nStart );                     // at beginning of the range
 162     }
 163 }
 164
 165 ScBlockUndo::ScBlockUndo( ScDocShell* pDocSh, const ScRange& rRange,
 166                                             ScBlockUndoMode eBlockMode ) :
 167     ScSimpleUndo( pDocSh ),
 168     aBlockRange( rRange ),
 169     eMode( eBlockMode )
 170 {
 171     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 172 }
 173
 174 ScBlockUndo::~ScBlockUndo()
 175 {
 176     DeleteSdrUndoAction( pDrawUndo );
 177 }
 178
 179 void ScBlockUndo::BeginUndo()
 180 {
 181     ScSimpleUndo::BeginUndo();
 182     EnableDrawAdjust( pDocShell->GetDocument(), false );
 183 }
 184
 185 void ScBlockUndo::EndUndo()
 186 {
 187     if (eMode == SC_UNDO_AUTOHEIGHT)
 188         AdjustHeight();
 189
 190     EnableDrawAdjust( pDocShell->GetDocument(), sal_True );
 191     DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );
 192
 193     ShowBlock();
 194     ScSimpleUndo::EndUndo();
 195 }
 196
 197 void ScBlockUndo::EndRedo()
 198 {
 199     if (eMode == SC_UNDO_AUTOHEIGHT)
 200         AdjustHeight();
 201
 202     ShowBlock();
 203     ScSimpleUndo::EndRedo();
 204 }
 205
 206 sal_Bool ScBlockUndo::AdjustHeight()
 207 {
 208     ScDocument* pDoc = pDocShell->GetDocument();
 209
 210     VirtualDevice aVirtDev;
 211     Fraction aZoomX( 1, 1 );
 212     Fraction aZoomY = aZoomX;
 213     double nPPTX, nPPTY;
 214     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 215     if (pViewShell)
 216     {
 217         ScViewData* pData = pViewShell->GetViewData();
 218         nPPTX = pData->GetPPTX();
 219         nPPTY = pData->GetPPTY();
 220         aZoomX = pData->GetZoomX();
 221         aZoomY = pData->GetZoomY();
 222     }
 223     else
 224     {
 225         // Leave zoom at 100
 226         nPPTX = ScGlobal::nScreenPPTX;
 227         nPPTY = ScGlobal::nScreenPPTY;
 228     }
 229
 230     sal_Bool bRet = pDoc->SetOptimalHeight( aBlockRange.aStart.Row(), aBlockRange.aEnd.Row(),
 231 /*!*/                                   aBlockRange.aStart.Tab(), 0, &aVirtDev,
 232                                         nPPTX, nPPTY, aZoomX, aZoomY, false );
 233
 234     if (bRet)
 235         pDocShell->PostPaint( 0,      aBlockRange.aStart.Row(), aBlockRange.aStart.Tab(),
 236                               MAXCOL, MAXROW,                   aBlockRange.aEnd.Tab(),
 237                               PAINT_GRID | PAINT_LEFT );
 238
 239     return bRet;
 240 }
 241
 242 void ScBlockUndo::ShowBlock()
 243 {
 244     if ( IsPaintLocked() )
 245         return;
 246
 247     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 248     if (pViewShell)
 249     {
 250         ShowTable( aBlockRange );       // with multiple sheets in range each of them is good
 251         pViewShell->MoveCursorAbs( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
 252                                    SC_FOLLOW_JUMP, false, false );
 253         SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 254         ScRange aRange = aBlockRange;
 255         aRange.aStart.SetTab( nTab );
 256         aRange.aEnd.SetTab( nTab );
 257         pViewShell->MarkRange( aRange );
 258
 259         // not through SetMarkArea to MarkData, due to possibly lacking paint
 260     }
 261 }
 262
 263 ScMultiBlockUndo::ScMultiBlockUndo(
 264     ScDocShell* pDocSh, const ScRangeList& rRanges, ScBlockUndoMode eBlockMode) :
 265     ScSimpleUndo(pDocSh),
 266     maBlockRanges(rRanges),
 267     meMode(eBlockMode)
 268 {
 269     mpDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 270 }
 271
 272 ScMultiBlockUndo::~ScMultiBlockUndo()
 273 {
 274     DeleteSdrUndoAction( mpDrawUndo );
 275 }
 276
 277 void ScMultiBlockUndo::BeginUndo()
 278 {
 279     ScSimpleUndo::BeginUndo();
 280     EnableDrawAdjust(pDocShell->GetDocument(), false);
 281 }
 282
 283 void ScMultiBlockUndo::EndUndo()
 284 {
 285     if (meMode == SC_UNDO_AUTOHEIGHT)
 286         AdjustHeight();
 287
 288     EnableDrawAdjust(pDocShell->GetDocument(), true);
 289     DoSdrUndoAction(mpDrawUndo, pDocShell->GetDocument());
 290
 291     ShowBlock();
 292     ScSimpleUndo::EndUndo();
 293 }
 294
 295 void ScMultiBlockUndo::EndRedo()
 296 {
 297     if (meMode == SC_UNDO_AUTOHEIGHT)
 298         AdjustHeight();
 299
 300     ShowBlock();
 301     ScSimpleUndo::EndRedo();
 302 }
 303
 304 void ScMultiBlockUndo::AdjustHeight()
 305 {
 306     ScDocument* pDoc = pDocShell->GetDocument();
 307
 308     VirtualDevice aVirtDev;
 309     Fraction aZoomX( 1, 1 );
 310     Fraction aZoomY = aZoomX;
 311     double nPPTX, nPPTY;
 312     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 313     if (pViewShell)
 314     {
 315         ScViewData* pData = pViewShell->GetViewData();
 316         nPPTX = pData->GetPPTX();
 317         nPPTY = pData->GetPPTY();
 318         aZoomX = pData->GetZoomX();
 319         aZoomY = pData->GetZoomY();
 320     }
 321     else
 322     {
 323         // Leave zoom at 100
 324         nPPTX = ScGlobal::nScreenPPTX;
 325         nPPTY = ScGlobal::nScreenPPTY;
 326     }
 327
 328     for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 329     {
 330         const ScRange& r = *maBlockRanges[i];
 331         bool bRet = pDoc->SetOptimalHeight(
 332             r.aStart.Row(), r.aEnd.Row(), r.aStart.Tab(), 0, &aVirtDev,
 333             nPPTX, nPPTY, aZoomX, aZoomY, false);
 334
 335         if (bRet)
 336             pDocShell->PostPaint(
 337                 0, r.aStart.Row(), r.aStart.Tab(), MAXCOL, MAXROW, r.aEnd.Tab(),
 338                 PAINT_GRID | PAINT_LEFT);
 339     }
 340 }
 341
 342 void ScMultiBlockUndo::ShowBlock()
 343 {
 344     if ( IsPaintLocked() )
 345         return;
 346
 347     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 348     if (!pViewShell)
 349         return;
 350
 351     if (maBlockRanges.empty())
 352         return;
 353
 354     // Move to the sheet of the first range.
 355     ScRange aRange = *maBlockRanges.front();
 356     ShowTable(aRange);
 357     pViewShell->MoveCursorAbs(
 358         aRange.aStart.Col(), aRange.aStart.Row(), SC_FOLLOW_JUMP, false, false);
 359     SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 360     aRange.aStart.SetTab(nTab);
 361     aRange.aEnd.SetTab(nTab);
 362     pViewShell->MarkRange(aRange, false, false);
 363
 364     for (size_t i = 1, n = maBlockRanges.size(); i < n; ++i)
 365     {
 366         aRange = *maBlockRanges[i];
 367         aRange.aStart.SetTab(nTab);
 368         aRange.aEnd.SetTab(nTab);
 369         pViewShell->MarkRange(aRange, false, true);
 370     }
 371 }
 372
 373 ScMoveUndo::ScMoveUndo( ScDocShell* pDocSh, ScDocument* pRefDoc, ScRefUndoData* pRefData,
 374                                                 ScMoveUndoMode eRefMode ) :
 375     ScSimpleUndo( pDocSh ),
 376     pRefUndoDoc( pRefDoc ),
 377     pRefUndoData( pRefData ),
 378     eMode( eRefMode )
 379 {
 380     ScDocument* pDoc = pDocShell->GetDocument();
 381     if (pRefUndoData)
 382         pRefUndoData->DeleteUnchanged(pDoc);
 383     pDrawUndo = GetSdrUndoAction( pDoc );
 384 }
 385
 386 ScMoveUndo::~ScMoveUndo()
 387 {
 388     delete pRefUndoData;
 389     delete pRefUndoDoc;
 390     DeleteSdrUndoAction( pDrawUndo );
 391 }
 392
 393 void ScMoveUndo::UndoRef()
 394 {
 395     ScDocument* pDoc = pDocShell->GetDocument();
 396     ScRange aRange(0,0,0, MAXCOL,MAXROW,pRefUndoDoc->GetTableCount()-1);
 397     pRefUndoDoc->CopyToDocument( aRange, IDF_FORMULA, false, pDoc, NULL, false );
 398     if (pRefUndoData)
 399         pRefUndoData->DoUndo( pDoc, (eMode == SC_UNDO_REFFIRST) );
 400         // HACK: ScDragDropUndo is the only one with REFFIRST.
 401         // If not, results possibly in a too frequent adjustment
 402         // of ChartRefs. Not that pretty, but not too bad either..
 403 }
 404
 405 void ScMoveUndo::BeginUndo()
 406 {
 407     ScSimpleUndo::BeginUndo();
 408
 409     EnableDrawAdjust( pDocShell->GetDocument(), false );
 410
 411     if (pRefUndoDoc && eMode == SC_UNDO_REFFIRST)
 412         UndoRef();
 413 }
 414
 415 void ScMoveUndo::EndUndo()
 416 {
 417     DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );     // must also be called when pointer is null
 418
 419     if (pRefUndoDoc && eMode == SC_UNDO_REFLAST)
 420         UndoRef();
 421
 422     EnableDrawAdjust( pDocShell->GetDocument(), sal_True );
 423
 424     ScSimpleUndo::EndUndo();
 425 }
 426
 427 ScDBFuncUndo::ScDBFuncUndo( ScDocShell* pDocSh, const ScRange& rOriginal, SdrUndoAction* pDrawUndo ) :
 428     ScSimpleUndo( pDocSh ),
 429     aOriginalRange( rOriginal ),
 430     mpDrawUndo( pDrawUndo )
 431 {
 432     pAutoDBRange = pDocSh->GetOldAutoDBRange();
 433 }
 434
 435 ScDBFuncUndo::~ScDBFuncUndo()
 436 {
 437     DeleteSdrUndoAction( mpDrawUndo );
 438     delete pAutoDBRange;
 439 }
 440
 441 void ScDBFuncUndo::SetDrawUndoAction( SdrUndoAction* pDrawUndo )
 442 {
 443     DeleteSdrUndoAction( mpDrawUndo );
 444     mpDrawUndo = pDrawUndo;
 445 }
 446
 447 void ScDBFuncUndo::BeginUndo()
 448 {
 449     ScSimpleUndo::BeginUndo();
 450     DoSdrUndoAction( mpDrawUndo, pDocShell->GetDocument() );
 451 }
 452
 453 void ScDBFuncUndo::EndUndo()
 454 {
 455     ScSimpleUndo::EndUndo();
 456
 457     if ( pAutoDBRange )
 458     {
 459         ScDocument* pDoc = pDocShell->GetDocument();
 460         SCTAB nTab = pDoc->GetVisibleTab();
 461         ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
 462         if (pNoNameData )
 463         {
 464             SCCOL nRangeX1;
 465             SCROW nRangeY1;
 466             SCCOL nRangeX2;
 467             SCROW nRangeY2;
 468             SCTAB nRangeTab;
 469             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 470             pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 471
 472             *pNoNameData = *pAutoDBRange;
 473
 474             if ( pAutoDBRange->HasAutoFilter() )
 475             {
 476                 // restore AutoFilter buttons
 477                 pAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 478                 pDoc->ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
 479                 pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
 480             }
 481         }
 482     }
 483 }
 484
 485 void ScDBFuncUndo::BeginRedo()
 486 {
 487     RedoSdrUndoAction( mpDrawUndo );
 488     if ( pAutoDBRange )
 489     {
 490         // move the database range to this function's position again (see ScDocShell::GetDBData)
 491
 492         ScDocument* pDoc = pDocShell->GetDocument();
 493         ScDBData* pNoNameData = pDoc->GetAnonymousDBData(aOriginalRange.aStart.Tab());
 494         if ( pNoNameData )
 495         {
 496
 497             SCCOL nRangeX1;
 498             SCROW nRangeY1;
 499             SCCOL nRangeX2;
 500             SCROW nRangeY2;
 501             SCTAB nRangeTab;
 502             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 503             pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 504
 505             pNoNameData->SetSortParam( ScSortParam() );
 506             pNoNameData->SetQueryParam( ScQueryParam() );
 507             pNoNameData->SetSubTotalParam( ScSubTotalParam() );
 508
 509             pNoNameData->SetArea( aOriginalRange.aStart.Tab(),
 510                                   aOriginalRange.aStart.Col(), aOriginalRange.aStart.Row(),
 511                                   aOriginalRange.aEnd.Col(), aOriginalRange.aEnd.Row() );
 512
 513             pNoNameData->SetByRow( sal_True );
 514             pNoNameData->SetAutoFilter( false );
 515             // header is always set with the operation in redo
 516         }
 517     }
 518
 519     ScSimpleUndo::BeginRedo();
 520 }
 521
 522 void ScDBFuncUndo::EndRedo()
 523 {
 524     ScSimpleUndo::EndRedo();
 525 }
 526
 527 ScUndoWrapper::ScUndoWrapper( SfxUndoAction* pUndo ) :
 528     pWrappedUndo( pUndo )
 529 {
 530 }
 531
 532 ScUndoWrapper::~ScUndoWrapper()
 533 {
 534     delete pWrappedUndo;
 535 }
 536
 537 void ScUndoWrapper::ForgetWrappedUndo()
 538 {
 539     pWrappedUndo = NULL;    // don't delete in dtor - pointer must be stored outside
 540 }
 541
 542 OUString ScUndoWrapper::GetComment() const
 543 {
 544     if (pWrappedUndo)
 545         return pWrappedUndo->GetComment();
 546     return OUString();
 547 }
 548
 549 OUString ScUndoWrapper::GetRepeatComment(SfxRepeatTarget& rTarget) const
 550 {
 551     if (pWrappedUndo)
 552         return pWrappedUndo->GetRepeatComment(rTarget);
 553     return OUString();
 554 }
 555
 556 sal_uInt16 ScUndoWrapper::GetId() const
 557 {
 558     if (pWrappedUndo)
 559         return pWrappedUndo->GetId();
 560     else
 561         return 0;
 562 }
 563
 564 sal_Bool ScUndoWrapper::IsLinked()
 565 {
 566     if (pWrappedUndo)
 567         return pWrappedUndo->IsLinked();
 568     else
 569         return false;
 570 }
 571
 572 void ScUndoWrapper::SetLinked( sal_Bool bIsLinked )
 573 {
 574     if (pWrappedUndo)
 575         pWrappedUndo->SetLinked(bIsLinked);
 576 }
 577
 578 sal_Bool ScUndoWrapper::Merge( SfxUndoAction* pNextAction )
 579 {
 580     if (pWrappedUndo)
 581         return pWrappedUndo->Merge(pNextAction);
 582     else
 583         return false;
 584 }
 585
 586 void ScUndoWrapper::Undo()
 587 {
 588     if (pWrappedUndo)
 589         pWrappedUndo->Undo();
 590 }
 591
 592 void ScUndoWrapper::Redo()
 593 {
 594     if (pWrappedUndo)
 595         pWrappedUndo->Redo();
 596 }
 597
 598 void ScUndoWrapper::Repeat(SfxRepeatTarget& rTarget)
 599 {
 600     if (pWrappedUndo)
 601         pWrappedUndo->Repeat(rTarget);
 602 }
 603
 604 sal_Bool ScUndoWrapper::CanRepeat(SfxRepeatTarget& rTarget) const
 605 {
 606     if (pWrappedUndo)
 607         return pWrappedUndo->CanRepeat(rTarget);
 608     else
 609         return false;
 610 }
 611
 612 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */