sc/source/ui/undo/undoblk3.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: undoblk3.cxx,v $
  10  * $Revision: 1.22.128.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 // INCLUDE -------------------------------------------------------------------
  35
  36 #include "scitems.hxx"
  37 #include <svx/algitem.hxx>
  38 #include <svx/boxitem.hxx>
  39 #include <svx/srchitem.hxx>
  40 #include <svx/linkmgr.hxx>
  41 #include <sfx2/bindings.hxx>
  42 #include <vcl/virdev.hxx>
  43 #include <sfx2/app.hxx>
  44
  45 #include "undoblk.hxx"
  46 #include "sc.hrc"
  47 #include "globstr.hrc"
  48 #include "global.hxx"
  49 #include "rangenam.hxx"
  50 #include "arealink.hxx"
  51 #include "patattr.hxx"
  52 #include "target.hxx"
  53 #include "document.hxx"
  54 #include "docpool.hxx"
  55 #include "table.hxx"
  56 #include "docsh.hxx"
  57 #include "tabvwsh.hxx"
  58 #include "undoolk.hxx"
  59 #include "undoutil.hxx"
  60 #include "chgtrack.hxx"
  61 #include "dociter.hxx"
  62 #include "cell.hxx"
  63 #include "paramisc.hxx"
  64 #include "postit.hxx"
  65 #include "docuno.hxx"
  66
  67 // STATIC DATA ---------------------------------------------------------------
  68
  69 TYPEINIT1(ScUndoDeleteContents,         SfxUndoAction);
  70 TYPEINIT1(ScUndoFillTable,                      SfxUndoAction);
  71 TYPEINIT1(ScUndoSelectionAttr,          SfxUndoAction);
  72 TYPEINIT1(ScUndoAutoFill,                       SfxUndoAction);
  73 TYPEINIT1(ScUndoMerge,                          SfxUndoAction);
  74 TYPEINIT1(ScUndoAutoFormat,             SfxUndoAction);
  75 TYPEINIT1(ScUndoReplace,                        SfxUndoAction);
  76 TYPEINIT1(ScUndoTabOp,                          SfxUndoAction);
  77 TYPEINIT1(ScUndoConversion,         SfxUndoAction);
  78 TYPEINIT1(ScUndoRefConversion,      SfxUndoAction);
  79 TYPEINIT1(ScUndoRefreshLink,            SfxUndoAction);
  80 TYPEINIT1(ScUndoInsertAreaLink,         SfxUndoAction);
  81 TYPEINIT1(ScUndoRemoveAreaLink,         SfxUndoAction);
  82 TYPEINIT1(ScUndoUpdateAreaLink,         SfxUndoAction);
  83
  84
  85 // To Do:
  86 /*A*/   // SetOptimalHeight auf Dokument, wenn keine View
  87
  88
  89 //============================================================================
  90 //      class ScUndoDeleteContents
  91 //
  92 //      Inhalte loeschen
  93
  94 //----------------------------------------------------------------------------
  95
  96 ScUndoDeleteContents::ScUndoDeleteContents(
  97                 ScDocShell* pNewDocShell,
  98                 const ScMarkData& rMark, const ScRange& rRange,
  99                 ScDocument* pNewUndoDoc, BOOL bNewMulti,
 100                 USHORT nNewFlags, BOOL bObjects )
 101         //
 102     :   ScSimpleUndo( pNewDocShell ),
 103         //
 104         aRange          ( rRange ),
 105         aMarkData       ( rMark ),
 106         pUndoDoc        ( pNewUndoDoc ),
 107         pDrawUndo       ( NULL ),
 108         nFlags          ( nNewFlags ),
 109         bMulti          ( bNewMulti )   // ueberliquid
 110 {
 111     if (bObjects)
 112         pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
 113
 114     if ( !(aMarkData.IsMarked() || aMarkData.IsMultiMarked()) )         // keine Zelle markiert:
 115         aMarkData.SetMarkArea( aRange );                                                        // Zelle unter Cursor markieren
 116
 117     SetChangeTrack();
 118 }
 119
 120
 121 //----------------------------------------------------------------------------
 122
 123 __EXPORT ScUndoDeleteContents::~ScUndoDeleteContents()
 124 {
 125     delete pUndoDoc;
 126     DeleteSdrUndoAction( pDrawUndo );
 127 }
 128
 129
 130 //----------------------------------------------------------------------------
 131
 132 String __EXPORT ScUndoDeleteContents::GetComment() const
 133 {
 134     return ScGlobal::GetRscString( STR_UNDO_DELETECONTENTS );    // "Loeschen"
 135 }
 136
 137
 138 void ScUndoDeleteContents::SetChangeTrack()
 139 {
 140     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 141     if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
 142         pChangeTrack->AppendContentRange( aRange, pUndoDoc,
 143             nStartChangeAction, nEndChangeAction );
 144     else
 145         nStartChangeAction = nEndChangeAction = 0;
 146 }
 147
 148
 149 //----------------------------------------------------------------------------
 150
 151 void ScUndoDeleteContents::DoChange( const BOOL bUndo )
 152 {
 153     ScDocument* pDoc = pDocShell->GetDocument();
 154     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 155
 156     if (pViewShell)
 157         pViewShell->SetMarkData( aMarkData );
 158
 159     USHORT nExtFlags = 0;
 160
 161     if (bUndo)  // nur Undo
 162     {
 163         USHORT nUndoFlags = IDF_NONE;           //      entweder alle oder keine Inhalte kopieren
 164         if (nFlags & IDF_CONTENTS)                      //      (es sind nur die richtigen ins UndoDoc kopiert worden)
 165             nUndoFlags |= IDF_CONTENTS;
 166         if (nFlags & IDF_ATTRIB)
 167             nUndoFlags |= IDF_ATTRIB;
 168         if (nFlags & IDF_EDITATTR)                      // Edit-Engine-Attribute
 169             nUndoFlags |= IDF_STRING;           // -> Zellen werden geaendert
 170         // do not create clones of note captions, they will be restored via drawing undo
 171         nUndoFlags |= IDF_NOCAPTIONS;
 172
 173         ScRange aCopyRange = aRange;
 174         SCTAB nTabCount = pDoc->GetTableCount();
 175         aCopyRange.aStart.SetTab(0);
 176         aCopyRange.aEnd.SetTab(nTabCount-1);
 177
 178         pUndoDoc->CopyToDocument( aCopyRange, nUndoFlags, bMulti, pDoc, &aMarkData );
 179
 180         DoSdrUndoAction( pDrawUndo, pDoc );
 181
 182         ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 183         if ( pChangeTrack )
 184             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 185
 186         pDocShell->UpdatePaintExt( nExtFlags, aRange );                         // content after the change
 187     }
 188     else                // nur Redo
 189     {
 190         pDocShell->UpdatePaintExt( nExtFlags, aRange );                         // content before the change
 191
 192         aMarkData.MarkToMulti();
 193         RedoSdrUndoAction( pDrawUndo );
 194         // do not delete objects and note captions, they have been removed via drawing undo
 195         USHORT nRedoFlags = (nFlags & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
 196         pDoc->DeleteSelection( nRedoFlags, aMarkData );
 197         aMarkData.MarkToSimple();
 198
 199         SetChangeTrack();
 200     }
 201
 202     if ( !( (pViewShell) && pViewShell->AdjustRowHeight(
 203                                 aRange.aStart.Row(), aRange.aEnd.Row() ) ) )
 204 /*A*/   pDocShell->PostPaint( aRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );
 205
 206     pDocShell->PostDataChanged();
 207     if (pViewShell)
 208         pViewShell->CellContentChanged();
 209
 210     ShowTable( aRange );
 211 }
 212
 213
 214 //----------------------------------------------------------------------------
 215
 216 void __EXPORT ScUndoDeleteContents::Undo()
 217 {
 218     BeginUndo();
 219     DoChange( TRUE );
 220     EndUndo();
 221
 222     // #i97876# Spreadsheet data changes are not notified
 223     ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
 224     if ( pModelObj && pModelObj->HasChangesListeners() )
 225     {
 226         ScRangeList aChangeRanges;
 227         aChangeRanges.Append( aRange );
 228         pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
 229     }
 230 }
 231
 232
 233 //----------------------------------------------------------------------------
 234
 235 void __EXPORT ScUndoDeleteContents::Redo()
 236 {
 237     BeginRedo();
 238     DoChange( FALSE );
 239     EndRedo();
 240
 241     // #i97876# Spreadsheet data changes are not notified
 242     ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
 243     if ( pModelObj && pModelObj->HasChangesListeners() )
 244     {
 245         ScRangeList aChangeRanges;
 246         aChangeRanges.Append( aRange );
 247         pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
 248     }
 249 }
 250
 251
 252 //----------------------------------------------------------------------------
 253
 254 void __EXPORT ScUndoDeleteContents::Repeat(SfxRepeatTarget& rTarget)
 255 {
 256     if (rTarget.ISA(ScTabViewTarget))
 257         ((ScTabViewTarget&)rTarget).GetViewShell()->DeleteContents( nFlags, TRUE );
 258 }
 259
 260
 261 //----------------------------------------------------------------------------
 262
 263 BOOL __EXPORT ScUndoDeleteContents::CanRepeat(SfxRepeatTarget& rTarget) const
 264 {
 265     return (rTarget.ISA(ScTabViewTarget));
 266 }
 267
 268
 269 //============================================================================
 270 //      class ScUndoFillTable
 271 //
 272 //      Tabellen ausfuellen
 273 //      (Bearbeiten|Ausfuellen|...)
 274
 275 //----------------------------------------------------------------------------
 276
 277 ScUndoFillTable::ScUndoFillTable( ScDocShell* pNewDocShell,
 278                 const ScMarkData& rMark,
 279                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 280                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
 281                 ScDocument* pNewUndoDoc, BOOL bNewMulti, SCTAB nSrc,
 282                 USHORT nFlg, USHORT nFunc, BOOL bSkip, BOOL bLink )
 283         //
 284     :   ScSimpleUndo( pNewDocShell ),
 285         //
 286         aRange          ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
 287         aMarkData       ( rMark ),
 288         pUndoDoc        ( pNewUndoDoc ),
 289         nFlags          ( nFlg ),
 290         nFunction       ( nFunc ),
 291         nSrcTab         ( nSrc ),
 292         bMulti          ( bNewMulti ),
 293         bSkipEmpty      ( bSkip ),
 294         bAsLink         ( bLink )
 295 {
 296     SetChangeTrack();
 297 }
 298
 299
 300 //----------------------------------------------------------------------------
 301
 302 __EXPORT ScUndoFillTable::~ScUndoFillTable()
 303 {
 304     delete pUndoDoc;
 305 }
 306
 307
 308 //----------------------------------------------------------------------------
 309
 310 String __EXPORT ScUndoFillTable::GetComment() const
 311 {
 312     return ScGlobal::GetRscString( STR_FILL_TAB );
 313 }
 314
 315
 316 void ScUndoFillTable::SetChangeTrack()
 317 {
 318     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 319     if ( pChangeTrack )
 320     {
 321         SCTAB nTabCount = pDocShell->GetDocument()->GetTableCount();
 322         ScRange aWorkRange(aRange);
 323         nStartChangeAction = 0;
 324         ULONG nTmpAction;
 325         for ( SCTAB i = 0; i < nTabCount; i++ )
 326         {
 327             if (i != nSrcTab && aMarkData.GetTableSelect(i))
 328             {
 329                 aWorkRange.aStart.SetTab(i);
 330                 aWorkRange.aEnd.SetTab(i);
 331                 pChangeTrack->AppendContentRange( aWorkRange, pUndoDoc,
 332                     nTmpAction, nEndChangeAction );
 333                 if ( !nStartChangeAction )
 334                     nStartChangeAction = nTmpAction;
 335             }
 336         }
 337     }
 338     else
 339         nStartChangeAction = nEndChangeAction = 0;
 340 }
 341
 342
 343 //----------------------------------------------------------------------------
 344
 345 void ScUndoFillTable::DoChange( const BOOL bUndo )
 346 {
 347     ScDocument* pDoc = pDocShell->GetDocument();
 348     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 349
 350     if (pViewShell)
 351         pViewShell->SetMarkData( aMarkData );
 352
 353     if (bUndo)  // nur Undo
 354     {
 355         SCTAB nTabCount = pDoc->GetTableCount();
 356         ScRange aWorkRange(aRange);
 357         for ( SCTAB i = 0; i < nTabCount; i++ )
 358             if (i != nSrcTab && aMarkData.GetTableSelect(i))
 359             {
 360                 aWorkRange.aStart.SetTab(i);
 361                 aWorkRange.aEnd.SetTab(i);
 362                 if (bMulti)
 363                     pDoc->DeleteSelectionTab( i, IDF_ALL, aMarkData );
 364                 else
 365                     pDoc->DeleteAreaTab( aWorkRange, IDF_ALL );
 366                 pUndoDoc->CopyToDocument( aWorkRange, IDF_ALL, bMulti, pDoc, &aMarkData );
 367             }
 368
 369         ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 370         if ( pChangeTrack )
 371             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 372     }
 373     else                // nur Redo
 374     {
 375         aMarkData.MarkToMulti();
 376         pDoc->FillTabMarked( nSrcTab, aMarkData, nFlags, nFunction, bSkipEmpty, bAsLink );
 377         aMarkData.MarkToSimple();
 378         SetChangeTrack();
 379     }
 380
 381     pDocShell->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_EXTRAS);
 382     pDocShell->PostDataChanged();
 383
 384     //  CellContentChanged kommt mit der Markierung
 385
 386     if (pViewShell)
 387     {
 388         SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
 389         if ( !aMarkData.GetTableSelect(nTab) )
 390             pViewShell->SetTabNo( nSrcTab );
 391
 392         pViewShell->DoneBlockMode();    // gibt sonst Probleme, weil Markierung auf falscher Tabelle
 393     }
 394 }
 395
 396
 397 //----------------------------------------------------------------------------
 398
 399 void __EXPORT ScUndoFillTable::Undo()
 400 {
 401     BeginUndo();
 402     DoChange( TRUE );
 403     EndUndo();
 404 }
 405
 406
 407 //----------------------------------------------------------------------------
 408
 409 void __EXPORT ScUndoFillTable::Redo()
 410 {
 411     BeginRedo();
 412     DoChange( FALSE );
 413     EndRedo();
 414 }
 415
 416
 417 //----------------------------------------------------------------------------
 418
 419 void __EXPORT ScUndoFillTable::Repeat(SfxRepeatTarget& rTarget)
 420 {
 421     if (rTarget.ISA(ScTabViewTarget))
 422         ((ScTabViewTarget&)rTarget).GetViewShell()->FillTab( nFlags, nFunction, bSkipEmpty, bAsLink );
 423 }
 424
 425
 426 //----------------------------------------------------------------------------
 427
 428 BOOL __EXPORT ScUndoFillTable::CanRepeat(SfxRepeatTarget& rTarget) const
 429 {
 430     return (rTarget.ISA(ScTabViewTarget));
 431 }
 432
 433
 434 //============================================================================
 435 //      class ScUndoSelectionAttr
 436 //
 437 //      Zellformat aendern
 438
 439 //----------------------------------------------------------------------------
 440
 441 ScUndoSelectionAttr::ScUndoSelectionAttr( ScDocShell* pNewDocShell,
 442                 const ScMarkData& rMark,
 443                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 444                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
 445                 ScDocument* pNewUndoDoc, BOOL bNewMulti,
 446                 const ScPatternAttr* pNewApply,
 447                 const SvxBoxItem* pNewOuter, const SvxBoxInfoItem* pNewInner )
 448         //
 449     :   ScSimpleUndo( pNewDocShell ),
 450         //
 451         aMarkData       ( rMark ),
 452         aRange          ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
 453         pUndoDoc        ( pNewUndoDoc ),
 454         bMulti          ( bNewMulti )
 455 {
 456     ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
 457     pApplyPattern = (ScPatternAttr*) &pPool->Put( *pNewApply );
 458     pLineOuter = pNewOuter ? (SvxBoxItem*) &pPool->Put( *pNewOuter ) : NULL;
 459     pLineInner = pNewInner ? (SvxBoxInfoItem*) &pPool->Put( *pNewInner ) : NULL;
 460 }
 461
 462
 463 //----------------------------------------------------------------------------
 464
 465 __EXPORT ScUndoSelectionAttr::~ScUndoSelectionAttr()
 466 {
 467     ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
 468     pPool->Remove(*pApplyPattern);
 469     if (pLineOuter)
 470         pPool->Remove(*pLineOuter);
 471     if (pLineInner)
 472         pPool->Remove(*pLineInner);
 473
 474     delete pUndoDoc;
 475 }
 476
 477
 478 //----------------------------------------------------------------------------
 479
 480 String __EXPORT ScUndoSelectionAttr::GetComment() const
 481 {
 482     //"Attribute" "/Linien"
 483     return ScGlobal::GetRscString( pLineOuter ? STR_UNDO_SELATTRLINES : STR_UNDO_SELATTR );
 484 }
 485
 486 //----------------------------------------------------------------------------
 487
 488 ScEditDataArray* ScUndoSelectionAttr::GetDataArray()
 489 {
 490     return &aDataArray;
 491 }
 492
 493 //----------------------------------------------------------------------------
 494
 495 void ScUndoSelectionAttr::DoChange( const BOOL bUndo )
 496 {
 497     ScDocument* pDoc = pDocShell->GetDocument();
 498     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 499
 500     if (pViewShell)
 501         pViewShell->SetMarkData( aMarkData );
 502
 503     ScRange aEffRange( aRange );
 504     if ( pDoc->HasAttrib( aEffRange, HASATTR_MERGED ) )                 // zusammengefasste Zellen?
 505         pDoc->ExtendMerge( aEffRange );
 506
 507     USHORT nExtFlags = 0;
 508     pDocShell->UpdatePaintExt( nExtFlags, aEffRange );
 509
 510     ChangeEditData(bUndo);
 511
 512     if (bUndo)  // nur bei Undo
 513     {
 514         ScRange aCopyRange = aRange;
 515         SCTAB nTabCount = pDoc->GetTableCount();
 516         aCopyRange.aStart.SetTab(0);
 517         aCopyRange.aEnd.SetTab(nTabCount-1);
 518         pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pDoc, &aMarkData );
 519     }
 520     else                // nur bei Redo
 521     {
 522         aMarkData.MarkToMulti();
 523         pDoc->ApplySelectionPattern( *pApplyPattern, aMarkData );
 524         aMarkData.MarkToSimple();
 525
 526         if (pLineOuter)
 527             pDoc->ApplySelectionFrame( aMarkData, pLineOuter, pLineInner );
 528     }
 529
 530     if ( !( (pViewShell) && pViewShell->AdjustBlockHeight() ) )
 531 /*A*/   pDocShell->PostPaint( aEffRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );
 532
 533     ShowTable( aRange );
 534 }
 535
 536 void ScUndoSelectionAttr::ChangeEditData( const bool bUndo )
 537 {
 538     ScDocument* pDoc = pDocShell->GetDocument();
 539     for (const ScEditDataArray::Item* pItem = aDataArray.First(); pItem; pItem = aDataArray.Next())
 540     {
 541         ScBaseCell* pCell;
 542         pDoc->GetCell(pItem->GetCol(), pItem->GetRow(), pItem->GetTab(), pCell);
 543         if (!pCell || pCell->GetCellType() != CELLTYPE_EDIT)
 544             continue;
 545
 546         ScEditCell* pEditCell = static_cast<ScEditCell*>(pCell);
 547         if (bUndo)
 548             pEditCell->SetData(pItem->GetOldData(), NULL);
 549         else
 550             pEditCell->SetData(pItem->GetNewData(), NULL);
 551     }
 552 }
 553
 554
 555 //----------------------------------------------------------------------------
 556
 557 void __EXPORT ScUndoSelectionAttr::Undo()
 558 {
 559     BeginUndo();
 560     DoChange( TRUE );
 561     EndUndo();
 562 }
 563
 564
 565 //----------------------------------------------------------------------------
 566
 567 void __EXPORT ScUndoSelectionAttr::Redo()
 568 {
 569     BeginRedo();
 570     DoChange( FALSE );
 571     EndRedo();
 572 }
 573
 574
 575 //----------------------------------------------------------------------------
 576
 577 void __EXPORT ScUndoSelectionAttr::Repeat(SfxRepeatTarget& rTarget)
 578 {
 579     if (rTarget.ISA(ScTabViewTarget))
 580     {
 581         ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
 582         if (pLineOuter)
 583             rViewShell.ApplyPatternLines( *pApplyPattern, pLineOuter, pLineInner, TRUE );
 584         else
 585             rViewShell.ApplySelectionPattern( *pApplyPattern, TRUE );
 586     }
 587 }
 588
 589
 590 //----------------------------------------------------------------------------
 591
 592 BOOL __EXPORT ScUndoSelectionAttr::CanRepeat(SfxRepeatTarget& rTarget) const
 593 {
 594     return (rTarget.ISA(ScTabViewTarget));
 595 }
 596
 597
 598 //============================================================================
 599 //      class ScUndoAutoFill
 600 //
 601 //      Auto-Fill (nur einfache Bloecke)
 602
 603 //----------------------------------------------------------------------------
 604
 605 ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,
 606                 const ScRange& rRange, const ScRange& rSourceArea,
 607                 ScDocument* pNewUndoDoc, const ScMarkData& rMark,
 608                 FillDir eNewFillDir, FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,
 609                 double fNewStartValue, double fNewStepValue, double fNewMaxValue,
 610                 USHORT nMaxShIndex )
 611         //
 612     :   ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
 613         //
 614         aSource                 ( rSourceArea ),
 615         aMarkData               ( rMark ),
 616         pUndoDoc                ( pNewUndoDoc ),
 617         eFillDir                ( eNewFillDir ),
 618         eFillCmd                ( eNewFillCmd ),
 619         eFillDateCmd    ( eNewFillDateCmd ),
 620         fStartValue             ( fNewStartValue ),
 621         fStepValue              ( fNewStepValue ),
 622         fMaxValue               ( fNewMaxValue ),
 623         nMaxSharedIndex ( nMaxShIndex)
 624 {
 625     SetChangeTrack();
 626 }
 627
 628
 629 //----------------------------------------------------------------------------
 630
 631 __EXPORT ScUndoAutoFill::~ScUndoAutoFill()
 632 {
 633     pDocShell->GetDocument()->EraseNonUsedSharedNames(nMaxSharedIndex);
 634     delete pUndoDoc;
 635 }
 636
 637
 638 //----------------------------------------------------------------------------
 639
 640 String __EXPORT ScUndoAutoFill::GetComment() const
 641 {
 642     return ScGlobal::GetRscString( STR_UNDO_AUTOFILL ); //"Ausfuellen"
 643 }
 644
 645
 646 void ScUndoAutoFill::SetChangeTrack()
 647 {
 648     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 649     if ( pChangeTrack )
 650         pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
 651             nStartChangeAction, nEndChangeAction );
 652     else
 653         nStartChangeAction = nEndChangeAction = 0;
 654 }
 655
 656
 657 //----------------------------------------------------------------------------
 658
 659 void __EXPORT ScUndoAutoFill::Undo()
 660 {
 661     BeginUndo();
 662
 663     ScDocument* pDoc = pDocShell->GetDocument();
 664
 665     SCTAB nTabCount = pDoc->GetTableCount();
 666     for (SCTAB nTab=0; nTab<nTabCount; nTab++)
 667     {
 668         if (aMarkData.GetTableSelect(nTab))
 669         {
 670             ScRange aWorkRange = aBlockRange;
 671             aWorkRange.aStart.SetTab(nTab);
 672             aWorkRange.aEnd.SetTab(nTab);
 673
 674             USHORT nExtFlags = 0;
 675             pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
 676             pDoc->DeleteAreaTab( aWorkRange, IDF_AUTOFILL );
 677             pUndoDoc->CopyToDocument( aWorkRange, IDF_AUTOFILL, FALSE, pDoc );
 678
 679             pDoc->ExtendMerge( aWorkRange, TRUE );
 680             pDocShell->PostPaint( aWorkRange, PAINT_GRID, nExtFlags );
 681         }
 682     }
 683     pDocShell->PostDataChanged();
 684     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 685     if (pViewShell)
 686         pViewShell->CellContentChanged();
 687
 688 // Shared-Names loeschen
 689 // Falls Undo ins Dokument gespeichert
 690 // => automatisches Loeschen am Ende
 691 // umarbeiten!!
 692
 693     String aName = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("___SC_"));
 694     aName += String::CreateFromInt32(nMaxSharedIndex);
 695     aName += '_';
 696     ScRangeName* pRangeName = pDoc->GetRangeName();
 697     BOOL bHasFound = FALSE;
 698     for (USHORT i = 0; i < pRangeName->GetCount(); i++)
 699     {
 700         ScRangeData* pRangeData = (*pRangeName)[i];
 701         if (pRangeData)
 702         {
 703             String aRName;
 704             pRangeData->GetName(aRName);
 705             if (aRName.Search(aName) != STRING_NOTFOUND)
 706             {
 707                 pRangeName->AtFree(i);
 708                 bHasFound = TRUE;
 709             }
 710         }
 711     }
 712     if (bHasFound)
 713         pRangeName->SetSharedMaxIndex(pRangeName->GetSharedMaxIndex()-1);
 714
 715     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 716     if ( pChangeTrack )
 717         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 718
 719     EndUndo();
 720 }
 721
 722
 723 //----------------------------------------------------------------------------
 724
 725 void __EXPORT ScUndoAutoFill::Redo()
 726 {
 727     BeginRedo();
 728
 729 //!     Tabellen selektieren
 730
 731     SCCOLROW nCount = 0;
 732     switch (eFillDir)
 733     {
 734         case FILL_TO_BOTTOM:
 735             nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();
 736             break;
 737         case FILL_TO_RIGHT:
 738             nCount = aBlockRange.aEnd.Col() - aSource.aEnd.Col();
 739             break;
 740         case FILL_TO_TOP:
 741             nCount = aSource.aStart.Row() - aBlockRange.aStart.Row();
 742             break;
 743         case FILL_TO_LEFT:
 744             nCount = aSource.aStart.Col() - aBlockRange.aStart.Col();
 745             break;
 746     }
 747
 748     ScDocument* pDoc = pDocShell->GetDocument();
 749     if ( fStartValue != MAXDOUBLE )
 750     {
 751         SCCOL nValX = (eFillDir == FILL_TO_LEFT) ? aSource.aEnd.Col() : aSource.aStart.Col();
 752         SCROW nValY = (eFillDir == FILL_TO_TOP ) ? aSource.aEnd.Row() : aSource.aStart.Row();
 753         SCTAB nTab = aSource.aStart.Tab();
 754         pDoc->SetValue( nValX, nValY, nTab, fStartValue );
 755     }
 756     pDoc->Fill( aSource.aStart.Col(), aSource.aStart.Row(),
 757                 aSource.aEnd.Col(),   aSource.aEnd.Row(),
 758                 aMarkData, nCount,
 759                 eFillDir, eFillCmd, eFillDateCmd,
 760                 fStepValue, fMaxValue );
 761
 762     SetChangeTrack();
 763
 764     pDocShell->PostPaint( aBlockRange, PAINT_GRID );
 765     pDocShell->PostDataChanged();
 766     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 767     if (pViewShell)
 768         pViewShell->CellContentChanged();
 769
 770     EndRedo();
 771 }
 772
 773
 774 //----------------------------------------------------------------------------
 775
 776 void __EXPORT ScUndoAutoFill::Repeat(SfxRepeatTarget& rTarget)
 777 {
 778     if (rTarget.ISA(ScTabViewTarget))
 779     {
 780         ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
 781         if (eFillCmd==FILL_SIMPLE)
 782             rViewShell.FillSimple( eFillDir, TRUE );
 783         else
 784             rViewShell.FillSeries( eFillDir, eFillCmd, eFillDateCmd,
 785                                    fStartValue, fStepValue, fMaxValue, TRUE );
 786     }
 787 }
 788
 789
 790 //----------------------------------------------------------------------------
 791
 792 BOOL __EXPORT ScUndoAutoFill::CanRepeat(SfxRepeatTarget& rTarget) const
 793 {
 794     return (rTarget.ISA(ScTabViewTarget));
 795 }
 796
 797
 798 //============================================================================
 799 //      class ScUndoMerge
 800 //
 801 //      Zellen zusammenfassen / Zusammenfassung aufheben
 802
 803 //----------------------------------------------------------------------------
 804
 805 ScUndoMerge::ScUndoMerge( ScDocShell* pNewDocShell, const ScCellMergeOption& rOption,
 806                           bool bMergeContents, ScDocument* pUndoDoc, SdrUndoAction* pDrawUndo )
 807         //
 808     :   ScSimpleUndo( pNewDocShell ),
 809         //
 810         maOption(rOption),
 811         mbMergeContents( bMergeContents ),
 812         mpUndoDoc( pUndoDoc ),
 813         mpDrawUndo( pDrawUndo )
 814 {
 815 }
 816
 817
 818 //----------------------------------------------------------------------------
 819
 820 ScUndoMerge::~ScUndoMerge()
 821 {
 822     delete mpUndoDoc;
 823     DeleteSdrUndoAction( mpDrawUndo );
 824 }
 825
 826
 827 //----------------------------------------------------------------------------
 828
 829 String ScUndoMerge::GetComment() const
 830 {
 831     return ScGlobal::GetRscString( STR_UNDO_MERGE );
 832 }
 833
 834
 835 //----------------------------------------------------------------------------
 836
 837 void ScUndoMerge::DoChange( bool bUndo ) const
 838 {
 839     using ::std::set;
 840
 841     if (maOption.maTabs.empty())
 842         // Nothing to do.
 843         return;
 844
 845     ScDocument* pDoc = pDocShell->GetDocument();
 846     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 847
 848     ScRange aCurRange = maOption.getSingleRange(pDocShell->GetCurTab());
 849     ScUndoUtil::MarkSimpleBlock(pDocShell, aCurRange);
 850
 851     for (set<SCTAB>::const_iterator itr = maOption.maTabs.begin(), itrEnd = maOption.maTabs.end();
 852           itr != itrEnd; ++itr)
 853     {
 854         SCTAB nTab = *itr;
 855         ScRange aRange = maOption.getSingleRange(nTab);
 856
 857         if (bUndo)
 858             // remove merge (contents are copied back below from undo document)
 859             pDoc->RemoveMerge( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab() );
 860         else
 861         {
 862             // repeat merge, but do not remove note captions (will be done by drawing redo below)
 863             pDoc->DoMerge( aRange.aStart.Tab(),
 864                            aRange.aStart.Col(), aRange.aStart.Row(),
 865                            aRange.aEnd.Col(),   aRange.aEnd.Row(), false );
 866
 867             if (maOption.mbCenter)
 868             {
 869                 pDoc->ApplyAttr( aRange.aStart.Col(), aRange.aStart.Row(),
 870                                  aRange.aStart.Tab(),
 871                                  SvxHorJustifyItem( SVX_HOR_JUSTIFY_CENTER, ATTR_HOR_JUSTIFY ) );
 872                 pDoc->ApplyAttr( aRange.aStart.Col(), aRange.aStart.Row(),
 873                                  aRange.aStart.Tab(),
 874                                  SvxVerJustifyItem( SVX_VER_JUSTIFY_CENTER, ATTR_VER_JUSTIFY ) );
 875             }
 876         }
 877
 878         // undo -> copy back deleted contents
 879         if (bUndo && mpUndoDoc)
 880         {
 881             pDoc->DeleteAreaTab( aRange, IDF_CONTENTS|IDF_NOCAPTIONS );
 882             mpUndoDoc->CopyToDocument( aRange, IDF_ALL|IDF_NOCAPTIONS, FALSE, pDoc );
 883         }
 884
 885         // redo -> merge contents again
 886         else if (!bUndo && mbMergeContents)
 887         {
 888             pDoc->DoMergeContents( aRange.aStart.Tab(),
 889                                    aRange.aStart.Col(), aRange.aStart.Row(),
 890                                    aRange.aEnd.Col(), aRange.aEnd.Row() );
 891         }
 892
 893         if (bUndo)
 894             DoSdrUndoAction( mpDrawUndo, pDoc );
 895         else
 896             RedoSdrUndoAction( mpDrawUndo );
 897
 898         bool bDidPaint = false;
 899         if ( pViewShell )
 900         {
 901             pViewShell->SetTabNo(nTab);
 902             bDidPaint = pViewShell->AdjustRowHeight(maOption.mnStartRow, maOption.mnEndRow);
 903         }
 904
 905         if (!bDidPaint)
 906             ScUndoUtil::PaintMore(pDocShell, aRange);
 907     }
 908
 909         ShowTable(aCurRange);
 910 }
 911
 912
 913 //----------------------------------------------------------------------------
 914
 915 void ScUndoMerge::Undo()
 916 {
 917     BeginUndo();
 918     DoChange( true );
 919     EndUndo();
 920 }
 921
 922
 923 //----------------------------------------------------------------------------
 924
 925 void ScUndoMerge::Redo()
 926 {
 927     BeginRedo();
 928     DoChange( false );
 929     EndRedo();
 930 }
 931
 932
 933 //----------------------------------------------------------------------------
 934
 935 void ScUndoMerge::Repeat(SfxRepeatTarget& rTarget)
 936 {
 937     if (rTarget.ISA(ScTabViewTarget))
 938     {
 939         ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
 940         BOOL bCont = FALSE;
 941         rViewShell.MergeCells( FALSE, bCont, TRUE );
 942     }
 943 }
 944
 945
 946 //----------------------------------------------------------------------------
 947
 948 BOOL ScUndoMerge::CanRepeat(SfxRepeatTarget& rTarget) const
 949 {
 950     return (rTarget.ISA(ScTabViewTarget));
 951 }
 952
 953
 954 //============================================================================
 955 //      class ScUndoAutoFormat
 956 //
 957 //              Auto-Format (nur einfache Bloecke)
 958
 959 //----------------------------------------------------------------------------
 960
 961 ScUndoAutoFormat::ScUndoAutoFormat( ScDocShell* pNewDocShell,
 962                         const ScRange& rRange, ScDocument* pNewUndoDoc,
 963                         const ScMarkData& rMark, BOOL bNewSize, USHORT nNewFormatNo )
 964         //
 965     :   ScBlockUndo( pNewDocShell, rRange, bNewSize ? SC_UNDO_MANUALHEIGHT : SC_UNDO_AUTOHEIGHT ),
 966         //
 967         pUndoDoc        ( pNewUndoDoc ),
 968         aMarkData       ( rMark ),
 969         bSize           ( bNewSize ),
 970         nFormatNo       ( nNewFormatNo )
 971 {
 972 }
 973
 974
 975 //----------------------------------------------------------------------------
 976
 977 __EXPORT ScUndoAutoFormat::~ScUndoAutoFormat()
 978 {
 979     delete pUndoDoc;
 980 }
 981
 982
 983 //----------------------------------------------------------------------------
 984
 985 String __EXPORT ScUndoAutoFormat::GetComment() const
 986 {
 987     return ScGlobal::GetRscString( STR_UNDO_AUTOFORMAT );       //"Auto-Format"
 988 }
 989
 990
 991 //----------------------------------------------------------------------------
 992
 993 void __EXPORT ScUndoAutoFormat::Undo()
 994 {
 995     BeginUndo();
 996
 997     ScDocument* pDoc = pDocShell->GetDocument();
 998
 999     // Attribute
1000 //      pDoc->DeleteAreaTab( aBlockRange, IDF_ATTRIB );
1001 //      pUndoDoc->CopyToDocument( aBlockRange, IDF_ATTRIB, FALSE, pDoc );
1002
1003     SCTAB nTabCount = pDoc->GetTableCount();
1004     pDoc->DeleteArea( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
1005                       aBlockRange.aEnd.Col(), aBlockRange.aEnd.Row(),
1006                       aMarkData, IDF_ATTRIB );
1007     ScRange aCopyRange = aBlockRange;
1008     aCopyRange.aStart.SetTab(0);
1009     aCopyRange.aEnd.SetTab(nTabCount-1);
1010     pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, FALSE, pDoc, &aMarkData );
1011
1012     // Zellhoehen und -breiten (IDF_NONE)
1013     if (bSize)
1014     {
1015         SCCOL nStartX = aBlockRange.aStart.Col();
1016         SCROW nStartY = aBlockRange.aStart.Row();
1017         SCTAB nStartZ = aBlockRange.aStart.Tab();
1018         SCCOL nEndX = aBlockRange.aEnd.Col();
1019         SCROW nEndY = aBlockRange.aEnd.Row();
1020         SCTAB nEndZ = aBlockRange.aEnd.Tab();
1021
1022         pUndoDoc->CopyToDocument( nStartX, 0, 0, nEndX, MAXROW, nTabCount-1,
1023                                     IDF_NONE, FALSE, pDoc, &aMarkData );
1024         pUndoDoc->CopyToDocument( 0, nStartY, 0, MAXCOL, nEndY, nTabCount-1,
1025                                     IDF_NONE, FALSE, pDoc, &aMarkData );
1026         pDocShell->PostPaint( 0, 0, nStartZ, MAXCOL, MAXROW, nEndZ,
1027                               PAINT_GRID | PAINT_LEFT | PAINT_TOP, SC_PF_LINES );
1028     }
1029     else
1030         pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES );
1031
1032     EndUndo();
1033 }
1034
1035
1036 //----------------------------------------------------------------------------
1037
1038 void __EXPORT ScUndoAutoFormat::Redo()
1039 {
1040     BeginRedo();
1041
1042     ScDocument* pDoc = pDocShell->GetDocument();
1043
1044     SCCOL nStartX = aBlockRange.aStart.Col();
1045     SCROW nStartY = aBlockRange.aStart.Row();
1046     SCTAB nStartZ = aBlockRange.aStart.Tab();
1047     SCCOL nEndX = aBlockRange.aEnd.Col();
1048     SCROW nEndY = aBlockRange.aEnd.Row();
1049     SCTAB nEndZ = aBlockRange.aEnd.Tab();
1050
1051     pDoc->AutoFormat( nStartX, nStartY, nEndX, nEndY, nFormatNo, aMarkData );
1052
1053     if (bSize)
1054     {
1055         VirtualDevice aVirtDev;
1056         Fraction aZoomX(1,1);
1057         Fraction aZoomY = aZoomX;
1058         double nPPTX,nPPTY;
1059         ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1060         if (pViewShell)
1061         {
1062             ScViewData* pData = pViewShell->GetViewData();
1063             nPPTX = pData->GetPPTX();
1064             nPPTY = pData->GetPPTY();
1065             aZoomX = pData->GetZoomX();
1066             aZoomY = pData->GetZoomY();
1067         }
1068         else
1069         {
1070             //  Zoom auf 100 lassen
1071             nPPTX = ScGlobal::nScreenPPTX;
1072             nPPTY = ScGlobal::nScreenPPTY;
1073         }
1074
1075         BOOL bFormula = FALSE;  //! merken
1076
1077         for (SCTAB nTab=nStartZ; nTab<=nEndZ; nTab++)
1078         {
1079             ScMarkData aDestMark;
1080             aDestMark.SelectOneTable( nTab );
1081             aDestMark.SetMarkArea( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
1082             aDestMark.MarkToMulti();
1083
1084             // wie SC_SIZE_VISOPT
1085             SCROW nLastRow = -1;
1086             for (SCROW nRow=nStartY; nRow<=nEndY; nRow++)
1087             {
1088                 BYTE nOld = pDoc->GetRowFlags(nRow,nTab);
1089                 bool bHidden = pDoc->RowHidden(nRow, nTab, nLastRow);
1090                                 if ( !bHidden && ( nOld & CR_MANUALSIZE ) )
1091                     pDoc->SetRowFlags( nRow, nTab, nOld & ~CR_MANUALSIZE );
1092             }
1093             pDoc->SetOptimalHeight( nStartY, nEndY, nTab, 0, &aVirtDev,
1094                                         nPPTX, nPPTY, aZoomX, aZoomY, FALSE );
1095
1096             SCCOL nLastCol = -1;
1097             for (SCCOL nCol=nStartX; nCol<=nEndX; nCol++)
1098                 if (!pDoc->ColHidden(nCol, nTab, nLastCol))
1099                 {
1100                     USHORT nThisSize = STD_EXTRA_WIDTH + pDoc->GetOptimalColWidth( nCol, nTab,
1101                                                 &aVirtDev, nPPTX, nPPTY, aZoomX, aZoomY, bFormula,
1102                                                 &aDestMark );
1103                     pDoc->SetColWidth( nCol, nTab, nThisSize );
1104                     pDoc->ShowCol( nCol, nTab, TRUE );
1105                 }
1106         }
1107
1108         pDocShell->PostPaint( 0,      0,      nStartZ,
1109                               MAXCOL, MAXROW, nEndZ,
1110                               PAINT_GRID | PAINT_LEFT | PAINT_TOP, SC_PF_LINES);
1111     }
1112     else
1113         pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES );
1114
1115     EndRedo();
1116 }
1117
1118
1119 //----------------------------------------------------------------------------
1120
1121 void __EXPORT ScUndoAutoFormat::Repeat(SfxRepeatTarget& rTarget)
1122 {
1123     if (rTarget.ISA(ScTabViewTarget))
1124         ((ScTabViewTarget&)rTarget).GetViewShell()->AutoFormat( nFormatNo, TRUE );
1125 }
1126
1127
1128 //----------------------------------------------------------------------------
1129
1130 BOOL __EXPORT ScUndoAutoFormat::CanRepeat(SfxRepeatTarget& rTarget) const
1131 {
1132     return (rTarget.ISA(ScTabViewTarget));
1133 }
1134
1135
1136 //============================================================================
1137 //      class ScUndoReplace
1138 //
1139 //              Ersetzen
1140
1141 //----------------------------------------------------------------------------
1142
1143 ScUndoReplace::ScUndoReplace( ScDocShell* pNewDocShell, const ScMarkData& rMark,
1144                                     SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
1145                                     const String& rNewUndoStr, ScDocument* pNewUndoDoc,
1146                                     const SvxSearchItem* pItem )
1147         //
1148     :   ScSimpleUndo( pNewDocShell ),
1149         //
1150         aCursorPos      ( nCurX, nCurY, nCurZ ),
1151         aMarkData       ( rMark ),
1152         aUndoStr        ( rNewUndoStr ),
1153         pUndoDoc        ( pNewUndoDoc )
1154 {
1155     pSearchItem = new SvxSearchItem( *pItem );
1156     SetChangeTrack();
1157 }
1158
1159
1160 //----------------------------------------------------------------------------
1161
1162 __EXPORT ScUndoReplace::~ScUndoReplace()
1163 {
1164     delete pUndoDoc;
1165     delete pSearchItem;
1166 }
1167
1168
1169 //----------------------------------------------------------------------------
1170
1171 void ScUndoReplace::SetChangeTrack()
1172 {
1173     ScDocument* pDoc = pDocShell->GetDocument();
1174     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
1175     if ( pChangeTrack )
1176     {
1177         if ( pUndoDoc )
1178         {       //! im UndoDoc stehen nur die geaenderten Zellen,
1179             // deswegen per Iterator moeglich
1180             pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
1181                 nStartChangeAction,     nEndChangeAction );
1182         }
1183         else
1184         {
1185             nStartChangeAction = pChangeTrack->GetActionMax() + 1;
1186             ScChangeActionContent* pContent = new ScChangeActionContent(
1187                 ScRange( aCursorPos) );
1188             pContent->SetOldValue( aUndoStr, pDoc );
1189             pContent->SetNewValue( pDoc->GetCell( aCursorPos ), pDoc );
1190             pChangeTrack->Append( pContent );
1191             nEndChangeAction = pChangeTrack->GetActionMax();
1192         }
1193     }
1194     else
1195         nStartChangeAction = nEndChangeAction = 0;
1196 }
1197
1198 //----------------------------------------------------------------------------
1199
1200 String __EXPORT ScUndoReplace::GetComment() const
1201 {
1202     return ScGlobal::GetRscString( STR_UNDO_REPLACE );  // "Ersetzen"
1203 }
1204
1205
1206 //----------------------------------------------------------------------------
1207
1208 void __EXPORT ScUndoReplace::Undo()
1209 {
1210     BeginUndo();
1211
1212     ScDocument* pDoc = pDocShell->GetDocument();
1213     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1214
1215     ShowTable( aCursorPos.Tab() );
1216
1217     if (pUndoDoc)               // nur bei ReplaceAll !!
1218     {
1219         DBG_ASSERT(pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE_ALL,
1220                    "ScUndoReplace:: Falscher Modus");
1221
1222         if (pViewShell)
1223             pViewShell->SetMarkData( aMarkData );
1224
1225 //!     markierte Tabellen
1226 //!     Bereich merken ?
1227
1228         //      Undo-Dokument hat keine Zeilen-/Spalten-Infos, also mit bColRowFlags = FALSE
1229         //      kopieren, um Outline-Gruppen nicht kaputtzumachen.
1230
1231         USHORT nUndoFlags = (pSearchItem->GetPattern()) ? IDF_ATTRIB : IDF_CONTENTS;
1232         pUndoDoc->CopyToDocument( 0,      0,      0,
1233                                   MAXCOL, MAXROW, MAXTAB,
1234                                   nUndoFlags, FALSE, pDoc, NULL, FALSE );       // ohne Row-Flags
1235         pDocShell->PostPaintGridAll();
1236     }
1237     else if (pSearchItem->GetPattern() &&
1238              pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
1239     {
1240         String aTempStr = pSearchItem->GetSearchString();               // vertauschen
1241         pSearchItem->SetSearchString(pSearchItem->GetReplaceString());
1242         pSearchItem->SetReplaceString(aTempStr);
1243         pDoc->ReplaceStyle( *pSearchItem,
1244                             aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
1245                             aMarkData, TRUE);
1246         pSearchItem->SetReplaceString(pSearchItem->GetSearchString());
1247         pSearchItem->SetSearchString(aTempStr);
1248         if (pViewShell)
1249             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1250                                        SC_FOLLOW_JUMP, FALSE, FALSE );
1251         pDocShell->PostPaintGridAll();
1252     }
1253     else if (pSearchItem->GetCellType() == SVX_SEARCHIN_NOTE)
1254     {
1255         ScPostIt* pNote = pDoc->GetNote( aCursorPos );
1256         DBG_ASSERT( pNote, "ScUndoReplace::Undo - cell does not contain a note" );
1257         if (pNote)
1258             pNote->SetText( aCursorPos, aUndoStr );
1259         if (pViewShell)
1260             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1261                                        SC_FOLLOW_JUMP, FALSE, FALSE );
1262     }
1263     else
1264     {
1265         // #78889# aUndoStr may contain line breaks
1266         if ( aUndoStr.Search('\n') != STRING_NOTFOUND )
1267             pDoc->PutCell( aCursorPos, new ScEditCell( aUndoStr, pDoc ) );
1268         else
1269             pDoc->SetString( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(), aUndoStr );
1270         if (pViewShell)
1271             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1272                                        SC_FOLLOW_JUMP, FALSE, FALSE );
1273         pDocShell->PostPaintGridAll();
1274     }
1275
1276     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
1277     if ( pChangeTrack )
1278         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1279
1280     EndUndo();
1281 }
1282
1283
1284 //----------------------------------------------------------------------------
1285
1286 void __EXPORT ScUndoReplace::Redo()
1287 {
1288     BeginRedo();
1289
1290     ScDocument* pDoc = pDocShell->GetDocument();
1291     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1292
1293     if (pViewShell)
1294         pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1295                                    SC_FOLLOW_JUMP, FALSE, FALSE );
1296     if (pUndoDoc)
1297     {
1298         if (pViewShell)
1299         {
1300             pViewShell->SetMarkData( aMarkData );
1301
1302             pViewShell->SearchAndReplace( pSearchItem, FALSE, TRUE );
1303         }
1304     }
1305     else if (pSearchItem->GetPattern() &&
1306              pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
1307     {
1308         pDoc->ReplaceStyle( *pSearchItem,
1309                             aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
1310                             aMarkData, TRUE);
1311         pDocShell->PostPaintGridAll();
1312     }
1313     else
1314         if (pViewShell)
1315             pViewShell->SearchAndReplace( pSearchItem, FALSE, TRUE );
1316
1317     SetChangeTrack();
1318
1319     EndRedo();
1320 }
1321
1322
1323 //----------------------------------------------------------------------------
1324
1325 void __EXPORT ScUndoReplace::Repeat(SfxRepeatTarget& rTarget)
1326 {
1327     if (rTarget.ISA(ScTabViewTarget))
1328         ((ScTabViewTarget&)rTarget).GetViewShell()->SearchAndReplace( pSearchItem, TRUE, FALSE );
1329 }
1330
1331
1332 //----------------------------------------------------------------------------
1333
1334 BOOL __EXPORT ScUndoReplace::CanRepeat(SfxRepeatTarget& rTarget) const
1335 {
1336     return (rTarget.ISA(ScTabViewTarget));
1337 }
1338
1339
1340 //============================================================================
1341 //      class ScUndoTabOp
1342 //
1343 //      Mehrfachoperation (nur einfache Bloecke)
1344
1345 //----------------------------------------------------------------------------
1346
1347 ScUndoTabOp::ScUndoTabOp( ScDocShell* pNewDocShell,
1348                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
1349                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ, ScDocument* pNewUndoDoc,
1350                 const ScRefAddress& rFormulaCell,
1351                 const ScRefAddress& rFormulaEnd,
1352                 const ScRefAddress& rRowCell,
1353                 const ScRefAddress& rColCell,
1354                 BYTE nMd )
1355         //
1356     :   ScSimpleUndo( pNewDocShell ),
1357         //
1358         aRange                  ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
1359         pUndoDoc                ( pNewUndoDoc ),
1360         theFormulaCell  ( rFormulaCell ),
1361         theFormulaEnd   ( rFormulaEnd ),
1362         theRowCell              ( rRowCell ),
1363         theColCell              ( rColCell ),
1364         nMode                   ( nMd )
1365 {
1366 }
1367
1368
1369 //----------------------------------------------------------------------------
1370
1371 __EXPORT ScUndoTabOp::~ScUndoTabOp()
1372 {
1373     delete pUndoDoc;
1374 }
1375
1376
1377 //----------------------------------------------------------------------------
1378
1379 String __EXPORT ScUndoTabOp::GetComment() const
1380 {
1381     return ScGlobal::GetRscString( STR_UNDO_TABOP );    // "Mehrfachoperation"
1382 }
1383
1384
1385 //----------------------------------------------------------------------------
1386
1387 void __EXPORT ScUndoTabOp::Undo()
1388 {
1389     BeginUndo();
1390
1391     ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );
1392
1393     USHORT nExtFlags = 0;
1394     pDocShell->UpdatePaintExt( nExtFlags, aRange );
1395
1396     ScDocument* pDoc = pDocShell->GetDocument();
1397     pDoc->DeleteAreaTab( aRange,IDF_ALL );
1398     pUndoDoc->CopyToDocument( aRange, IDF_ALL, FALSE, pDoc );
1399     pDocShell->PostPaint( aRange, PAINT_GRID, nExtFlags );
1400     pDocShell->PostDataChanged();
1401     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1402     if (pViewShell)
1403         pViewShell->CellContentChanged();
1404
1405     EndUndo();
1406 }
1407
1408
1409 //----------------------------------------------------------------------------
1410
1411 void __EXPORT ScUndoTabOp::Redo()
1412 {
1413     BeginRedo();
1414
1415     ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );
1416
1417     ScTabOpParam aParam( theFormulaCell, theFormulaEnd,
1418                          theRowCell,     theColCell,
1419                          nMode );
1420
1421     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1422     if (pViewShell)
1423         pViewShell->TabOp( aParam, FALSE);
1424
1425     EndRedo();
1426 }
1427
1428
1429 //----------------------------------------------------------------------------
1430
1431 void __EXPORT ScUndoTabOp::Repeat(SfxRepeatTarget& /* rTarget */)
1432 {
1433 }
1434
1435
1436 //----------------------------------------------------------------------------
1437
1438 BOOL __EXPORT ScUndoTabOp::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1439 {
1440     return FALSE;
1441 }
1442
1443
1444 //============================================================================
1445 //  class ScUndoConversion
1446 //
1447 //      Spelling
1448
1449 //----------------------------------------------------------------------------
1450
1451 ScUndoConversion::ScUndoConversion(
1452         ScDocShell* pNewDocShell, const ScMarkData& rMark,
1453         SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, ScDocument* pNewUndoDoc,
1454         SCCOL nNewX, SCROW nNewY, SCTAB nNewZ, ScDocument* pNewRedoDoc,
1455         const ScConversionParam& rConvParam ) :
1456     ScSimpleUndo( pNewDocShell ),
1457     aMarkData( rMark ),
1458     aCursorPos( nCurX, nCurY, nCurZ ),
1459     pUndoDoc( pNewUndoDoc ),
1460     aNewCursorPos( nNewX, nNewY, nNewZ ),
1461     pRedoDoc( pNewRedoDoc ),
1462     maConvParam( rConvParam )
1463 {
1464     SetChangeTrack();
1465 }
1466
1467
1468 //----------------------------------------------------------------------------
1469
1470 __EXPORT ScUndoConversion::~ScUndoConversion()
1471 {
1472     delete pUndoDoc;
1473     delete pRedoDoc;
1474 }
1475
1476
1477 //----------------------------------------------------------------------------
1478
1479 void ScUndoConversion::SetChangeTrack()
1480 {
1481     ScDocument* pDoc = pDocShell->GetDocument();
1482     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
1483     if ( pChangeTrack )
1484     {
1485         if ( pUndoDoc )
1486             pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
1487                 nStartChangeAction, nEndChangeAction );
1488         else
1489         {
1490             DBG_ERROR( "ScUndoConversion::SetChangeTrack: kein UndoDoc" );
1491             nStartChangeAction = nEndChangeAction = 0;
1492         }
1493     }
1494     else
1495         nStartChangeAction = nEndChangeAction = 0;
1496 }
1497
1498 //----------------------------------------------------------------------------
1499
1500 String ScUndoConversion::GetComment() const
1501 {
1502     String aText;
1503     switch( maConvParam.GetType() )
1504     {
1505         case SC_CONVERSION_SPELLCHECK:      aText = ScGlobal::GetRscString( STR_UNDO_SPELLING );    break;
1506         case SC_CONVERSION_HANGULHANJA:     aText = ScGlobal::GetRscString( STR_UNDO_HANGULHANJA ); break;
1507         case SC_CONVERSION_CHINESE_TRANSL:  aText = ScGlobal::GetRscString( STR_UNDO_CHINESE_TRANSLATION ); break;
1508         default: DBG_ERRORFILE( "ScUndoConversion::GetComment - unknown conversion type" );
1509     }
1510     return aText;
1511 }
1512
1513
1514 //----------------------------------------------------------------------------
1515
1516 void ScUndoConversion::DoChange( ScDocument* pRefDoc, const ScAddress& rCursorPos )
1517 {
1518     if (pRefDoc)
1519     {
1520         ScDocument* pDoc = pDocShell->GetDocument();
1521         ShowTable( rCursorPos.Tab() );
1522
1523         ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1524         if (pViewShell)
1525             pViewShell->SetMarkData( aMarkData );
1526
1527         SCTAB nTabCount = pDoc->GetTableCount();
1528         //      Undo/Redo-doc has only selected tables
1529
1530         BOOL bMulti = aMarkData.IsMultiMarked();
1531         pRefDoc->CopyToDocument( 0,      0,      0,
1532                                  MAXCOL, MAXROW, nTabCount-1,
1533                                  IDF_CONTENTS, bMulti, pDoc, &aMarkData );
1534         pDocShell->PostPaintGridAll();
1535     }
1536     else
1537     {
1538         DBG_ERROR("Kein Un-/RedoDoc bei Un-/RedoSpelling");
1539     }
1540 }
1541
1542
1543 //----------------------------------------------------------------------------
1544
1545 void ScUndoConversion::Undo()
1546 {
1547     BeginUndo();
1548     DoChange( pUndoDoc, aCursorPos );
1549     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
1550     if ( pChangeTrack )
1551         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1552     EndUndo();
1553 }
1554
1555
1556 //----------------------------------------------------------------------------
1557
1558 void ScUndoConversion::Redo()
1559 {
1560     BeginRedo();
1561     DoChange( pRedoDoc, aNewCursorPos );
1562     SetChangeTrack();
1563     EndRedo();
1564 }
1565
1566
1567 //----------------------------------------------------------------------------
1568
1569 void ScUndoConversion::Repeat( SfxRepeatTarget& rTarget )
1570 {
1571     if( rTarget.ISA( ScTabViewTarget ) )
1572         ((ScTabViewTarget&)rTarget).GetViewShell()->DoSheetConversion( maConvParam, TRUE );
1573 }
1574
1575
1576 //----------------------------------------------------------------------------
1577
1578 BOOL ScUndoConversion::CanRepeat(SfxRepeatTarget& rTarget) const
1579 {
1580     return rTarget.ISA( ScTabViewTarget );
1581 }
1582
1583
1584 //============================================================================
1585 //  class ScUndoRefConversion
1586 //
1587 //      cell reference conversion
1588
1589 //----------------------------------------------------------------------------
1590
1591 ScUndoRefConversion::ScUndoRefConversion( ScDocShell* pNewDocShell,
1592                                          const ScRange& aMarkRange, const ScMarkData& rMark,
1593                                          ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc, BOOL bNewMulti, USHORT nNewFlag) :
1594 ScSimpleUndo( pNewDocShell ),
1595 aMarkData   ( rMark ),
1596 pUndoDoc        ( pNewUndoDoc ),
1597 pRedoDoc        ( pNewRedoDoc ),
1598 aRange          ( aMarkRange ),
1599 bMulti      ( bNewMulti ),
1600 nFlags      ( nNewFlag )
1601 {
1602     SetChangeTrack();
1603 }
1604
1605 __EXPORT ScUndoRefConversion::~ScUndoRefConversion()
1606 {
1607     delete pUndoDoc;
1608     delete pRedoDoc;
1609 }
1610
1611 String __EXPORT ScUndoRefConversion::GetComment() const
1612 {
1613     return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Eingabe"
1614 }
1615
1616 void ScUndoRefConversion::SetChangeTrack()
1617 {
1618     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
1619     if ( pChangeTrack && (nFlags & IDF_FORMULA) )
1620         pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
1621             nStartChangeAction, nEndChangeAction );
1622     else
1623         nStartChangeAction = nEndChangeAction = 0;
1624 }
1625
1626 void ScUndoRefConversion::DoChange( ScDocument* pRefDoc)
1627 {
1628     ScDocument* pDoc = pDocShell->GetDocument();
1629
1630     ShowTable(aRange);
1631
1632     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1633     if (pViewShell)
1634         pViewShell->SetMarkData( aMarkData );
1635
1636     ScRange aCopyRange = aRange;
1637     SCTAB nTabCount = pDoc->GetTableCount();
1638     aCopyRange.aStart.SetTab(0);
1639     aCopyRange.aEnd.SetTab(nTabCount-1);
1640     pRefDoc->CopyToDocument( aCopyRange, nFlags, bMulti, pDoc, &aMarkData );
1641     pDocShell->PostPaint( aRange, PAINT_GRID);
1642     pDocShell->PostDataChanged();
1643     if (pViewShell)
1644         pViewShell->CellContentChanged();
1645 }
1646 void __EXPORT ScUndoRefConversion::Undo()
1647 {
1648     BeginUndo();
1649     if (pUndoDoc)
1650         DoChange(pUndoDoc);
1651     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
1652     if ( pChangeTrack )
1653         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1654     EndUndo();
1655 }
1656
1657 void __EXPORT ScUndoRefConversion::Redo()
1658 {
1659     BeginRedo();
1660     if (pRedoDoc)
1661         DoChange(pRedoDoc);
1662     SetChangeTrack();
1663     EndRedo();
1664 }
1665
1666 void __EXPORT ScUndoRefConversion::Repeat(SfxRepeatTarget& rTarget)
1667 {
1668     if (rTarget.ISA(ScTabViewTarget))
1669         ((ScTabViewTarget&)rTarget).GetViewShell()->DoRefConversion();
1670 }
1671
1672 BOOL __EXPORT ScUndoRefConversion::CanRepeat(SfxRepeatTarget& rTarget) const
1673 {
1674     return (rTarget.ISA(ScTabViewTarget));
1675 }
1676 //============================================================================
1677 //      class ScUndoRefreshLink
1678 //
1679 //      Link aktualisieren / aendern
1680
1681 //----------------------------------------------------------------------------
1682
1683 ScUndoRefreshLink::ScUndoRefreshLink( ScDocShell* pNewDocShell,
1684                                     ScDocument* pNewUndoDoc )
1685         //
1686     :   ScSimpleUndo( pNewDocShell ),
1687         //
1688         pUndoDoc( pNewUndoDoc ),
1689         pRedoDoc( NULL )
1690 {
1691 }
1692
1693
1694 //----------------------------------------------------------------------------
1695
1696 __EXPORT ScUndoRefreshLink::~ScUndoRefreshLink()
1697 {
1698     delete pUndoDoc;
1699     delete pRedoDoc;
1700 }
1701
1702
1703 //----------------------------------------------------------------------------
1704
1705 String __EXPORT ScUndoRefreshLink::GetComment() const
1706 {
1707     return ScGlobal::GetRscString( STR_UNDO_UPDATELINK );
1708 }
1709
1710
1711 //----------------------------------------------------------------------------
1712
1713 void __EXPORT ScUndoRefreshLink::Undo()
1714 {
1715     BeginUndo();
1716
1717     BOOL bMakeRedo = !pRedoDoc;
1718     if (bMakeRedo)
1719         pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
1720
1721     BOOL bFirst = TRUE;
1722     ScDocument* pDoc = pDocShell->GetDocument();
1723     SCTAB nCount = pDoc->GetTableCount();
1724     for (SCTAB nTab=0; nTab<nCount; nTab++)
1725         if (pUndoDoc->HasTable(nTab))
1726         {
1727             ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab);
1728             if (bMakeRedo)
1729             {
1730                 if (bFirst)
1731                     pRedoDoc->InitUndo( pDoc, nTab, nTab, TRUE, TRUE );
1732                 else
1733                     pRedoDoc->AddUndoTab( nTab, nTab, TRUE, TRUE );
1734                 bFirst = FALSE;
1735                 pDoc->CopyToDocument(aRange, IDF_ALL, FALSE, pRedoDoc);
1736 //                              pRedoDoc->TransferDrawPage( pDoc, nTab, nTab );
1737                 pRedoDoc->SetLink( nTab,
1738                                    pDoc->GetLinkMode(nTab),
1739                                    pDoc->GetLinkDoc(nTab),
1740                                    pDoc->GetLinkFlt(nTab),
1741                                    pDoc->GetLinkOpt(nTab),
1742                                    pDoc->GetLinkTab(nTab),
1743                                    pDoc->GetLinkRefreshDelay(nTab) );
1744             }
1745
1746             pDoc->DeleteAreaTab( aRange,IDF_ALL );
1747             pUndoDoc->CopyToDocument( aRange, IDF_ALL, FALSE, pDoc );
1748 //                      pDoc->TransferDrawPage( pUndoDoc, nTab, nTab );
1749             pDoc->SetLink( nTab, pUndoDoc->GetLinkMode(nTab), pUndoDoc->GetLinkDoc(nTab),
1750                                  pUndoDoc->GetLinkFlt(nTab),  pUndoDoc->GetLinkOpt(nTab),
1751                                  pUndoDoc->GetLinkTab(nTab),
1752                                  pUndoDoc->GetLinkRefreshDelay(nTab) );
1753         }
1754
1755     pDocShell->PostPaintGridAll();
1756
1757     EndUndo();
1758 }
1759
1760
1761 //----------------------------------------------------------------------------
1762
1763 void __EXPORT ScUndoRefreshLink::Redo()
1764 {
1765     DBG_ASSERT(pRedoDoc, "Kein RedoDoc bei ScUndoRefreshLink::Redo");
1766
1767     BeginUndo();
1768
1769     ScDocument* pDoc = pDocShell->GetDocument();
1770     SCTAB nCount = pDoc->GetTableCount();
1771     for (SCTAB nTab=0; nTab<nCount; nTab++)
1772         if (pRedoDoc->HasTable(nTab))
1773         {
1774             ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab);
1775
1776             pDoc->DeleteAreaTab( aRange, IDF_ALL );
1777             pRedoDoc->CopyToDocument( aRange, IDF_ALL, FALSE, pDoc );
1778 //                      pDoc->TransferDrawPage( pRedoDoc, nTab, nTab );
1779             pDoc->SetLink( nTab,
1780                            pRedoDoc->GetLinkMode(nTab),
1781                            pRedoDoc->GetLinkDoc(nTab),
1782                            pRedoDoc->GetLinkFlt(nTab),
1783                            pRedoDoc->GetLinkOpt(nTab),
1784                            pRedoDoc->GetLinkTab(nTab),
1785                            pRedoDoc->GetLinkRefreshDelay(nTab) );
1786         }
1787
1788     pDocShell->PostPaintGridAll();
1789
1790     EndUndo();
1791 }
1792
1793
1794 //----------------------------------------------------------------------------
1795
1796 void __EXPORT ScUndoRefreshLink::Repeat(SfxRepeatTarget& /* rTarget */)
1797 {
1798     //  gippsnich
1799 }
1800
1801
1802 //----------------------------------------------------------------------------
1803
1804 BOOL __EXPORT ScUndoRefreshLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1805 {
1806     return FALSE;
1807 }
1808
1809
1810 //----------------------------------------------------------------------------
1811
1812 ScAreaLink* lcl_FindAreaLink( SvxLinkManager* pLinkManager, const String& rDoc,
1813                             const String& rFlt, const String& rOpt,
1814                             const String& rSrc, const ScRange& rDest )
1815 {
1816     const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1817     USHORT nCount = pLinkManager->GetLinks().Count();
1818     for (USHORT i=0; i<nCount; i++)
1819     {
1820         ::sfx2::SvBaseLink* pBase = *rLinks[i];
1821         if (pBase->ISA(ScAreaLink))
1822             if ( ((ScAreaLink*)pBase)->IsEqual( rDoc, rFlt, rOpt, rSrc, rDest ) )
1823                 return (ScAreaLink*)pBase;
1824     }
1825
1826     DBG_ERROR("ScAreaLink nicht gefunden");
1827     return NULL;
1828 }
1829
1830
1831 //============================================================================
1832 //      class ScUndoInsertAreaLink
1833 //
1834 //      Bereichs-Verknuepfung einfuegen
1835
1836 //----------------------------------------------------------------------------
1837
1838 ScUndoInsertAreaLink::ScUndoInsertAreaLink( ScDocShell* pShell,
1839                             const String& rDoc,
1840                             const String& rFlt, const String& rOpt,
1841                             const String& rArea, const ScRange& rDestRange,
1842                             ULONG nRefresh )
1843         //
1844     :   ScSimpleUndo    ( pShell ),
1845         //
1846         aDocName                ( rDoc ),
1847         aFltName                ( rFlt ),
1848         aOptions                ( rOpt ),
1849         aAreaName               ( rArea ),
1850         aRange                  ( rDestRange ),
1851         nRefreshDelay   ( nRefresh )
1852 {
1853 }
1854
1855
1856 //----------------------------------------------------------------------------
1857
1858 __EXPORT ScUndoInsertAreaLink::~ScUndoInsertAreaLink()
1859 {
1860 }
1861
1862
1863 //----------------------------------------------------------------------------
1864
1865 String __EXPORT ScUndoInsertAreaLink::GetComment() const
1866 {
1867     return ScGlobal::GetRscString( STR_UNDO_INSERTAREALINK );
1868 }
1869
1870
1871 //----------------------------------------------------------------------------
1872
1873 void __EXPORT ScUndoInsertAreaLink::Undo()
1874 {
1875     ScDocument* pDoc = pDocShell->GetDocument();
1876     SvxLinkManager* pLinkManager = pDoc->GetLinkManager();
1877
1878     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
1879                                             aAreaName, aRange );
1880     if (pLink)
1881         pLinkManager->Remove( pLink );
1882
1883     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );         // Navigator
1884 }
1885
1886
1887 //----------------------------------------------------------------------------
1888
1889 void __EXPORT ScUndoInsertAreaLink::Redo()
1890 {
1891     ScDocument* pDoc = pDocShell->GetDocument();
1892     SvxLinkManager* pLinkManager = pDoc->GetLinkManager();
1893
1894     ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
1895                                             aAreaName, aRange.aStart, nRefreshDelay );
1896     pLink->SetInCreate( TRUE );
1897     pLink->SetDestArea( aRange );
1898     pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName, &aAreaName );
1899     pLink->Update();
1900     pLink->SetInCreate( FALSE );
1901
1902     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );         // Navigator
1903 }
1904
1905
1906 //----------------------------------------------------------------------------
1907
1908 void __EXPORT ScUndoInsertAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
1909 {
1910     //! ....
1911 }
1912
1913
1914 //----------------------------------------------------------------------------
1915
1916 BOOL __EXPORT ScUndoInsertAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1917 {
1918     return FALSE;
1919 }
1920
1921
1922 //============================================================================
1923 //      class ScUndoRemoveAreaLink
1924 //
1925 //      Bereichs-Verknuepfung loeschen
1926
1927 //----------------------------------------------------------------------------
1928
1929 ScUndoRemoveAreaLink::ScUndoRemoveAreaLink( ScDocShell* pShell,
1930                             const String& rDoc, const String& rFlt, const String& rOpt,
1931                             const String& rArea, const ScRange& rDestRange,
1932                             ULONG nRefresh )
1933         //
1934     :   ScSimpleUndo    ( pShell ),
1935         //
1936         aDocName                ( rDoc ),
1937         aFltName                ( rFlt ),
1938         aOptions                ( rOpt ),
1939         aAreaName               ( rArea ),
1940         aRange                  ( rDestRange ),
1941         nRefreshDelay   ( nRefresh )
1942 {
1943 }
1944
1945
1946 //----------------------------------------------------------------------------
1947
1948 __EXPORT ScUndoRemoveAreaLink::~ScUndoRemoveAreaLink()
1949 {
1950 }
1951
1952
1953 //----------------------------------------------------------------------------
1954
1955 String __EXPORT ScUndoRemoveAreaLink::GetComment() const
1956 {
1957     return ScGlobal::GetRscString( STR_UNDO_REMOVELINK );       //! eigener Text ??
1958 }
1959
1960
1961 //----------------------------------------------------------------------------
1962
1963 void __EXPORT ScUndoRemoveAreaLink::Undo()
1964 {
1965     ScDocument* pDoc = pDocShell->GetDocument();
1966     SvxLinkManager* pLinkManager = pDoc->GetLinkManager();
1967
1968     ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
1969                                         aAreaName, aRange.aStart, nRefreshDelay );
1970     pLink->SetInCreate( TRUE );
1971     pLink->SetDestArea( aRange );
1972     pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName, &aAreaName );
1973     pLink->Update();
1974     pLink->SetInCreate( FALSE );
1975
1976     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );         // Navigator
1977 }
1978
1979
1980 //----------------------------------------------------------------------------
1981
1982 void __EXPORT ScUndoRemoveAreaLink::Redo()
1983 {
1984     ScDocument* pDoc = pDocShell->GetDocument();
1985     SvxLinkManager* pLinkManager = pDoc->GetLinkManager();
1986
1987     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
1988                                             aAreaName, aRange );
1989     if (pLink)
1990         pLinkManager->Remove( pLink );
1991
1992     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );         // Navigator
1993 }
1994
1995
1996 //----------------------------------------------------------------------------
1997
1998 void __EXPORT ScUndoRemoveAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
1999 {
2000     //  gippsnich
2001 }
2002
2003
2004 //----------------------------------------------------------------------------
2005
2006 BOOL __EXPORT ScUndoRemoveAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
2007 {
2008     return FALSE;
2009 }
2010
2011
2012 //============================================================================
2013 //      class ScUndoUpdateAreaLink
2014 //
2015 //      Bereichs-Verknuepfung aktualisieren
2016
2017 //----------------------------------------------------------------------------
2018
2019 ScUndoUpdateAreaLink::ScUndoUpdateAreaLink( ScDocShell* pShell,
2020                             const String& rOldD, const String& rOldF, const String& rOldO,
2021                             const String& rOldA, const ScRange& rOldR, ULONG nOldRD,
2022                             const String& rNewD, const String& rNewF, const String& rNewO,
2023                             const String& rNewA, const ScRange& rNewR, ULONG nNewRD,
2024                             ScDocument* pUndo, ScDocument* pRedo, BOOL bDoInsert )
2025         //
2026     :   ScSimpleUndo( pShell ),
2027         //
2028         aOldDoc         ( rOldD ),
2029         aOldFlt         ( rOldF ),
2030         aOldOpt         ( rOldO ),
2031         aOldArea        ( rOldA ),
2032         aOldRange       ( rOldR ),
2033         aNewDoc         ( rNewD ),
2034         aNewFlt         ( rNewF ),
2035         aNewOpt         ( rNewO ),
2036         aNewArea        ( rNewA ),
2037         aNewRange       ( rNewR ),
2038         pUndoDoc        ( pUndo ),
2039         pRedoDoc        ( pRedo ),
2040         nOldRefresh     ( nOldRD ),
2041         nNewRefresh     ( nNewRD ),
2042         bWithInsert     ( bDoInsert )
2043 {
2044     DBG_ASSERT( aOldRange.aStart == aNewRange.aStart, "AreaLink verschoben ?" );
2045 }
2046
2047
2048 //----------------------------------------------------------------------------
2049
2050 __EXPORT ScUndoUpdateAreaLink::~ScUndoUpdateAreaLink()
2051 {
2052     delete pUndoDoc;
2053     delete pRedoDoc;
2054 }
2055
2056
2057 //----------------------------------------------------------------------------
2058
2059 String __EXPORT ScUndoUpdateAreaLink::GetComment() const
2060 {
2061     return ScGlobal::GetRscString( STR_UNDO_UPDATELINK );       //! eigener Text ??
2062 }
2063
2064
2065 //----------------------------------------------------------------------------
2066
2067 void ScUndoUpdateAreaLink::DoChange( const BOOL bUndo ) const
2068 {
2069     ScDocument* pDoc = pDocShell->GetDocument();
2070
2071     SCCOL nEndX = Max( aOldRange.aEnd.Col(), aNewRange.aEnd.Col() );
2072     SCROW nEndY = Max( aOldRange.aEnd.Row(), aNewRange.aEnd.Row() );
2073     SCTAB nEndZ = Max( aOldRange.aEnd.Tab(), aNewRange.aEnd.Tab() );    //?
2074
2075     if ( bUndo )
2076     {
2077         if ( bWithInsert )
2078         {
2079             pDoc->FitBlock( aNewRange, aOldRange );
2080             pDoc->DeleteAreaTab( aOldRange, IDF_ALL );
2081             pUndoDoc->UndoToDocument( aOldRange, IDF_ALL, FALSE, pDoc );
2082         }
2083         else
2084         {
2085             ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
2086             pDoc->DeleteAreaTab( aCopyRange, IDF_ALL );
2087             pUndoDoc->CopyToDocument( aCopyRange, IDF_ALL, FALSE, pDoc );
2088         }
2089     }
2090     else
2091     {
2092         if ( bWithInsert )
2093         {
2094             pDoc->FitBlock( aOldRange, aNewRange );
2095             pDoc->DeleteAreaTab( aNewRange, IDF_ALL );
2096             pRedoDoc->CopyToDocument( aNewRange, IDF_ALL, FALSE, pDoc );
2097         }
2098         else
2099         {
2100             ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
2101             pDoc->DeleteAreaTab( aCopyRange, IDF_ALL );
2102             pRedoDoc->CopyToDocument( aCopyRange, IDF_ALL, FALSE, pDoc );
2103         }
2104     }
2105
2106     ScRange aWorkRange( aNewRange.aStart, ScAddress( nEndX, nEndY, nEndZ ) );
2107     pDoc->ExtendMerge( aWorkRange, TRUE );
2108
2109     //  Paint
2110
2111     if ( aNewRange.aEnd.Col() != aOldRange.aEnd.Col() )
2112         aWorkRange.aEnd.SetCol(MAXCOL);
2113     if ( aNewRange.aEnd.Row() != aOldRange.aEnd.Row() )
2114         aWorkRange.aEnd.SetRow(MAXROW);
2115
2116     if ( !pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), aWorkRange.aStart.Tab() ) )
2117         pDocShell->PostPaint( aWorkRange, PAINT_GRID );
2118
2119     pDocShell->PostDataChanged();
2120     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2121     if (pViewShell)
2122         pViewShell->CellContentChanged();
2123 }
2124
2125
2126 //----------------------------------------------------------------------------
2127
2128 void __EXPORT ScUndoUpdateAreaLink::Undo()
2129 {
2130     ScDocument* pDoc = pDocShell->GetDocument();
2131     SvxLinkManager* pLinkManager = pDoc->GetLinkManager();
2132     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aNewDoc, aNewFlt, aNewOpt,
2133                                             aNewArea, aNewRange );
2134     if (pLink)
2135     {
2136         pLink->SetSource( aOldDoc, aOldFlt, aOldOpt, aOldArea );                // alte Werte im Link
2137         pLink->SetDestArea( aOldRange );
2138         pLink->SetRefreshDelay( nOldRefresh );
2139     }
2140
2141     DoChange(TRUE);
2142 }
2143
2144
2145 //----------------------------------------------------------------------------
2146
2147 void __EXPORT ScUndoUpdateAreaLink::Redo()
2148 {
2149     ScDocument* pDoc = pDocShell->GetDocument();
2150     SvxLinkManager* pLinkManager = pDoc->GetLinkManager();
2151     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aOldDoc, aOldFlt, aOldOpt,
2152                                             aOldArea, aOldRange );
2153     if (pLink)
2154     {
2155         pLink->SetSource( aNewDoc, aNewFlt, aNewOpt, aNewArea );                // neue Werte im Link
2156         pLink->SetDestArea( aNewRange );
2157         pLink->SetRefreshDelay( nNewRefresh );
2158     }
2159
2160     DoChange(FALSE);
2161 }
2162
2163
2164 //----------------------------------------------------------------------------
2165
2166 void __EXPORT ScUndoUpdateAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
2167 {
2168     //  gippsnich
2169 }
2170
2171
2172 //----------------------------------------------------------------------------
2173
2174 BOOL __EXPORT ScUndoUpdateAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
2175 {
2176     return FALSE;
2177 }
2178
2179
2180
2181