sc/source/ui/undo/undotab.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 <sfx2/app.hxx>
  21 #include <sfx2/bindings.hxx>
  22 #include <sfx2/dispatch.hxx>
  23 #include <svl/smplhint.hxx>
  24
  25 #include "undotab.hxx"
  26 #include "document.hxx"
  27 #include "docsh.hxx"
  28 #include "tabvwsh.hxx"
  29 #include "globstr.hrc"
  30 #include "global.hxx"
  31 #include "sc.hrc"
  32 #include "undoolk.hxx"
  33 #include "target.hxx"
  34 #include "uiitems.hxx"
  35 #include "prnsave.hxx"
  36 #include "printfun.hxx"
  37 #include "chgtrack.hxx"
  38 #include "tabprotection.hxx"
  39 #include "viewdata.hxx"
  40 #include "progress.hxx"
  41 #include "markdata.hxx"
  42
  43 // for ScUndoRenameObject - might me moved to another file later
  44 #include <svx/svditer.hxx>
  45 #include <svx/svdoole2.hxx>
  46 #include <svx/svdpage.hxx>
  47 #include "drwlayer.hxx"
  48 #include "scresid.hxx"
  49
  50 #include <vector>
  51
  52 extern sal_Bool bDrawIsInUndo; // somewhere as member!
  53
  54 using namespace com::sun::star;
  55 using ::com::sun::star::uno::Sequence;
  56 using ::std::auto_ptr;
  57 using ::std::vector;
  58 using ::boost::shared_ptr;
  59
  60 TYPEINIT1(ScUndoInsertTab,      SfxUndoAction);
  61 TYPEINIT1(ScUndoInsertTables,   SfxUndoAction);
  62 TYPEINIT1(ScUndoDeleteTab,      SfxUndoAction);
  63 TYPEINIT1(ScUndoRenameTab,      SfxUndoAction);
  64 TYPEINIT1(ScUndoMoveTab,        SfxUndoAction);
  65 TYPEINIT1(ScUndoCopyTab,        SfxUndoAction);
  66 TYPEINIT1(ScUndoMakeScenario,   SfxUndoAction);
  67 TYPEINIT1(ScUndoImportTab,      SfxUndoAction);
  68 TYPEINIT1(ScUndoRemoveLink,     SfxUndoAction);
  69 TYPEINIT1(ScUndoShowHideTab,    SfxUndoAction);
  70 TYPEINIT1(ScUndoPrintRange,     SfxUndoAction);
  71 TYPEINIT1(ScUndoScenarioFlags,  SfxUndoAction);
  72 TYPEINIT1(ScUndoRenameObject,   SfxUndoAction);
  73 TYPEINIT1(ScUndoLayoutRTL,      SfxUndoAction);
  74 TYPEINIT1(ScUndoTabColor,  SfxUndoAction);
  75
  76 ScUndoInsertTab::ScUndoInsertTab( ScDocShell* pNewDocShell,
  77                                   SCTAB nTabNum,
  78                                   sal_Bool bApp,
  79                                   const OUString& rNewName) :
  80     ScSimpleUndo( pNewDocShell ),
  81     sNewName( rNewName ),
  82     pDrawUndo( NULL ),
  83     nTab( nTabNum ),
  84     bAppend( bApp )
  85 {
  86     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
  87     SetChangeTrack();
  88 }
  89
  90 ScUndoInsertTab::~ScUndoInsertTab()
  91 {
  92     DeleteSdrUndoAction( pDrawUndo );
  93 }
  94
  95 OUString ScUndoInsertTab::GetComment() const
  96 {
  97     if (bAppend)
  98         return ScGlobal::GetRscString( STR_UNDO_APPEND_TAB );
  99     else
 100         return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB );
 101 }
 102
 103 void ScUndoInsertTab::SetChangeTrack()
 104 {
 105     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 106     if ( pChangeTrack )
 107     {
 108         ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
 109         pChangeTrack->AppendInsert( aRange );
 110         nEndChangeAction = pChangeTrack->GetActionMax();
 111     }
 112     else
 113         nEndChangeAction = 0;
 114 }
 115
 116 void ScUndoInsertTab::Undo()
 117 {
 118     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 119     pViewShell->SetTabNo(nTab);
 120
 121     pDocShell->SetInUndo( sal_True );               //! BeginUndo
 122     bDrawIsInUndo = sal_True;
 123     pViewShell->DeleteTable( nTab, false );
 124     bDrawIsInUndo = false;
 125     pDocShell->SetInUndo( false );              //! EndUndo
 126
 127     DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );
 128
 129     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 130     if ( pChangeTrack )
 131         pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 132
 133     //  SetTabNo(...,sal_True) for all views to sync with drawing layer pages
 134     pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
 135 }
 136
 137 void ScUndoInsertTab::Redo()
 138 {
 139     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 140
 141     RedoSdrUndoAction( pDrawUndo );             // Draw Redo first
 142
 143     pDocShell->SetInUndo( sal_True );               //! BeginRedo
 144     bDrawIsInUndo = sal_True;
 145     if (bAppend)
 146         pViewShell->AppendTable( sNewName, false );
 147     else
 148     {
 149         pViewShell->SetTabNo(nTab);
 150         pViewShell->InsertTable( sNewName, nTab, false );
 151     }
 152     bDrawIsInUndo = false;
 153     pDocShell->SetInUndo( false );              //! EndRedo
 154
 155     SetChangeTrack();
 156 }
 157
 158 void ScUndoInsertTab::Repeat(SfxRepeatTarget& rTarget)
 159 {
 160     if (rTarget.ISA(ScTabViewTarget))
 161         ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher().
 162             Execute(FID_INS_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
 163 }
 164
 165 bool ScUndoInsertTab::CanRepeat(SfxRepeatTarget& rTarget) const
 166 {
 167     return rTarget.ISA(ScTabViewTarget);
 168 }
 169
 170 ScUndoInsertTables::ScUndoInsertTables( ScDocShell* pNewDocShell,
 171                                         SCTAB nTabNum,
 172                                         std::vector<OUString>& newNameList) :
 173     ScSimpleUndo( pNewDocShell ),
 174     pDrawUndo( NULL ),
 175     aNameList( newNameList ),
 176     nTab( nTabNum )
 177 {
 178     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 179
 180     SetChangeTrack();
 181 }
 182
 183 ScUndoInsertTables::~ScUndoInsertTables()
 184 {
 185     DeleteSdrUndoAction( pDrawUndo );
 186 }
 187
 188 OUString ScUndoInsertTables::GetComment() const
 189 {
 190     return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB );
 191 }
 192
 193 void ScUndoInsertTables::SetChangeTrack()
 194 {
 195     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 196     if ( pChangeTrack )
 197     {
 198         nStartChangeAction = pChangeTrack->GetActionMax() + 1;
 199         nEndChangeAction = 0;
 200         ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
 201         for( size_t i = 0; i < aNameList.size(); i++ )
 202         {
 203             aRange.aStart.SetTab( sal::static_int_cast<SCTAB>( nTab + i ) );
 204             aRange.aEnd.SetTab( sal::static_int_cast<SCTAB>( nTab + i ) );
 205             pChangeTrack->AppendInsert( aRange );
 206             nEndChangeAction = pChangeTrack->GetActionMax();
 207         }
 208     }
 209     else
 210         nStartChangeAction = nEndChangeAction = 0;
 211 }
 212
 213 void ScUndoInsertTables::Undo()
 214 {
 215     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 216     pViewShell->SetTabNo(nTab);
 217
 218     pDocShell->SetInUndo( sal_True );               //! BeginUndo
 219     bDrawIsInUndo = sal_True;
 220
 221     pViewShell->DeleteTables( nTab, static_cast<SCTAB>(aNameList.size()) );
 222
 223     bDrawIsInUndo = false;
 224     pDocShell->SetInUndo( false );              //! EndUndo
 225
 226     DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );
 227
 228     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 229     if ( pChangeTrack )
 230         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 231
 232     //  SetTabNo(...,sal_True) for all views to sync with drawing layer pages
 233     pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
 234 }
 235
 236 void ScUndoInsertTables::Redo()
 237 {
 238     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 239
 240     RedoSdrUndoAction( pDrawUndo );             // Draw Redo first
 241
 242     pDocShell->SetInUndo( sal_True );               //! BeginRedo
 243     bDrawIsInUndo = sal_True;
 244     pViewShell->SetTabNo(nTab);
 245     pViewShell->InsertTables( aNameList, nTab, static_cast<SCTAB>(aNameList.size()),false );
 246
 247     bDrawIsInUndo = false;
 248     pDocShell->SetInUndo( false );              //! EndRedo
 249
 250     SetChangeTrack();
 251 }
 252
 253 void ScUndoInsertTables::Repeat(SfxRepeatTarget& rTarget)
 254 {
 255     if (rTarget.ISA(ScTabViewTarget))
 256         ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher().
 257             Execute(FID_INS_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
 258 }
 259
 260 bool ScUndoInsertTables::CanRepeat(SfxRepeatTarget& rTarget) const
 261 {
 262     return rTarget.ISA(ScTabViewTarget);
 263 }
 264
 265 ScUndoDeleteTab::ScUndoDeleteTab( ScDocShell* pNewDocShell, const vector<SCTAB> &aTab,
 266                                     ScDocument* pUndoDocument, ScRefUndoData* pRefData ) :
 267     ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFLAST )
 268 {
 269     theTabs.insert(theTabs.end(), aTab.begin(), aTab.end() );
 270     SetChangeTrack();
 271 }
 272
 273 ScUndoDeleteTab::~ScUndoDeleteTab()
 274 {
 275     theTabs.clear();
 276 }
 277
 278 OUString ScUndoDeleteTab::GetComment() const
 279 {
 280     return ScGlobal::GetRscString( STR_UNDO_DELETE_TAB );
 281 }
 282
 283 void ScUndoDeleteTab::SetChangeTrack()
 284 {
 285     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 286     if ( pChangeTrack )
 287     {
 288         sal_uLong nTmpChangeAction;
 289         nStartChangeAction = pChangeTrack->GetActionMax() + 1;
 290         nEndChangeAction = 0;
 291         ScRange aRange( 0, 0, 0, MAXCOL, MAXROW, 0 );
 292         for ( unsigned int i = 0; i < theTabs.size(); ++i )
 293         {
 294             aRange.aStart.SetTab( theTabs[i] );
 295             aRange.aEnd.SetTab( theTabs[i] );
 296             pChangeTrack->AppendDeleteRange( aRange, pRefUndoDoc,
 297                 nTmpChangeAction, nEndChangeAction, (short) i );
 298         }
 299     }
 300     else
 301         nStartChangeAction = nEndChangeAction = 0;
 302 }
 303
 304 static SCTAB lcl_GetVisibleTabBefore( ScDocument& rDoc, SCTAB nTab )
 305 {
 306     while ( nTab > 0 && !rDoc.IsVisible( nTab ) )
 307         --nTab;
 308
 309     return nTab;
 310 }
 311
 312 void ScUndoDeleteTab::Undo()
 313 {
 314     BeginUndo();
 315     unsigned int i=0;
 316     ScDocument* pDoc = pDocShell->GetDocument();
 317
 318     sal_Bool bLink = false;
 319     OUString aName;
 320
 321     for(i=0; i<theTabs.size(); ++i)
 322     {
 323         SCTAB nTab = theTabs[i];
 324         pRefUndoDoc->GetName( nTab, aName );
 325
 326         bDrawIsInUndo = sal_True;
 327         sal_Bool bOk = pDoc->InsertTab( nTab, aName );
 328         bDrawIsInUndo = false;
 329         if (bOk)
 330         {
 331             pRefUndoDoc->CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,false, pDoc );
 332
 333             OUString aOldName;
 334             pRefUndoDoc->GetName( nTab, aOldName );
 335             pDoc->RenameTab( nTab, aOldName, false );
 336             if (pRefUndoDoc->IsLinked(nTab))
 337             {
 338                 pDoc->SetLink( nTab, pRefUndoDoc->GetLinkMode(nTab), pRefUndoDoc->GetLinkDoc(nTab),
 339                                      pRefUndoDoc->GetLinkFlt(nTab), pRefUndoDoc->GetLinkOpt(nTab),
 340                                      pRefUndoDoc->GetLinkTab(nTab), pRefUndoDoc->GetLinkRefreshDelay(nTab) );
 341                 bLink = sal_True;
 342             }
 343
 344             if ( pRefUndoDoc->IsScenario(nTab) )
 345             {
 346                 pDoc->SetScenario( nTab, sal_True );
 347                 OUString aComment;
 348                 Color  aColor;
 349                 sal_uInt16 nScenFlags;
 350                 pRefUndoDoc->GetScenarioData( nTab, aComment, aColor, nScenFlags );
 351                 pDoc->SetScenarioData( nTab, aComment, aColor, nScenFlags );
 352                 sal_Bool bActive = pRefUndoDoc->IsActiveScenario( nTab );
 353                 pDoc->SetActiveScenario( nTab, bActive );
 354             }
 355             pDoc->SetVisible( nTab, pRefUndoDoc->IsVisible( nTab ) );
 356             pDoc->SetTabBgColor( nTab, pRefUndoDoc->GetTabBgColor(nTab) );
 357             pDoc->SetSheetEvents( nTab, pRefUndoDoc->GetSheetEvents( nTab ) );
 358             pDoc->SetLayoutRTL( nTab, pRefUndoDoc->IsLayoutRTL( nTab ) );
 359
 360             if ( pRefUndoDoc->IsTabProtected( nTab ) )
 361                 pDoc->SetTabProtection(nTab, pRefUndoDoc->GetTabProtection(nTab));
 362         }
 363     }
 364     if (bLink)
 365     {
 366         pDocShell->UpdateLinks(); // update Link Manager
 367     }
 368
 369     EndUndo();      // Draw-Undo has to be called before Broadcast!
 370
 371     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 372     if ( pChangeTrack )
 373         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 374
 375     for(i=0; i<theTabs.size(); ++i)
 376     {
 377         pDocShell->Broadcast( ScTablesHint( SC_TAB_INSERTED, theTabs[i]) );
 378     }
 379     SfxApplication* pSfxApp = SFX_APP();                                // Navigator
 380     pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
 381     pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
 382     pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
 383
 384     pDocShell->PostPaint(0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_ALL );  // incl. extras
 385
 386     // not ShowTable due to SetTabNo(..., sal_True):
 387     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 388     if (pViewShell)
 389         pViewShell->SetTabNo( lcl_GetVisibleTabBefore( *pDoc, theTabs[0] ), true );
 390 }
 391
 392 void ScUndoDeleteTab::Redo()
 393 {
 394     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 395     pViewShell->SetTabNo( lcl_GetVisibleTabBefore( *pDocShell->GetDocument(), theTabs.front() ) );
 396
 397     RedoSdrUndoAction( pDrawUndo );             // Draw Redo first
 398
 399     pDocShell->SetInUndo( sal_True );               //! BeginRedo
 400     bDrawIsInUndo = sal_True;
 401     pViewShell->DeleteTables( theTabs, false );
 402     bDrawIsInUndo = false;
 403     pDocShell->SetInUndo( sal_True );               //! EndRedo
 404
 405     SetChangeTrack();
 406
 407     //  SetTabNo(...,sal_True) for all views to sync with drawing layer pages
 408     pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
 409 }
 410
 411 void ScUndoDeleteTab::Repeat(SfxRepeatTarget& rTarget)
 412 {
 413     if (rTarget.ISA(ScTabViewTarget))
 414     {
 415         ScTabViewShell* pViewShell = ((ScTabViewTarget&)rTarget).GetViewShell();
 416         pViewShell->DeleteTable( pViewShell->GetViewData()->GetTabNo(), sal_True );
 417     }
 418 }
 419
 420 bool ScUndoDeleteTab::CanRepeat(SfxRepeatTarget& rTarget) const
 421 {
 422     return rTarget.ISA(ScTabViewTarget);
 423 }
 424
 425 ScUndoRenameTab::ScUndoRenameTab( ScDocShell* pNewDocShell,
 426                                   SCTAB nT,
 427                                   const OUString& rOldName,
 428                                   const OUString& rNewName) :
 429     ScSimpleUndo( pNewDocShell ),
 430     nTab     ( nT )
 431 {
 432     sOldName = rOldName;
 433     sNewName = rNewName;
 434 }
 435
 436 ScUndoRenameTab::~ScUndoRenameTab()
 437 {
 438 }
 439
 440 OUString ScUndoRenameTab::GetComment() const
 441 {
 442     return ScGlobal::GetRscString( STR_UNDO_RENAME_TAB );
 443 }
 444
 445 void ScUndoRenameTab::DoChange( SCTAB nTabP, const OUString& rName ) const
 446 {
 447     ScDocument* pDoc = pDocShell->GetDocument();
 448     pDoc->RenameTab( nTabP, rName );
 449
 450     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );    // Navigator
 451
 452     pDocShell->PostPaintGridAll();
 453     pDocShell->PostPaintExtras();
 454     pDocShell->PostDataChanged();
 455
 456     // The sheet name might be used in a formula ...
 457     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 458     if (pViewShell)
 459         pViewShell->UpdateInputHandler();
 460 }
 461
 462 void ScUndoRenameTab::Undo()
 463 {
 464     DoChange(nTab, sOldName);
 465 }
 466
 467 void ScUndoRenameTab::Redo()
 468 {
 469     DoChange(nTab, sNewName);
 470 }
 471
 472 void ScUndoRenameTab::Repeat(SfxRepeatTarget& /* rTarget */)
 473 {
 474     // makes no sense
 475 }
 476
 477 bool ScUndoRenameTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 478 {
 479     return false;
 480 }
 481
 482 ScUndoMoveTab::ScUndoMoveTab(
 483     ScDocShell* pNewDocShell, vector<SCTAB>* pOldTabs, vector<SCTAB>* pNewTabs,
 484     vector<OUString>* pOldNames, vector<OUString>* pNewNames) :
 485     ScSimpleUndo( pNewDocShell ),
 486     mpOldTabs(pOldTabs), mpNewTabs(pNewTabs),
 487     mpOldNames(pOldNames), mpNewNames(pNewNames)
 488 {
 489     if (mpOldNames && mpOldTabs->size() != mpOldNames->size())
 490         // The sizes differ.  Something is wrong.
 491         mpOldNames.reset();
 492
 493     if (mpNewNames && mpNewTabs->size() != mpNewNames->size())
 494         // The sizes differ.  Something is wrong.
 495         mpNewNames.reset();
 496 }
 497
 498 ScUndoMoveTab::~ScUndoMoveTab()
 499 {
 500 }
 501
 502 OUString ScUndoMoveTab::GetComment() const
 503 {
 504     return ScGlobal::GetRscString( STR_UNDO_MOVE_TAB );
 505 }
 506
 507 void ScUndoMoveTab::DoChange( sal_Bool bUndo ) const
 508 {
 509     ScDocument* pDoc = pDocShell->GetDocument();
 510     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 511
 512     if (bUndo)                                      // UnDo
 513     {
 514         size_t i = mpNewTabs->size();
 515         ScProgress* pProgress = new ScProgress(pDocShell , ScGlobal::GetRscString(STR_UNDO_MOVE_TAB),
 516                                                 i * pDoc->GetCodeCount());
 517         for (; i > 0; --i)
 518         {
 519             SCTAB nDestTab = (*mpNewTabs)[i-1];
 520             SCTAB nOldTab = (*mpOldTabs)[i-1];
 521             if (nDestTab > MAXTAB)                          // appended ?
 522                 nDestTab = pDoc->GetTableCount() - 1;
 523
 524             pDoc->MoveTab( nDestTab, nOldTab, pProgress );
 525             pViewShell->GetViewData()->MoveTab( nDestTab, nOldTab );
 526             pViewShell->SetTabNo( nOldTab, true );
 527             if (mpOldNames)
 528             {
 529                 const OUString& rOldName = (*mpOldNames)[i-1];
 530                 pDoc->RenameTab(nOldTab, rOldName);
 531             }
 532         }
 533         delete pProgress;
 534     }
 535     else
 536     {
 537         size_t n = mpNewTabs->size();
 538         ScProgress* pProgress = new ScProgress(pDocShell , ScGlobal::GetRscString(STR_UNDO_MOVE_TAB),
 539                                                 n * pDoc->GetCodeCount());
 540         for (size_t i = 0; i < n; ++i)
 541         {
 542             SCTAB nDestTab = (*mpNewTabs)[i];
 543             SCTAB nNewTab = nDestTab;
 544             SCTAB nOldTab = (*mpOldTabs)[i];
 545             if (nDestTab > MAXTAB)                          // appended ?
 546                 nDestTab = pDoc->GetTableCount() - 1;
 547
 548             pDoc->MoveTab( nOldTab, nNewTab, pProgress );
 549             pViewShell->GetViewData()->MoveTab( nOldTab, nNewTab );
 550             pViewShell->SetTabNo( nDestTab, true );
 551             if (mpNewNames)
 552             {
 553                 const OUString& rNewName = (*mpNewNames)[i];
 554                 pDoc->RenameTab(nNewTab, rNewName);
 555             }
 556         }
 557         delete pProgress;
 558     }
 559
 560     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );    // Navigator
 561
 562     pDocShell->PostPaintGridAll();
 563     pDocShell->PostPaintExtras();
 564     pDocShell->PostDataChanged();
 565 }
 566
 567 void ScUndoMoveTab::Undo()
 568 {
 569     DoChange( sal_True );
 570 }
 571
 572 void ScUndoMoveTab::Redo()
 573 {
 574     DoChange( false );
 575 }
 576
 577 void ScUndoMoveTab::Repeat(SfxRepeatTarget& /* rTarget */)
 578 {
 579         // No Repeat ! ? !
 580 }
 581
 582 bool ScUndoMoveTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 583 {
 584     return false;
 585 }
 586
 587 ScUndoCopyTab::ScUndoCopyTab(
 588     ScDocShell* pNewDocShell,
 589     vector<SCTAB>* pOldTabs, vector<SCTAB>* pNewTabs,
 590     vector<OUString>* pNewNames) :
 591     ScSimpleUndo( pNewDocShell ),
 592     mpOldTabs(pOldTabs),
 593     mpNewTabs(pNewTabs),
 594     mpNewNames(pNewNames),
 595     pDrawUndo( NULL )
 596 {
 597     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 598
 599     if (mpNewNames && mpNewTabs->size() != mpNewNames->size())
 600         // The sizes differ.  Something is wrong.
 601         mpNewNames.reset();
 602 }
 603
 604 ScUndoCopyTab::~ScUndoCopyTab()
 605 {
 606     DeleteSdrUndoAction( pDrawUndo );
 607 }
 608
 609 OUString ScUndoCopyTab::GetComment() const
 610 {
 611     return ScGlobal::GetRscString( STR_UNDO_COPY_TAB );
 612 }
 613
 614 void ScUndoCopyTab::DoChange() const
 615 {
 616     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 617
 618     if (pViewShell)
 619         pViewShell->SetTabNo((*mpOldTabs)[0],true);
 620
 621     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );    // Navigator
 622
 623     pDocShell->PostPaintGridAll();
 624     pDocShell->PostPaintExtras();
 625     pDocShell->PostDataChanged();
 626 }
 627
 628 void ScUndoCopyTab::Undo()
 629 {
 630     ScDocument* pDoc = pDocShell->GetDocument();
 631
 632     DoSdrUndoAction( pDrawUndo, pDoc );                 // before the sheets are deleted
 633
 634     vector<SCTAB>::const_reverse_iterator itr, itrEnd = mpNewTabs->rend();
 635     for (itr = mpNewTabs->rbegin(); itr != itrEnd; ++itr)
 636     {
 637         SCTAB nDestTab = *itr;
 638         if (nDestTab > MAXTAB)                          // append?
 639             nDestTab = pDoc->GetTableCount() - 1;
 640
 641         bDrawIsInUndo = sal_True;
 642         pDoc->DeleteTab(nDestTab);
 643         bDrawIsInUndo = false;
 644     }
 645
 646     //  ScTablesHint broadcasts after all sheets have been deleted,
 647     //  so sheets and draw pages are in sync!
 648
 649     for (itr = mpNewTabs->rbegin(); itr != itrEnd; ++itr)
 650     {
 651         SCTAB nDestTab = *itr;
 652         if (nDestTab > MAXTAB)                          // append?
 653             nDestTab = pDoc->GetTableCount() - 1;
 654
 655         pDocShell->Broadcast( ScTablesHint( SC_TAB_DELETED, nDestTab ) );
 656     }
 657
 658     DoChange();
 659 }
 660
 661 void ScUndoCopyTab::Redo()
 662 {
 663     ScDocument* pDoc = pDocShell->GetDocument();
 664     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 665
 666     SCTAB nDestTab = 0;
 667     for (size_t i = 0, n = mpNewTabs->size(); i < n; ++i)
 668     {
 669         nDestTab = (*mpNewTabs)[i];
 670         SCTAB nNewTab = nDestTab;
 671         SCTAB nOldTab = (*mpOldTabs)[i];
 672         if (nDestTab > MAXTAB)                          // appended ?
 673             nDestTab = pDoc->GetTableCount() - 1;
 674
 675         bDrawIsInUndo = sal_True;
 676         pDoc->CopyTab( nOldTab, nNewTab );
 677         bDrawIsInUndo = false;
 678
 679         pViewShell->GetViewData()->MoveTab( nOldTab, nNewTab );
 680
 681         SCTAB nAdjSource = nOldTab;
 682         if ( nNewTab <= nOldTab )
 683             ++nAdjSource;               // new position of source table after CopyTab
 684
 685         if ( pDoc->IsScenario(nAdjSource) )
 686         {
 687             pDoc->SetScenario(nNewTab, sal_True );
 688             OUString aComment;
 689             Color  aColor;
 690             sal_uInt16 nScenFlags;
 691             pDoc->GetScenarioData(nAdjSource, aComment, aColor, nScenFlags );
 692             pDoc->SetScenarioData(nNewTab, aComment, aColor, nScenFlags );
 693             sal_Bool bActive = pDoc->IsActiveScenario(nAdjSource);
 694             pDoc->SetActiveScenario(nNewTab, bActive );
 695             sal_Bool bVisible=pDoc->IsVisible(nAdjSource);
 696             pDoc->SetVisible(nNewTab,bVisible );
 697         }
 698
 699         if ( pDoc->IsTabProtected( nAdjSource ) )
 700             pDoc->CopyTabProtection(nAdjSource, nNewTab);
 701
 702         if (mpNewNames)
 703         {
 704             const OUString& rName = (*mpNewNames)[i];
 705             pDoc->RenameTab(nNewTab, rName);
 706         }
 707     }
 708
 709     RedoSdrUndoAction( pDrawUndo );             // after the sheets are inserted
 710
 711     pViewShell->SetTabNo( nDestTab, sal_True );     // after draw-undo
 712
 713     DoChange();
 714
 715 }
 716
 717 void ScUndoCopyTab::Repeat(SfxRepeatTarget& /* rTarget */)
 718 {
 719         // no Repeat ! ? !
 720 }
 721
 722 bool ScUndoCopyTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 723 {
 724     return false;
 725 }
 726
 727
 728 ScUndoTabColor::ScUndoTabColor(
 729     ScDocShell* pNewDocShell, SCTAB nT, const Color& aOTabBgColor, const Color& aNTabBgColor) :
 730     ScSimpleUndo( pNewDocShell )
 731 {
 732     ScUndoTabColorInfo aInfo(nT);
 733     aInfo.maOldTabBgColor = aOTabBgColor;
 734     aInfo.maNewTabBgColor = aNTabBgColor;
 735     aTabColorList.push_back(aInfo);
 736 }
 737
 738 ScUndoTabColor::ScUndoTabColor(
 739     ScDocShell* pNewDocShell,
 740     const ScUndoTabColorInfo::List& rUndoTabColorList) :
 741     ScSimpleUndo(pNewDocShell),
 742     aTabColorList(rUndoTabColorList)
 743 {
 744 }
 745
 746 ScUndoTabColor::~ScUndoTabColor()
 747 {
 748 }
 749
 750 OUString ScUndoTabColor::GetComment() const
 751 {
 752     if (aTabColorList.size() > 1)
 753         return ScGlobal::GetRscString(STR_UNDO_SET_MULTI_TAB_BG_COLOR);
 754     return ScGlobal::GetRscString(STR_UNDO_SET_TAB_BG_COLOR);
 755 }
 756
 757 void ScUndoTabColor::DoChange(bool bUndoType) const
 758 {
 759     ScDocument* pDoc = pDocShell->GetDocument();
 760     if (!pDoc)
 761         return;
 762
 763     size_t nTabColorCount = aTabColorList.size();
 764     for (size_t i = 0; i < nTabColorCount; ++i)
 765     {
 766         const ScUndoTabColorInfo& rTabColor = aTabColorList[i];
 767         pDoc->SetTabBgColor(rTabColor.mnTabId,
 768             bUndoType ? rTabColor.maOldTabBgColor : rTabColor.maNewTabBgColor);
 769     }
 770
 771     pDocShell->PostPaintExtras();
 772     ScDocShellModificator aModificator( *pDocShell );
 773     aModificator.SetDocumentModified();
 774 }
 775
 776 void ScUndoTabColor::Undo()
 777 {
 778     DoChange(true);
 779 }
 780
 781 void ScUndoTabColor::Redo()
 782 {
 783     DoChange(false);
 784 }
 785
 786 void ScUndoTabColor::Repeat(SfxRepeatTarget& /* rTarget */)
 787 {
 788     // makes no sense
 789 }
 790
 791 bool ScUndoTabColor::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 792 {
 793     return false;
 794 }
 795
 796 ScUndoMakeScenario::ScUndoMakeScenario( ScDocShell* pNewDocShell,
 797                         SCTAB nSrc, SCTAB nDest,
 798                         const OUString& rN, const OUString& rC,
 799                         const Color& rCol, sal_uInt16 nF,
 800                         const ScMarkData& rMark ) :
 801     ScSimpleUndo( pNewDocShell ),
 802     mpMarkData(new ScMarkData(rMark)),
 803     nSrcTab( nSrc ),
 804     nDestTab( nDest ),
 805     aName( rN ),
 806     aComment( rC ),
 807     aColor( rCol ),
 808     nFlags( nF ),
 809     pDrawUndo( NULL )
 810 {
 811     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 812 }
 813
 814 ScUndoMakeScenario::~ScUndoMakeScenario()
 815 {
 816     DeleteSdrUndoAction( pDrawUndo );
 817 }
 818
 819 OUString ScUndoMakeScenario::GetComment() const
 820 {
 821     return ScGlobal::GetRscString( STR_UNDO_MAKESCENARIO );
 822 }
 823
 824 void ScUndoMakeScenario::Undo()
 825 {
 826     ScDocument* pDoc = pDocShell->GetDocument();
 827
 828     pDocShell->SetInUndo( sal_True );
 829     bDrawIsInUndo = sal_True;
 830     pDoc->DeleteTab( nDestTab );
 831     bDrawIsInUndo = false;
 832     pDocShell->SetInUndo( false );
 833
 834     DoSdrUndoAction( pDrawUndo, pDoc );
 835
 836     pDocShell->PostPaint(0,0,nDestTab,MAXCOL,MAXROW,MAXTAB, PAINT_ALL);
 837     pDocShell->PostDataChanged();
 838
 839     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 840     if (pViewShell)
 841         pViewShell->SetTabNo( nSrcTab, sal_True );
 842
 843     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
 844
 845     //  SetTabNo(...,sal_True) for all views to sync with drawing layer pages
 846     pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
 847 }
 848
 849 void ScUndoMakeScenario::Redo()
 850 {
 851     SetViewMarkData(*mpMarkData);
 852
 853     RedoSdrUndoAction( pDrawUndo );             // Draw Redo first
 854
 855     pDocShell->SetInUndo( sal_True );
 856     bDrawIsInUndo = sal_True;
 857
 858     pDocShell->MakeScenario( nSrcTab, aName, aComment, aColor, nFlags, *mpMarkData, false );
 859
 860     bDrawIsInUndo = false;
 861     pDocShell->SetInUndo( false );
 862
 863     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 864     if (pViewShell)
 865         pViewShell->SetTabNo( nDestTab, sal_True );
 866
 867     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
 868 }
 869
 870 void ScUndoMakeScenario::Repeat(SfxRepeatTarget& rTarget)
 871 {
 872     if (rTarget.ISA(ScTabViewTarget))
 873     {
 874         ((ScTabViewTarget&)rTarget).GetViewShell()->MakeScenario( aName, aComment, aColor, nFlags );
 875     }
 876 }
 877
 878 bool ScUndoMakeScenario::CanRepeat(SfxRepeatTarget& rTarget) const
 879 {
 880     return rTarget.ISA(ScTabViewTarget);
 881 }
 882
 883 ScUndoImportTab::ScUndoImportTab( ScDocShell* pShell,
 884                         SCTAB nNewTab, SCTAB nNewCount ) :
 885     ScSimpleUndo( pShell ),
 886     nTab( nNewTab ),
 887     nCount( nNewCount ),
 888     pRedoDoc( NULL ),
 889     pDrawUndo( NULL )
 890 {
 891     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 892 }
 893
 894 ScUndoImportTab::~ScUndoImportTab()
 895 {
 896     delete pRedoDoc;
 897     DeleteSdrUndoAction( pDrawUndo );
 898 }
 899
 900 OUString ScUndoImportTab::GetComment() const
 901 {
 902     return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB );
 903 }
 904
 905 void ScUndoImportTab::DoChange() const
 906 {
 907     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 908     ScDocument* pDoc = pDocShell->GetDocument();
 909     SCTAB nTabCount = pDoc->GetTableCount();
 910     if (pViewShell)
 911     {
 912         if(nTab<nTabCount)
 913         {
 914             pViewShell->SetTabNo(nTab,sal_True);
 915         }
 916         else
 917         {
 918             pViewShell->SetTabNo(nTab-1,sal_True);
 919         }
 920     }
 921
 922     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );    // Navigator
 923     pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB,
 924                                 PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS );
 925 }
 926
 927 void ScUndoImportTab::Undo()
 928 {
 929     // Inserted range names, etc.
 930
 931     SCTAB i;
 932     ScDocument* pDoc = pDocShell->GetDocument();
 933     sal_Bool bMakeRedo = !pRedoDoc;
 934     if (bMakeRedo)
 935     {
 936         pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
 937         pRedoDoc->InitUndo( pDoc, nTab,nTab+nCount-1, sal_True,sal_True );
 938
 939         OUString aOldName;
 940         for (i=0; i<nCount; i++)
 941         {
 942             SCTAB nTabPos=nTab+i;
 943
 944             pDoc->CopyToDocument(0,0,nTabPos, MAXCOL,MAXROW,nTabPos, IDF_ALL,false, pRedoDoc );
 945             pDoc->GetName( nTabPos, aOldName );
 946             pRedoDoc->RenameTab( nTabPos, aOldName, false );
 947             pRedoDoc->SetTabBgColor( nTabPos, pDoc->GetTabBgColor(nTabPos) );
 948
 949             if ( pDoc->IsScenario(nTabPos) )
 950             {
 951                 pRedoDoc->SetScenario(nTabPos, sal_True );
 952                 OUString aComment;
 953                 Color  aColor;
 954                 sal_uInt16 nScenFlags;
 955                 pDoc->GetScenarioData(nTabPos, aComment, aColor, nScenFlags );
 956                 pRedoDoc->SetScenarioData(nTabPos, aComment, aColor, nScenFlags );
 957                 sal_Bool bActive = pDoc->IsActiveScenario(nTabPos);
 958                 pRedoDoc->SetActiveScenario(nTabPos, bActive );
 959                 sal_Bool bVisible=pDoc->IsVisible(nTabPos);
 960                 pRedoDoc->SetVisible(nTabPos,bVisible );
 961             }
 962
 963             if ( pDoc->IsTabProtected( nTabPos ) )
 964                 pRedoDoc->SetTabProtection(nTabPos, pDoc->GetTabProtection(nTabPos));
 965         }
 966
 967     }
 968
 969     DoSdrUndoAction( pDrawUndo, pDoc );             // before the sheets are deleted
 970
 971     bDrawIsInUndo = sal_True;
 972     for (i=0; i<nCount; i++)
 973         pDoc->DeleteTab( nTab );
 974     bDrawIsInUndo = false;
 975
 976     DoChange();
 977 }
 978
 979 void ScUndoImportTab::Redo()
 980 {
 981     if (!pRedoDoc)
 982     {
 983         OSL_FAIL("Where is my Redo Document?");
 984         return;
 985     }
 986
 987     ScDocument* pDoc = pDocShell->GetDocument();
 988     OUString aName;
 989     SCTAB i;
 990     for (i=0; i<nCount; i++)                // first insert all sheets (#63304#)
 991     {
 992         SCTAB nTabPos=nTab+i;
 993         pRedoDoc->GetName(nTabPos,aName);
 994         bDrawIsInUndo = sal_True;
 995         pDoc->InsertTab(nTabPos,aName);
 996         bDrawIsInUndo = false;
 997     }
 998     for (i=0; i<nCount; i++)                // then copy into inserted sheets
 999     {
1000         SCTAB nTabPos=nTab+i;
1001         pRedoDoc->CopyToDocument(0,0,nTabPos, MAXCOL,MAXROW,nTabPos, IDF_ALL,false, pDoc );
1002         pDoc->SetTabBgColor( nTabPos, pRedoDoc->GetTabBgColor(nTabPos) );
1003
1004         if ( pRedoDoc->IsScenario(nTabPos) )
1005         {
1006             pDoc->SetScenario(nTabPos, sal_True );
1007             OUString aComment;
1008             Color  aColor;
1009             sal_uInt16 nScenFlags;
1010             pRedoDoc->GetScenarioData(nTabPos, aComment, aColor, nScenFlags );
1011             pDoc->SetScenarioData(nTabPos, aComment, aColor, nScenFlags );
1012             sal_Bool bActive = pRedoDoc->IsActiveScenario(nTabPos);
1013             pDoc->SetActiveScenario(nTabPos, bActive );
1014             sal_Bool bVisible=pRedoDoc->IsVisible(nTabPos);
1015             pDoc->SetVisible(nTabPos,bVisible );
1016         }
1017
1018         if ( pRedoDoc->IsTabProtected( nTabPos ) )
1019             pDoc->SetTabProtection(nTabPos, pRedoDoc->GetTabProtection(nTabPos));
1020     }
1021
1022     RedoSdrUndoAction( pDrawUndo );     // after the sheets are inserted
1023
1024     DoChange();
1025 }
1026
1027 void ScUndoImportTab::Repeat(SfxRepeatTarget& rTarget)
1028 {
1029     if (rTarget.ISA(ScTabViewTarget))
1030         ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher().
1031             Execute(FID_INS_TABLE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
1032 }
1033
1034 bool ScUndoImportTab::CanRepeat(SfxRepeatTarget& rTarget) const
1035 {
1036     return rTarget.ISA(ScTabViewTarget);
1037 }
1038
1039 ScUndoRemoveLink::ScUndoRemoveLink( ScDocShell* pShell, const OUString& rDoc ) :
1040     ScSimpleUndo( pShell ),
1041     aDocName( rDoc ),
1042     nRefreshDelay( 0 ),
1043     nCount( 0 )
1044 {
1045     ScDocument* pDoc = pDocShell->GetDocument();
1046     SCTAB nTabCount = pDoc->GetTableCount();
1047     pTabs     = new SCTAB[nTabCount];
1048     pModes    = new sal_uInt8[nTabCount];
1049     pTabNames = new OUString[nTabCount];
1050
1051     for (SCTAB i=0; i<nTabCount; i++)
1052     {
1053         sal_uInt8 nMode = pDoc->GetLinkMode(i);
1054         if (nMode)
1055             if (pDoc->GetLinkDoc(i) == aDocName)
1056             {
1057                 if (!nCount)
1058                 {
1059                     aFltName = pDoc->GetLinkFlt(i);
1060                     aOptions = pDoc->GetLinkOpt(i);
1061                     nRefreshDelay = pDoc->GetLinkRefreshDelay(i);
1062                 }
1063                 else
1064                 {
1065                     OSL_ENSURE(OUString(aFltName) == pDoc->GetLinkFlt(i) &&
1066                                OUString(aOptions) == pDoc->GetLinkOpt(i),
1067                                     "different Filter for a Document?");
1068                 }
1069                 pTabs[nCount] = i;
1070                 pModes[nCount] = nMode;
1071                 pTabNames[nCount] = pDoc->GetLinkTab(i);
1072                 ++nCount;
1073             }
1074     }
1075 }
1076
1077 ScUndoRemoveLink::~ScUndoRemoveLink()
1078 {
1079     delete pTabs;
1080     delete pModes;
1081     delete[] pTabNames;
1082 }
1083
1084 OUString ScUndoRemoveLink::GetComment() const
1085 {
1086     return ScGlobal::GetRscString( STR_UNDO_REMOVELINK );
1087 }
1088
1089 void ScUndoRemoveLink::DoChange( sal_Bool bLink ) const
1090 {
1091     ScDocument* pDoc = pDocShell->GetDocument();
1092     OUString aEmpty;
1093     for (sal_uInt16 i=0; i<nCount; i++)
1094         if (bLink)      // establish link
1095             pDoc->SetLink( pTabs[i], pModes[i], aDocName, aFltName, aOptions, pTabNames[i], nRefreshDelay );
1096         else            // remove link
1097             pDoc->SetLink( pTabs[i], SC_LINK_NONE, aEmpty, aEmpty, aEmpty, aEmpty, 0 );
1098     pDocShell->UpdateLinks();
1099 }
1100
1101 void ScUndoRemoveLink::Undo()
1102 {
1103     DoChange( sal_True );
1104 }
1105
1106 void ScUndoRemoveLink::Redo()
1107 {
1108     DoChange( false );
1109 }
1110
1111 void ScUndoRemoveLink::Repeat(SfxRepeatTarget& /* rTarget */)
1112 {
1113     // makes no sense
1114 }
1115
1116 bool ScUndoRemoveLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1117 {
1118     return false;
1119 }
1120
1121 ScUndoShowHideTab::ScUndoShowHideTab( ScDocShell* pShell, const std::vector<SCTAB>& newUndoTabs, sal_Bool bNewShow ) :
1122     ScSimpleUndo( pShell ),
1123     undoTabs( newUndoTabs ),
1124     bShow( bNewShow )
1125 {
1126 }
1127
1128 ScUndoShowHideTab::~ScUndoShowHideTab()
1129 {
1130 }
1131
1132 void ScUndoShowHideTab::DoChange( sal_Bool bShowP ) const
1133 {
1134     ScDocument* pDoc = pDocShell->GetDocument();
1135     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1136
1137     SCTAB nTab;
1138
1139     for(std::vector<SCTAB>::const_iterator itr = undoTabs.begin(), itrEnd = undoTabs.end(); itr != itrEnd; ++itr)
1140     {
1141         nTab = *itr;
1142         pDoc->SetVisible( nTab, bShowP );
1143         if (pViewShell)
1144             pViewShell->SetTabNo(nTab,sal_True);
1145     }
1146
1147     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1148     pDocShell->SetDocumentModified();
1149 }
1150
1151 void ScUndoShowHideTab::Undo()
1152 {
1153     DoChange(!bShow);
1154 }
1155
1156 void ScUndoShowHideTab::Redo()
1157 {
1158     DoChange(bShow);
1159 }
1160
1161 void ScUndoShowHideTab::Repeat(SfxRepeatTarget& rTarget)
1162 {
1163     if (rTarget.ISA(ScTabViewTarget))
1164         ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher().
1165             Execute( bShow ? FID_TABLE_SHOW : FID_TABLE_HIDE,
1166                                 SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
1167 }
1168
1169 bool ScUndoShowHideTab::CanRepeat(SfxRepeatTarget& rTarget) const
1170 {
1171     return rTarget.ISA(ScTabViewTarget);
1172 }
1173
1174 OUString ScUndoShowHideTab::GetComment() const
1175 {
1176     sal_uInt16 nId;
1177     if (undoTabs.size() > 1)
1178     {
1179         nId = bShow ? STR_UNDO_SHOWTABS : STR_UNDO_HIDETABS;
1180     }
1181     else
1182     {
1183         nId = bShow ? STR_UNDO_SHOWTAB : STR_UNDO_HIDETAB;
1184     }
1185
1186     return ScGlobal::GetRscString( nId );
1187 }
1188
1189 SAL_WNODEPRECATED_DECLARATIONS_PUSH
1190 ScUndoDocProtect::ScUndoDocProtect(ScDocShell* pShell, auto_ptr<ScDocProtection> pProtectSettings) :
1191     ScSimpleUndo(pShell),
1192     mpProtectSettings(pProtectSettings)
1193 {
1194 }
1195 SAL_WNODEPRECATED_DECLARATIONS_POP
1196
1197 ScUndoDocProtect::~ScUndoDocProtect()
1198 {
1199 }
1200
1201 void ScUndoDocProtect::DoProtect(bool bProtect)
1202 {
1203     ScDocument* pDoc = pDocShell->GetDocument();
1204
1205     if (bProtect)
1206     {
1207         // set protection.
1208         SAL_WNODEPRECATED_DECLARATIONS_PUSH
1209         auto_ptr<ScDocProtection> pCopy(new ScDocProtection(*mpProtectSettings));
1210         SAL_WNODEPRECATED_DECLARATIONS_POP
1211         pCopy->setProtected(true);
1212         pDoc->SetDocProtection(pCopy.get());
1213     }
1214     else
1215     {
1216         // remove protection.
1217         pDoc->SetDocProtection(NULL);
1218     }
1219
1220     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1221     if (pViewShell)
1222     {
1223         pViewShell->UpdateLayerLocks();
1224         pViewShell->UpdateInputHandler(sal_True);   // so that input can be immediately entered again
1225     }
1226
1227     pDocShell->PostPaintGridAll();
1228 }
1229
1230 void ScUndoDocProtect::Undo()
1231 {
1232     BeginUndo();
1233     DoProtect(!mpProtectSettings->isProtected());
1234     EndUndo();
1235 }
1236
1237 void ScUndoDocProtect::Redo()
1238 {
1239     BeginRedo();
1240     DoProtect(mpProtectSettings->isProtected());
1241     EndRedo();
1242 }
1243
1244 void ScUndoDocProtect::Repeat(SfxRepeatTarget& /* rTarget */)
1245 {
1246     // makes no sense
1247 }
1248
1249 bool ScUndoDocProtect::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1250 {
1251     return false;       // makes no sense
1252 }
1253
1254 OUString ScUndoDocProtect::GetComment() const
1255 {
1256     sal_uInt16 nId = mpProtectSettings->isProtected() ? STR_UNDO_PROTECT_DOC : STR_UNDO_UNPROTECT_DOC;
1257     return ScGlobal::GetRscString( nId );
1258 }
1259
1260 SAL_WNODEPRECATED_DECLARATIONS_PUSH
1261 ScUndoTabProtect::ScUndoTabProtect(ScDocShell* pShell, SCTAB nTab, auto_ptr<ScTableProtection> pProtectSettings) :
1262     ScSimpleUndo(pShell),
1263     mnTab(nTab),
1264     mpProtectSettings(pProtectSettings)
1265 {
1266 }
1267 SAL_WNODEPRECATED_DECLARATIONS_POP
1268
1269 ScUndoTabProtect::~ScUndoTabProtect()
1270 {
1271 }
1272
1273 void ScUndoTabProtect::DoProtect(bool bProtect)
1274 {
1275     ScDocument* pDoc = pDocShell->GetDocument();
1276
1277     if (bProtect)
1278     {
1279         // set protection.
1280         SAL_WNODEPRECATED_DECLARATIONS_PUSH
1281         auto_ptr<ScTableProtection> pCopy(new ScTableProtection(*mpProtectSettings));
1282         SAL_WNODEPRECATED_DECLARATIONS_POP
1283         pCopy->setProtected(true);
1284         pDoc->SetTabProtection(mnTab, pCopy.get());
1285     }
1286     else
1287     {
1288         // remove protection.
1289         pDoc->SetTabProtection(mnTab, NULL);
1290     }
1291
1292     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1293     if (pViewShell)
1294     {
1295         pViewShell->UpdateLayerLocks();
1296         pViewShell->UpdateInputHandler(sal_True);   // so that input can be immediately entered again
1297     }
1298
1299     pDocShell->PostPaintGridAll();
1300 }
1301
1302 void ScUndoTabProtect::Undo()
1303 {
1304     BeginUndo();
1305     DoProtect(!mpProtectSettings->isProtected());
1306     EndUndo();
1307 }
1308
1309 void ScUndoTabProtect::Redo()
1310 {
1311     BeginRedo();
1312     DoProtect(mpProtectSettings->isProtected());
1313     EndRedo();
1314 }
1315
1316 void ScUndoTabProtect::Repeat(SfxRepeatTarget& /* rTarget */)
1317 {
1318     // makes no sense
1319 }
1320
1321 bool ScUndoTabProtect::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1322 {
1323     return false;       // makes no sense
1324 }
1325
1326 OUString ScUndoTabProtect::GetComment() const
1327 {
1328     sal_uInt16 nId = mpProtectSettings->isProtected() ? STR_UNDO_PROTECT_TAB : STR_UNDO_UNPROTECT_TAB;
1329     return ScGlobal::GetRscString( nId );
1330 }
1331
1332 ScUndoPrintRange::ScUndoPrintRange( ScDocShell* pShell, SCTAB nNewTab,
1333                                     ScPrintRangeSaver* pOld, ScPrintRangeSaver* pNew ) :
1334     ScSimpleUndo( pShell ),
1335     nTab( nNewTab ),
1336     pOldRanges( pOld ),
1337     pNewRanges( pNew )
1338 {
1339 }
1340
1341 ScUndoPrintRange::~ScUndoPrintRange()
1342 {
1343     delete pOldRanges;
1344     delete pNewRanges;
1345 }
1346
1347 void ScUndoPrintRange::DoChange(sal_Bool bUndo)
1348 {
1349     ScDocument* pDoc = pDocShell->GetDocument();
1350     if (bUndo)
1351         pDoc->RestorePrintRanges( *pOldRanges );
1352     else
1353         pDoc->RestorePrintRanges( *pNewRanges );
1354
1355     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1356     if (pViewShell)
1357         pViewShell->SetTabNo( nTab );
1358
1359     ScPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab ).UpdatePages();
1360
1361     pDocShell->PostPaint( ScRange(0,0,nTab,MAXCOL,MAXROW,nTab), PAINT_GRID );
1362 }
1363
1364 void ScUndoPrintRange::Undo()
1365 {
1366     BeginUndo();
1367     DoChange( sal_True );
1368     EndUndo();
1369 }
1370
1371 void ScUndoPrintRange::Redo()
1372 {
1373     BeginRedo();
1374     DoChange( false );
1375     EndRedo();
1376 }
1377
1378 void ScUndoPrintRange::Repeat(SfxRepeatTarget& /* rTarget */)
1379 {
1380     // makes no sense
1381 }
1382
1383 bool ScUndoPrintRange::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1384 {
1385     return false;       // makes no sense
1386 }
1387
1388 OUString ScUndoPrintRange::GetComment() const
1389 {
1390     return ScGlobal::GetRscString( STR_UNDO_PRINTRANGES );
1391 }
1392
1393 ScUndoScenarioFlags::ScUndoScenarioFlags( ScDocShell* pNewDocShell, SCTAB nT,
1394                     const OUString& rON, const OUString& rNN, const OUString& rOC, const OUString& rNC,
1395                     const Color& rOCol, const Color& rNCol, sal_uInt16 nOF, sal_uInt16 nNF ) :
1396     ScSimpleUndo( pNewDocShell ),
1397     nTab        ( nT ),
1398     aOldName    ( rON ),
1399     aNewName    ( rNN ),
1400     aOldComment ( rOC ),
1401     aNewComment ( rNC ),
1402     aOldColor   ( rOCol ),
1403     aNewColor   ( rNCol ),
1404     nOldFlags   ( nOF ),
1405     nNewFlags   ( nNF )
1406 {
1407 }
1408
1409 ScUndoScenarioFlags::~ScUndoScenarioFlags()
1410 {
1411 }
1412
1413 OUString ScUndoScenarioFlags::GetComment() const
1414 {
1415     return ScGlobal::GetRscString( STR_UNDO_EDITSCENARIO );
1416 }
1417
1418 void ScUndoScenarioFlags::Undo()
1419 {
1420     ScDocument* pDoc = pDocShell->GetDocument();
1421
1422     pDoc->RenameTab( nTab, aOldName );
1423     pDoc->SetScenarioData( nTab, aOldComment, aOldColor, nOldFlags );
1424
1425     pDocShell->PostPaintGridAll();
1426     // The sheet name might be used in a formula ...
1427     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1428     if (pViewShell)
1429         pViewShell->UpdateInputHandler();
1430
1431     if ( aOldName != aNewName )
1432         SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1433 }
1434
1435 void ScUndoScenarioFlags::Redo()
1436 {
1437     ScDocument* pDoc = pDocShell->GetDocument();
1438
1439     pDoc->RenameTab( nTab, aNewName );
1440     pDoc->SetScenarioData( nTab, aNewComment, aNewColor, nNewFlags );
1441
1442     pDocShell->PostPaintGridAll();
1443     // The sheet name might be used in a formula ...
1444     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1445     if (pViewShell)
1446         pViewShell->UpdateInputHandler();
1447
1448     if ( aOldName != aNewName )
1449         SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1450 }
1451
1452 void ScUndoScenarioFlags::Repeat(SfxRepeatTarget& /* rTarget */)
1453 {
1454     //  Repeat makes no sense
1455 }
1456
1457 bool ScUndoScenarioFlags::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1458 {
1459     return false;
1460 }
1461
1462 //      (move to different file?)
1463 ScUndoRenameObject::ScUndoRenameObject( ScDocShell* pNewDocShell, const OUString& rPN,
1464                                         const OUString& rON, const OUString& rNN ) :
1465     ScSimpleUndo( pNewDocShell ),
1466     aPersistName( rPN ),
1467     aOldName    ( rON ),
1468     aNewName    ( rNN )
1469 {
1470 }
1471
1472 ScUndoRenameObject::~ScUndoRenameObject()
1473 {
1474 }
1475
1476 OUString ScUndoRenameObject::GetComment() const
1477 {
1478     //  string resource shared with title for dialog
1479     return OUString( ScResId(SCSTR_RENAMEOBJECT) );
1480 }
1481
1482 SdrObject* ScUndoRenameObject::GetObject()
1483 {
1484     ScDocument* pDoc = pDocShell->GetDocument();
1485     ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
1486     if ( pDrawLayer )
1487     {
1488         sal_uInt16 nCount = pDrawLayer->GetPageCount();
1489         for (sal_uInt16 nTab=0; nTab<nCount; nTab++)
1490         {
1491             SdrPage* pPage = pDrawLayer->GetPage(nTab);
1492             OSL_ENSURE(pPage,"Page ?");
1493
1494             SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
1495             SdrObject* pObject = aIter.Next();
1496             while (pObject)
1497             {
1498                 if ( pObject->GetObjIdentifier() == OBJ_OLE2 &&
1499                         ((SdrOle2Obj*)pObject)->GetPersistName() == aPersistName )
1500                 {
1501                     return pObject;
1502                 }
1503
1504                 pObject = aIter.Next();
1505             }
1506         }
1507     }
1508     OSL_FAIL("Object not found");
1509     return NULL;
1510 }
1511
1512 void ScUndoRenameObject::Undo()
1513 {
1514     BeginUndo();
1515     SdrObject* pObj = GetObject();
1516     if ( pObj )
1517         pObj->SetName( aOldName );
1518     EndUndo();
1519 }
1520
1521 void ScUndoRenameObject::Redo()
1522 {
1523     BeginRedo();
1524     SdrObject* pObj = GetObject();
1525     if ( pObj )
1526         pObj->SetName( aNewName );
1527     EndRedo();
1528 }
1529
1530 void ScUndoRenameObject::Repeat(SfxRepeatTarget& /* rTarget */)
1531 {
1532 }
1533
1534 bool ScUndoRenameObject::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1535 {
1536     return false;
1537 }
1538
1539 ScUndoLayoutRTL::ScUndoLayoutRTL( ScDocShell* pShell, SCTAB nNewTab, sal_Bool bNewRTL ) :
1540     ScSimpleUndo( pShell ),
1541     nTab( nNewTab ),
1542     bRTL( bNewRTL )
1543 {
1544 }
1545
1546 ScUndoLayoutRTL::~ScUndoLayoutRTL()
1547 {
1548 }
1549
1550 void ScUndoLayoutRTL::DoChange( sal_Bool bNew )
1551 {
1552     pDocShell->SetInUndo( sal_True );
1553
1554     ScDocument* pDoc = pDocShell->GetDocument();
1555     pDoc->SetLayoutRTL( nTab, bNew );
1556
1557     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1558     if (pViewShell)
1559         pViewShell->SetTabNo(nTab,sal_True);
1560
1561     pDocShell->SetDocumentModified();
1562
1563     pDocShell->SetInUndo( false );
1564 }
1565
1566 void ScUndoLayoutRTL::Undo()
1567 {
1568     DoChange(!bRTL);
1569 }
1570
1571 void ScUndoLayoutRTL::Redo()
1572 {
1573     DoChange(bRTL);
1574 }
1575
1576 void ScUndoLayoutRTL::Repeat(SfxRepeatTarget& rTarget)
1577 {
1578     if (rTarget.ISA(ScTabViewTarget))
1579         ((ScTabViewTarget&)rTarget).GetViewShell()->GetViewData()->GetDispatcher().
1580             Execute( FID_TAB_RTL, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD);
1581 }
1582
1583 bool ScUndoLayoutRTL::CanRepeat(SfxRepeatTarget& rTarget) const
1584 {
1585     return rTarget.ISA(ScTabViewTarget);
1586 }
1587
1588 OUString ScUndoLayoutRTL::GetComment() const
1589 {
1590     return ScGlobal::GetRscString( STR_UNDO_TAB_RTL );
1591 }
1592
1593 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */