sc/source/ui/undo/undocell.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: undocell.cxx,v $
  10  * $Revision: 1.15.128.8 $
  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 "scitems.hxx"
  35 #include <svx/eeitem.hxx>
  36
  37 #include <svx/editobj.hxx>
  38 #include <svtools/zforlist.hxx>
  39 #include <sfx2/app.hxx>
  40
  41 #include "undocell.hxx"
  42 #include "document.hxx"
  43 #include "docpool.hxx"
  44 #include "patattr.hxx"
  45 #include "docsh.hxx"
  46 #include "tabvwsh.hxx"
  47 #include "globstr.hrc"
  48 #include "global.hxx"
  49 #include "cell.hxx"
  50 #include "target.hxx"
  51 #include "undoolk.hxx"
  52 #include "detdata.hxx"
  53 #include "stlpool.hxx"
  54 #include "printfun.hxx"
  55 #include "rangenam.hxx"
  56 #include "chgtrack.hxx"
  57 #include "sc.hrc"
  58 #include "docuno.hxx"
  59
  60 using ::boost::shared_ptr;
  61
  62 // STATIC DATA -----------------------------------------------------------
  63
  64 TYPEINIT1(ScUndoCursorAttr, ScSimpleUndo);
  65 TYPEINIT1(ScUndoEnterData, ScSimpleUndo);
  66 TYPEINIT1(ScUndoEnterValue, ScSimpleUndo);
  67 TYPEINIT1(ScUndoPutCell, ScSimpleUndo);
  68 TYPEINIT1(ScUndoPageBreak, ScSimpleUndo);
  69 TYPEINIT1(ScUndoPrintZoom, ScSimpleUndo);
  70 TYPEINIT1(ScUndoThesaurus, ScSimpleUndo);
  71 TYPEINIT1(ScUndoReplaceNote, ScSimpleUndo);
  72 TYPEINIT1(ScUndoShowHideNote, ScSimpleUndo);
  73 TYPEINIT1(ScUndoDetective, ScSimpleUndo);
  74 TYPEINIT1(ScUndoRangeNames, ScSimpleUndo);
  75
  76
  77 // -----------------------------------------------------------------------
  78 //
  79 //              Attribute auf Cursor anwenden
  80 //
  81
  82 ScUndoCursorAttr::ScUndoCursorAttr( ScDocShell* pNewDocShell,
  83             SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
  84             const ScPatternAttr* pOldPat, const ScPatternAttr* pNewPat,
  85             const ScPatternAttr* pApplyPat, BOOL bAutomatic ) :
  86     ScSimpleUndo( pNewDocShell ),
  87     nCol( nNewCol ),
  88     nRow( nNewRow ),
  89     nTab( nNewTab ),
  90     pOldEditData( static_cast<EditTextObject*>(NULL) ),
  91     pNewEditData( static_cast<EditTextObject*>(NULL) ),
  92     bIsAutomatic( bAutomatic )
  93 {
  94     ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
  95     pNewPattern = (ScPatternAttr*) &pPool->Put( *pNewPat );
  96     pOldPattern = (ScPatternAttr*) &pPool->Put( *pOldPat );
  97     pApplyPattern = (ScPatternAttr*) &pPool->Put( *pApplyPat );
  98 }
  99
 100 __EXPORT ScUndoCursorAttr::~ScUndoCursorAttr()
 101 {
 102     ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
 103     pPool->Remove(*pNewPattern);
 104     pPool->Remove(*pOldPattern);
 105     pPool->Remove(*pApplyPattern);
 106 }
 107
 108 String __EXPORT ScUndoCursorAttr::GetComment() const
 109 {
 110     //! eigener Text fuer automatische Attributierung
 111
 112     USHORT nId = STR_UNDO_CURSORATTR;            // "Attribute"
 113     return ScGlobal::GetRscString( nId );
 114 }
 115
 116 void ScUndoCursorAttr::SetEditData( EditTextObject* pOld, EditTextObject* pNew )
 117 {
 118     pOldEditData.reset(pOld);
 119     pNewEditData.reset(pNew);
 120 }
 121
 122 void ScUndoCursorAttr::DoChange( const ScPatternAttr* pWhichPattern, const shared_ptr<EditTextObject>& pEditData ) const
 123 {
 124     ScDocument* pDoc = pDocShell->GetDocument();
 125         pDoc->SetPattern( nCol, nRow, nTab, *pWhichPattern, TRUE );
 126
 127     ScBaseCell* pCell;
 128     pDoc->GetCell(nCol, nRow, nTab, pCell);
 129     if (pCell && pCell->GetCellType() == CELLTYPE_EDIT && pEditData.get())
 130         static_cast<ScEditCell*>(pCell)->SetData(pEditData.get(), NULL);
 131
 132     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 133     if (pViewShell)
 134     {
 135         pViewShell->SetTabNo( nTab );
 136         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, FALSE, FALSE );
 137         pViewShell->AdjustBlockHeight();
 138     }
 139
 140     const SfxItemSet& rApplySet = pApplyPattern->GetItemSet();
 141     BOOL bPaintExt = ( rApplySet.GetItemState( ATTR_SHADOW, TRUE ) != SFX_ITEM_DEFAULT ||
 142                        rApplySet.GetItemState( ATTR_CONDITIONAL, TRUE ) != SFX_ITEM_DEFAULT );
 143     BOOL bPaintRows = ( rApplySet.GetItemState( ATTR_HOR_JUSTIFY, TRUE ) != SFX_ITEM_DEFAULT );
 144
 145     USHORT nFlags = SC_PF_TESTMERGE;
 146     if (bPaintExt)
 147         nFlags |= SC_PF_LINES;
 148     if (bPaintRows)
 149         nFlags |= SC_PF_WHOLEROWS;
 150     pDocShell->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID, nFlags );
 151 }
 152
 153 void __EXPORT ScUndoCursorAttr::Undo()
 154 {
 155     BeginUndo();
 156         DoChange(pOldPattern, pOldEditData);
 157
 158     if ( bIsAutomatic )
 159     {
 160         //      wenn automatische Formatierung rueckgaengig gemacht wird,
 161         //      soll auch nicht weiter automatisch formatiert werden:
 162
 163         ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 164         if (pViewShell)
 165             pViewShell->ForgetFormatArea();
 166     }
 167
 168     EndUndo();
 169 }
 170
 171 void __EXPORT ScUndoCursorAttr::Redo()
 172 {
 173     BeginRedo();
 174         DoChange(pNewPattern, pNewEditData);
 175     EndRedo();
 176 }
 177
 178 void __EXPORT ScUndoCursorAttr::Repeat(SfxRepeatTarget& rTarget)
 179 {
 180     if (rTarget.ISA(ScTabViewTarget))
 181         ((ScTabViewTarget&)rTarget).GetViewShell()->ApplySelectionPattern( *pApplyPattern );
 182 }
 183
 184 BOOL __EXPORT ScUndoCursorAttr::CanRepeat(SfxRepeatTarget& rTarget) const
 185 {
 186     return (rTarget.ISA(ScTabViewTarget));
 187 }
 188
 189
 190 // -----------------------------------------------------------------------
 191 //
 192 //              Daten eingeben
 193 //
 194
 195 ScUndoEnterData::ScUndoEnterData( ScDocShell* pNewDocShell,
 196             SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
 197             SCTAB nNewCount, SCTAB* pNewTabs, ScBaseCell** ppOldData,
 198             BOOL* pHasForm, ULONG* pOldForm,
 199             const String& rNewStr, EditTextObject* pObj ) :
 200     ScSimpleUndo( pNewDocShell ),
 201     aNewString( rNewStr ),
 202     pTabs( pNewTabs ),
 203     ppOldCells( ppOldData ),
 204     pHasFormat( pHasForm ),
 205     pOldFormats( pOldForm ),
 206     pNewEditData( pObj ),
 207     nCol( nNewCol ),
 208     nRow( nNewRow ),
 209     nTab( nNewTab ),
 210     nCount( nNewCount )
 211 {
 212     SetChangeTrack();
 213 }
 214
 215 __EXPORT ScUndoEnterData::~ScUndoEnterData()
 216 {
 217     for (USHORT i=0; i<nCount; i++)
 218         if (ppOldCells[i])
 219             ppOldCells[i]->Delete();
 220     delete[] ppOldCells;
 221
 222     delete[] pHasFormat;
 223     delete[] pOldFormats;
 224     delete[] pTabs;
 225
 226     delete pNewEditData;
 227 }
 228
 229 String __EXPORT ScUndoEnterData::GetComment() const
 230 {
 231     return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Eingabe"
 232 }
 233
 234 void ScUndoEnterData::DoChange() const
 235 {
 236     //  Zeilenhoehe anpassen
 237     //! nur wenn noetig (alte oder neue EditZelle, oder Attribute) ??
 238     for (USHORT i=0; i<nCount; i++)
 239         pDocShell->AdjustRowHeight( nRow, nRow, pTabs[i] );
 240
 241     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 242     if (pViewShell)
 243     {
 244         pViewShell->SetTabNo( nTab );
 245         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, FALSE, FALSE );
 246     }
 247
 248     pDocShell->PostDataChanged();
 249 }
 250
 251 void ScUndoEnterData::SetChangeTrack()
 252 {
 253     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 254     if ( pChangeTrack )
 255     {
 256         nEndChangeAction = pChangeTrack->GetActionMax() + 1;
 257         ScAddress aPos( nCol, nRow, nTab );
 258         for (USHORT i=0; i<nCount; i++)
 259         {
 260             aPos.SetTab( pTabs[i] );
 261             ULONG nFormat = 0;
 262             if ( pHasFormat && pOldFormats )
 263             {
 264                 if ( pHasFormat[i] )
 265                     nFormat = pOldFormats[i];
 266             }
 267             pChangeTrack->AppendContent( aPos, ppOldCells[i], nFormat );
 268         }
 269         if ( nEndChangeAction > pChangeTrack->GetActionMax() )
 270             nEndChangeAction = 0;               // nichts appended
 271     }
 272     else
 273         nEndChangeAction = 0;
 274 }
 275
 276 void __EXPORT ScUndoEnterData::Undo()
 277 {
 278     BeginUndo();
 279
 280     ScDocument* pDoc = pDocShell->GetDocument();
 281     for (USHORT i=0; i<nCount; i++)
 282     {
 283         ScBaseCell* pNewCell = ppOldCells[i] ? ppOldCells[i]->CloneWithoutNote( *pDoc, SC_CLONECELL_STARTLISTENING ) : 0;
 284         pDoc->PutCell( nCol, nRow, pTabs[i], pNewCell );
 285
 286         if (pHasFormat && pOldFormats)
 287         {
 288             if ( pHasFormat[i] )
 289                 pDoc->ApplyAttr( nCol, nRow, pTabs[i],
 290                                     SfxUInt32Item( ATTR_VALUE_FORMAT, pOldFormats[i] ) );
 291             else
 292             {
 293                 ScPatternAttr aPattern( *pDoc->GetPattern( nCol, nRow, pTabs[i] ) );
 294                 aPattern.GetItemSet().ClearItem( ATTR_VALUE_FORMAT );
 295                 pDoc->SetPattern( nCol, nRow, pTabs[i], aPattern, TRUE );
 296             }
 297         }
 298         pDocShell->PostPaintCell( nCol, nRow, pTabs[i] );
 299     }
 300
 301     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 302     if ( pChangeTrack && nEndChangeAction >= sal::static_int_cast<ULONG>(nCount) )
 303         pChangeTrack->Undo( nEndChangeAction - nCount + 1, nEndChangeAction );
 304
 305     DoChange();
 306     EndUndo();
 307
 308     // #i97876# Spreadsheet data changes are not notified
 309     ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
 310     if ( pModelObj && pModelObj->HasChangesListeners() )
 311     {
 312         ScRangeList aChangeRanges;
 313         for ( USHORT i = 0; i < nCount; ++i )
 314         {
 315             aChangeRanges.Append( ScRange( nCol, nRow, pTabs[i] ) );
 316         }
 317         pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
 318     }
 319 }
 320
 321 void __EXPORT ScUndoEnterData::Redo()
 322 {
 323     BeginRedo();
 324
 325     ScDocument* pDoc = pDocShell->GetDocument();
 326     for (USHORT i=0; i<nCount; i++)
 327     {
 328         if (pNewEditData)
 329             pDoc->PutCell( nCol, nRow, pTabs[i], new ScEditCell( pNewEditData,
 330                 pDoc, NULL ) );
 331         else
 332             pDoc->SetString( nCol, nRow, pTabs[i], aNewString );
 333         pDocShell->PostPaintCell( nCol, nRow, pTabs[i] );
 334     }
 335
 336     SetChangeTrack();
 337
 338     DoChange();
 339     EndRedo();
 340
 341     // #i97876# Spreadsheet data changes are not notified
 342     ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
 343     if ( pModelObj && pModelObj->HasChangesListeners() )
 344     {
 345         ScRangeList aChangeRanges;
 346         for ( USHORT i = 0; i < nCount; ++i )
 347         {
 348             aChangeRanges.Append( ScRange( nCol, nRow, pTabs[i] ) );
 349         }
 350         pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
 351     }
 352 }
 353
 354 void __EXPORT ScUndoEnterData::Repeat(SfxRepeatTarget& rTarget)
 355 {
 356     if (rTarget.ISA(ScTabViewTarget))
 357     {
 358         String aTemp = aNewString;
 359         ((ScTabViewTarget&)rTarget).GetViewShell()->EnterDataAtCursor( aTemp );
 360     }
 361 }
 362
 363 BOOL __EXPORT ScUndoEnterData::CanRepeat(SfxRepeatTarget& rTarget) const
 364 {
 365     return (rTarget.ISA(ScTabViewTarget));
 366 }
 367
 368
 369 // -----------------------------------------------------------------------
 370 //
 371 //              Wert aendern
 372 //
 373
 374 ScUndoEnterValue::ScUndoEnterValue( ScDocShell* pNewDocShell, const ScAddress& rNewPos,
 375                                     ScBaseCell* pUndoCell, double nVal, BOOL bHeight ) :
 376     ScSimpleUndo( pNewDocShell ),
 377     aPos                ( rNewPos ),
 378     pOldCell    ( pUndoCell ),
 379     nValue              ( nVal ),
 380     bNeedHeight ( bHeight )
 381 {
 382     SetChangeTrack();
 383 }
 384
 385 __EXPORT ScUndoEnterValue::~ScUndoEnterValue()
 386 {
 387     if (pOldCell)
 388         pOldCell->Delete();
 389 }
 390
 391 String __EXPORT ScUndoEnterValue::GetComment() const
 392 {
 393     return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Eingabe"
 394 }
 395
 396 void ScUndoEnterValue::SetChangeTrack()
 397 {
 398     ScDocument* pDoc = pDocShell->GetDocument();
 399     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 400     if ( pChangeTrack )
 401     {
 402         nEndChangeAction = pChangeTrack->GetActionMax() + 1;
 403         pChangeTrack->AppendContent( aPos, pOldCell );
 404         if ( nEndChangeAction > pChangeTrack->GetActionMax() )
 405             nEndChangeAction = 0;               // nichts appended
 406     }
 407     else
 408         nEndChangeAction = 0;
 409 }
 410
 411 void __EXPORT ScUndoEnterValue::Undo()
 412 {
 413     BeginUndo();
 414
 415     ScDocument* pDoc = pDocShell->GetDocument();
 416     ScBaseCell* pNewCell = pOldCell ? pOldCell->CloneWithoutNote( *pDoc, SC_CLONECELL_STARTLISTENING ) : 0;
 417
 418     pDoc->PutCell( aPos, pNewCell );
 419
 420     pDocShell->PostPaintCell( aPos );
 421
 422     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 423     if ( pChangeTrack )
 424         pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 425
 426     EndUndo();
 427 }
 428
 429 void __EXPORT ScUndoEnterValue::Redo()
 430 {
 431     BeginRedo();
 432
 433     ScDocument* pDoc = pDocShell->GetDocument();
 434     pDoc->SetValue( aPos.Col(), aPos.Row(), aPos.Tab(), nValue );
 435     pDocShell->PostPaintCell( aPos );
 436
 437     SetChangeTrack();
 438
 439     EndRedo();
 440 }
 441
 442 void __EXPORT ScUndoEnterValue::Repeat(SfxRepeatTarget& /* rTarget */)
 443 {
 444     //  gippsnich
 445 }
 446
 447 BOOL __EXPORT ScUndoEnterValue::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 448 {
 449     return FALSE;
 450 }
 451
 452
 453 // -----------------------------------------------------------------------
 454 //
 455 //              Beliebige Zelle eingeben
 456 //
 457
 458 ScUndoPutCell::ScUndoPutCell( ScDocShell* pNewDocShell, const ScAddress& rNewPos,
 459                             ScBaseCell* pUndoCell, ScBaseCell* pRedoCell, BOOL bHeight ) :
 460     ScSimpleUndo( pNewDocShell ),
 461     aPos                ( rNewPos ),
 462     pOldCell    ( pUndoCell ),
 463     pEnteredCell( pRedoCell ),
 464     bNeedHeight ( bHeight )
 465 {
 466     SetChangeTrack();
 467 }
 468
 469 __EXPORT ScUndoPutCell::~ScUndoPutCell()
 470 {
 471     if (pOldCell)
 472         pOldCell->Delete();
 473     if (pEnteredCell)
 474         pEnteredCell->Delete();
 475 }
 476
 477 String __EXPORT ScUndoPutCell::GetComment() const
 478 {
 479     return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Eingabe"
 480 }
 481
 482 void ScUndoPutCell::SetChangeTrack()
 483 {
 484     ScDocument* pDoc = pDocShell->GetDocument();
 485     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 486     if ( pChangeTrack )
 487     {
 488         nEndChangeAction = pChangeTrack->GetActionMax() + 1;
 489         pChangeTrack->AppendContent( aPos, pOldCell );
 490         if ( nEndChangeAction > pChangeTrack->GetActionMax() )
 491             nEndChangeAction = 0;               // nichts appended
 492     }
 493     else
 494         nEndChangeAction = 0;
 495 }
 496
 497 void __EXPORT ScUndoPutCell::Undo()
 498 {
 499     BeginUndo();
 500
 501     ScDocument* pDoc = pDocShell->GetDocument();
 502     ScBaseCell* pNewCell = pOldCell ? pOldCell->CloneWithoutNote( *pDoc, aPos, SC_CLONECELL_STARTLISTENING ) : 0;
 503
 504     pDoc->PutCell( aPos.Col(), aPos.Row(), aPos.Tab(), pNewCell );
 505
 506     pDocShell->PostPaintCell( aPos );
 507
 508     ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 509     if ( pChangeTrack )
 510         pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 511
 512     EndUndo();
 513 }
 514
 515 void __EXPORT ScUndoPutCell::Redo()
 516 {
 517     BeginRedo();
 518
 519     ScDocument* pDoc = pDocShell->GetDocument();
 520     ScBaseCell* pNewCell = pEnteredCell ? pEnteredCell->CloneWithoutNote( *pDoc, aPos, SC_CLONECELL_STARTLISTENING ) : 0;
 521
 522     pDoc->PutCell( aPos.Col(), aPos.Row(), aPos.Tab(), pNewCell );
 523
 524     pDocShell->PostPaintCell( aPos );
 525
 526     SetChangeTrack();
 527
 528     EndRedo();
 529 }
 530
 531 void __EXPORT ScUndoPutCell::Repeat(SfxRepeatTarget& /* rTarget */)
 532 {
 533     //  gippsnich
 534 }
 535
 536 BOOL __EXPORT ScUndoPutCell::CanRepeat(SfxRepeatTarget& /* rTarget */) const
 537 {
 538     return FALSE;
 539 }
 540
 541
 542 // -----------------------------------------------------------------------
 543 //
 544 //              Seitenumbrueche
 545 //
 546
 547 ScUndoPageBreak::ScUndoPageBreak( ScDocShell* pNewDocShell,
 548             SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
 549             BOOL bNewColumn, BOOL bNewInsert ) :
 550     ScSimpleUndo( pNewDocShell ),
 551     nCol( nNewCol ),
 552     nRow( nNewRow ),
 553     nTab( nNewTab ),
 554     bColumn( bNewColumn ),
 555     bInsert( bNewInsert )
 556 {
 557 }
 558
 559 __EXPORT ScUndoPageBreak::~ScUndoPageBreak()
 560 {
 561 }
 562
 563 String __EXPORT ScUndoPageBreak::GetComment() const
 564 {
 565     //"Spaltenumbruch" | "Zeilenumbruch"  "einfuegen" | "loeschen"
 566     return String ( bColumn ?
 567         ( bInsert ?
 568             ScGlobal::GetRscString( STR_UNDO_INSCOLBREAK ) :
 569             ScGlobal::GetRscString( STR_UNDO_DELCOLBREAK )
 570         ) :
 571         ( bInsert ?
 572             ScGlobal::GetRscString( STR_UNDO_INSROWBREAK ) :
 573             ScGlobal::GetRscString( STR_UNDO_DELROWBREAK )
 574         ) );
 575 }
 576
 577 void ScUndoPageBreak::DoChange( BOOL bInsertP ) const
 578 {
 579     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 580
 581     if (pViewShell)
 582     {
 583         pViewShell->SetTabNo( nTab );
 584         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, FALSE, FALSE );
 585
 586         if (bInsertP)
 587             pViewShell->InsertPageBreak(bColumn, FALSE);
 588         else
 589             pViewShell->DeletePageBreak(bColumn, FALSE);
 590
 591         pDocShell->GetDocument()->InvalidatePageBreaks(nTab);
 592     }
 593 }
 594
 595 void __EXPORT ScUndoPageBreak::Undo()
 596 {
 597     BeginUndo();
 598     DoChange(!bInsert);
 599     EndUndo();
 600 }
 601
 602 void __EXPORT ScUndoPageBreak::Redo()
 603 {
 604     BeginRedo();
 605     DoChange(bInsert);
 606     EndRedo();
 607 }
 608
 609 void __EXPORT ScUndoPageBreak::Repeat(SfxRepeatTarget& rTarget)
 610 {
 611     if (rTarget.ISA(ScTabViewTarget))
 612     {
 613         ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
 614
 615         if (bInsert)
 616             rViewShell.InsertPageBreak(bColumn, TRUE);
 617         else
 618             rViewShell.DeletePageBreak(bColumn, TRUE);
 619     }
 620 }
 621
 622 BOOL __EXPORT ScUndoPageBreak::CanRepeat(SfxRepeatTarget& rTarget) const
 623 {
 624     return (rTarget.ISA(ScTabViewTarget));
 625 }
 626
 627 // -----------------------------------------------------------------------
 628 //
 629 //              Druck-Skalierung
 630 //
 631
 632 ScUndoPrintZoom::ScUndoPrintZoom( ScDocShell* pNewDocShell,
 633             SCTAB nT, USHORT nOS, USHORT nOP, USHORT nNS, USHORT nNP ) :
 634     ScSimpleUndo( pNewDocShell ),
 635     nTab( nT ),
 636     nOldScale( nOS ),
 637     nOldPages( nOP ),
 638     nNewScale( nNS ),
 639     nNewPages( nNP )
 640 {
 641 }
 642
 643 __EXPORT ScUndoPrintZoom::~ScUndoPrintZoom()
 644 {
 645 }
 646
 647 String __EXPORT ScUndoPrintZoom::GetComment() const
 648 {
 649     return ScGlobal::GetRscString( STR_UNDO_PRINTSCALE );
 650 }
 651
 652 void ScUndoPrintZoom::DoChange( BOOL bUndo )
 653 {
 654     USHORT nScale = bUndo ? nOldScale : nNewScale;
 655     USHORT nPages = bUndo ? nOldPages : nNewPages;
 656
 657     ScDocument* pDoc = pDocShell->GetDocument();
 658     String aStyleName = pDoc->GetPageStyle( nTab );
 659     ScStyleSheetPool* pStylePool = pDoc->GetStyleSheetPool();
 660     SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName, SFX_STYLE_FAMILY_PAGE );
 661     DBG_ASSERT( pStyleSheet, "PageStyle not found" );
 662     if ( pStyleSheet )
 663     {
 664         SfxItemSet& rSet = pStyleSheet->GetItemSet();
 665         rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, nScale ) );
 666         rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALETOPAGES, nPages ) );
 667
 668         ScPrintFunc aPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab );
 669         aPrintFunc.UpdatePages();
 670     }
 671 }
 672
 673 void __EXPORT ScUndoPrintZoom::Undo()
 674 {
 675     BeginUndo();
 676     DoChange(TRUE);
 677     EndUndo();
 678 }
 679
 680 void __EXPORT ScUndoPrintZoom::Redo()
 681 {
 682     BeginRedo();
 683     DoChange(FALSE);
 684     EndRedo();
 685 }
 686
 687 void __EXPORT ScUndoPrintZoom::Repeat(SfxRepeatTarget& rTarget)
 688 {
 689     if (rTarget.ISA(ScTabViewTarget))
 690     {
 691         ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
 692         ScViewData* pViewData = rViewShell.GetViewData();
 693         pViewData->GetDocShell()->SetPrintZoom( pViewData->GetTabNo(), nNewScale, nNewPages );
 694     }
 695 }
 696
 697 BOOL __EXPORT ScUndoPrintZoom::CanRepeat(SfxRepeatTarget& rTarget) const
 698 {
 699     return (rTarget.ISA(ScTabViewTarget));
 700 }
 701
 702
 703 // -----------------------------------------------------------------------
 704 //
 705 //              Thesaurus
 706 //
 707
 708 ScUndoThesaurus::ScUndoThesaurus( ScDocShell* pNewDocShell,
 709                                   SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
 710                                   const String& rNewUndoStr, const EditTextObject* pUndoTObj,
 711                                   const String& rNewRedoStr, const EditTextObject* pRedoTObj) :
 712     ScSimpleUndo( pNewDocShell ),
 713     nCol( nNewCol ),
 714     nRow( nNewRow ),
 715     nTab( nNewTab ),
 716     aUndoStr( rNewUndoStr ),
 717     aRedoStr( rNewRedoStr )
 718 {
 719     pUndoTObject = (pUndoTObj) ? pUndoTObj->Clone() : NULL;
 720     pRedoTObject = (pRedoTObj) ? pRedoTObj->Clone() : NULL;
 721
 722     ScBaseCell* pOldCell;
 723     if ( pUndoTObject )
 724         pOldCell = new ScEditCell( pUndoTObject, pDocShell->GetDocument(), NULL );
 725     else
 726         pOldCell = new ScStringCell( aUndoStr );
 727     SetChangeTrack( pOldCell );
 728     pOldCell->Delete();
 729 }
 730
 731 __EXPORT ScUndoThesaurus::~ScUndoThesaurus()
 732 {
 733     delete pUndoTObject;
 734     delete pRedoTObject;
 735 }
 736
 737 String __EXPORT ScUndoThesaurus::GetComment() const
 738 {
 739     return ScGlobal::GetRscString( STR_UNDO_THESAURUS );        // "Thesaurus"
 740 }
 741
 742 void ScUndoThesaurus::SetChangeTrack( ScBaseCell* pOldCell )
 743 {
 744     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 745     if ( pChangeTrack )
 746     {
 747         nEndChangeAction = pChangeTrack->GetActionMax() + 1;
 748         pChangeTrack->AppendContent( ScAddress( nCol, nRow, nTab ), pOldCell );
 749         if ( nEndChangeAction > pChangeTrack->GetActionMax() )
 750             nEndChangeAction = 0;               // nichts appended
 751     }
 752     else
 753         nEndChangeAction = 0;
 754 }
 755
 756 void __EXPORT ScUndoThesaurus::DoChange( BOOL bUndo, const String& rStr,
 757             const EditTextObject* pTObj )
 758 {
 759     ScDocument* pDoc = pDocShell->GetDocument();
 760
 761     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 762     if (pViewShell)
 763     {
 764         pViewShell->SetTabNo( nTab );
 765         pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, FALSE, FALSE );
 766     }
 767
 768     if (pTObj)
 769     {
 770         ScBaseCell* pCell;
 771         pDoc->GetCell( nCol, nRow, nTab, pCell );
 772         if (pCell)
 773         {
 774             if (pCell->GetCellType() == CELLTYPE_EDIT )
 775             {
 776                 ScEditCell* pNewCell = new ScEditCell( pTObj, pDoc, NULL );
 777                 pDoc->PutCell( nCol, nRow, nTab, pNewCell );
 778                 if ( !bUndo )
 779                     SetChangeTrack( pCell );
 780             }
 781             else
 782             {
 783                 DBG_ERROR("Nicht CELLTYPE_EDIT bei Un/RedoThesaurus");
 784             }
 785         }
 786     }
 787     else
 788     {
 789         ScBaseCell* pCell = NULL;
 790         if ( !bUndo )
 791             pDoc->GetCell( nCol, nRow, nTab, pCell );
 792         pDoc->SetString( nCol, nRow, nTab, rStr );
 793         if ( !bUndo )
 794             SetChangeTrack( pCell );
 795     }
 796
 797     pDocShell->PostPaintCell( nCol, nRow, nTab );
 798 }
 799
 800 void __EXPORT ScUndoThesaurus::Undo()
 801 {
 802     BeginUndo();
 803     DoChange( TRUE, aUndoStr, pUndoTObject );
 804     ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
 805     if ( pChangeTrack )
 806         pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 807     EndUndo();
 808 }
 809
 810 void __EXPORT ScUndoThesaurus::Redo()
 811 {
 812     BeginRedo();
 813     DoChange( FALSE, aRedoStr, pRedoTObject );
 814     EndRedo();
 815 }
 816
 817 void __EXPORT ScUndoThesaurus::Repeat(SfxRepeatTarget& rTarget)
 818 {
 819     if (rTarget.ISA(ScTabViewTarget))
 820         ((ScTabViewTarget&)rTarget).GetViewShell()->DoThesaurus( TRUE );
 821 }
 822
 823 BOOL __EXPORT ScUndoThesaurus::CanRepeat(SfxRepeatTarget& rTarget) const
 824 {
 825     return (rTarget.ISA(ScTabViewTarget));
 826 }
 827
 828
 829 // ============================================================================
 830
 831 ScUndoReplaceNote::ScUndoReplaceNote( ScDocShell& rDocShell, const ScAddress& rPos,
 832         const ScNoteData& rNoteData, bool bInsert, SdrUndoAction* pDrawUndo ) :
 833     ScSimpleUndo( &rDocShell ),
 834     maPos( rPos ),
 835     mpDrawUndo( pDrawUndo )
 836 {
 837     DBG_ASSERT( rNoteData.mpCaption, "ScUndoReplaceNote::ScUndoReplaceNote - missing note caption" );
 838     (bInsert ? maNewData : maOldData) = rNoteData;
 839 }
 840
 841 ScUndoReplaceNote::ScUndoReplaceNote( ScDocShell& rDocShell, const ScAddress& rPos,
 842         const ScNoteData& rOldData, const ScNoteData& rNewData, SdrUndoAction* pDrawUndo ) :
 843     ScSimpleUndo( &rDocShell ),
 844     maPos( rPos ),
 845     maOldData( rOldData ),
 846     maNewData( rNewData ),
 847     mpDrawUndo( pDrawUndo )
 848 {
 849     DBG_ASSERT( maOldData.mpCaption || maNewData.mpCaption, "ScUndoReplaceNote::ScUndoReplaceNote - missing note captions" );
 850     DBG_ASSERT( !maOldData.mxInitData.get() && !maNewData.mxInitData.get(), "ScUndoReplaceNote::ScUndoReplaceNote - unexpected unitialized note" );
 851 }
 852
 853 ScUndoReplaceNote::~ScUndoReplaceNote()
 854 {
 855     DeleteSdrUndoAction( mpDrawUndo );
 856 }
 857
 858 void ScUndoReplaceNote::Undo()
 859 {
 860     BeginUndo();
 861     DoSdrUndoAction( mpDrawUndo, pDocShell->GetDocument() );
 862     /*  Undo insert -> remove new note.
 863         Undo remove -> insert old note.
 864         Undo replace -> remove new note, insert old note. */
 865     DoRemoveNote( maNewData );
 866     DoInsertNote( maOldData );
 867     pDocShell->PostPaintCell( maPos );
 868     EndUndo();
 869 }
 870
 871 void ScUndoReplaceNote::Redo()
 872 {
 873     BeginRedo();
 874     RedoSdrUndoAction( mpDrawUndo );
 875     /*  Redo insert -> insert new note.
 876         Redo remove -> remove old note.
 877         Redo replace -> remove old note, insert new note. */
 878     DoRemoveNote( maOldData );
 879     DoInsertNote( maNewData );
 880     pDocShell->PostPaintCell( maPos );
 881     EndRedo();
 882 }
 883
 884 void ScUndoReplaceNote::Repeat( SfxRepeatTarget& /*rTarget*/ )
 885 {
 886 }
 887
 888 BOOL ScUndoReplaceNote::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
 889 {
 890     return FALSE;
 891 }
 892
 893 String ScUndoReplaceNote::GetComment() const
 894 {
 895     return ScGlobal::GetRscString( maNewData.mpCaption ?
 896         (maOldData.mpCaption ? STR_UNDO_EDITNOTE : STR_UNDO_INSERTNOTE) : STR_UNDO_DELETENOTE );
 897 }
 898
 899 void ScUndoReplaceNote::DoInsertNote( const ScNoteData& rNoteData )
 900 {
 901     if( rNoteData.mpCaption )
 902     {
 903         ScDocument& rDoc = *pDocShell->GetDocument();
 904         DBG_ASSERT( !rDoc.GetNote( maPos ), "ScUndoReplaceNote::DoInsertNote - unexpected cell note" );
 905         ScPostIt* pNote = new ScPostIt( rDoc, maPos, rNoteData, false );
 906         rDoc.TakeNote( maPos, pNote );
 907     }
 908 }
 909
 910 void ScUndoReplaceNote::DoRemoveNote( const ScNoteData& rNoteData )
 911 {
 912     if( rNoteData.mpCaption )
 913     {
 914         ScDocument& rDoc = *pDocShell->GetDocument();
 915         DBG_ASSERT( rDoc.GetNote( maPos ), "ScUndoReplaceNote::DoRemoveNote - missing cell note" );
 916         if( ScPostIt* pNote = rDoc.ReleaseNote( maPos ) )
 917         {
 918             /*  Forget pointer to caption object to suppress removing the
 919                 caption object from the drawing layer while deleting pNote
 920                 (removing the caption is done by a drawing undo action). */
 921             pNote->ForgetCaption();
 922             delete pNote;
 923         }
 924     }
 925 }
 926
 927 // ============================================================================
 928
 929 ScUndoShowHideNote::ScUndoShowHideNote( ScDocShell& rDocShell, const ScAddress& rPos, bool bShow ) :
 930     ScSimpleUndo( &rDocShell ),
 931     maPos( rPos ),
 932     mbShown( bShow )
 933 {
 934 }
 935
 936 ScUndoShowHideNote::~ScUndoShowHideNote()
 937 {
 938 }
 939
 940 void ScUndoShowHideNote::Undo()
 941 {
 942     BeginUndo();
 943     if( ScPostIt* pNote = pDocShell->GetDocument()->GetNote( maPos ) )
 944         pNote->ShowCaption( maPos, !mbShown );
 945     EndUndo();
 946 }
 947
 948 void ScUndoShowHideNote::Redo()
 949 {
 950     BeginRedo();
 951     if( ScPostIt* pNote = pDocShell->GetDocument()->GetNote( maPos ) )
 952         pNote->ShowCaption( maPos, mbShown );
 953     EndRedo();
 954 }
 955
 956 void ScUndoShowHideNote::Repeat( SfxRepeatTarget& /*rTarget*/ )
 957 {
 958 }
 959
 960 BOOL ScUndoShowHideNote::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
 961 {
 962     return FALSE;
 963 }
 964
 965 String ScUndoShowHideNote::GetComment() const
 966 {
 967     return ScGlobal::GetRscString( mbShown ? STR_UNDO_SHOWNOTE : STR_UNDO_HIDENOTE );
 968 }
 969
 970 // ============================================================================
 971
 972 // -----------------------------------------------------------------------
 973 //
 974 //              Detektiv
 975 //
 976
 977 ScUndoDetective::ScUndoDetective( ScDocShell* pNewDocShell,
 978                                     SdrUndoAction* pDraw, const ScDetOpData* pOperation,
 979                                     ScDetOpList* pUndoList ) :
 980     ScSimpleUndo( pNewDocShell ),
 981     pOldList    ( pUndoList ),
 982     nAction             ( 0 ),
 983     pDrawUndo   ( pDraw )
 984 {
 985     bIsDelete = ( pOperation == NULL );
 986     if (!bIsDelete)
 987     {
 988         nAction = (USHORT) pOperation->GetOperation();
 989         aPos = pOperation->GetPos();
 990     }
 991 }
 992
 993 __EXPORT ScUndoDetective::~ScUndoDetective()
 994 {
 995     DeleteSdrUndoAction( pDrawUndo );
 996     delete pOldList;
 997 }
 998
 999 String __EXPORT ScUndoDetective::GetComment() const
1000 {
1001     USHORT nId = STR_UNDO_DETDELALL;
1002     if ( !bIsDelete )
1003         switch ( (ScDetOpType) nAction )
1004         {
1005             case SCDETOP_ADDSUCC:       nId = STR_UNDO_DETADDSUCC;      break;
1006             case SCDETOP_DELSUCC:       nId = STR_UNDO_DETDELSUCC;      break;
1007             case SCDETOP_ADDPRED:       nId = STR_UNDO_DETADDPRED;      break;
1008             case SCDETOP_DELPRED:       nId = STR_UNDO_DETDELPRED;      break;
1009             case SCDETOP_ADDERROR:      nId = STR_UNDO_DETADDERROR;     break;
1010         }
1011
1012     return ScGlobal::GetRscString( nId );
1013 }
1014
1015
1016 void __EXPORT ScUndoDetective::Undo()
1017 {
1018     BeginUndo();
1019
1020     ScDocument* pDoc = pDocShell->GetDocument();
1021     DoSdrUndoAction(pDrawUndo, pDoc);
1022
1023     if (bIsDelete)
1024     {
1025         if ( pOldList )
1026             pDoc->SetDetOpList( new ScDetOpList(*pOldList) );
1027     }
1028     else
1029     {
1030         //      Eintrag aus der Liste loeschen
1031
1032         ScDetOpList* pList = pDoc->GetDetOpList();
1033         if (pList && pList->Count())
1034         {
1035             USHORT nPos = pList->Count() - 1;
1036             ScDetOpData* pData = (*pList)[nPos];
1037             if ( pData->GetOperation() == (ScDetOpType) nAction && pData->GetPos() == aPos )
1038                 pList->DeleteAndDestroy( nPos, 1 );
1039             else
1040             {
1041                 DBG_ERROR("Detektiv-Eintrag in der Liste nicht gefunden");
1042             }
1043         }
1044     }
1045
1046     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1047     if (pViewShell)
1048         pViewShell->RecalcPPT();        //! use broadcast instead?
1049
1050     EndUndo();
1051 }
1052
1053 void __EXPORT ScUndoDetective::Redo()
1054 {
1055     BeginRedo();
1056
1057     RedoSdrUndoAction(pDrawUndo);
1058
1059     ScDocument* pDoc = pDocShell->GetDocument();
1060
1061     if (bIsDelete)
1062         pDoc->ClearDetectiveOperations();
1063     else
1064         pDoc->AddDetectiveOperation( ScDetOpData( aPos, (ScDetOpType) nAction ) );
1065
1066     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1067     if (pViewShell)
1068         pViewShell->RecalcPPT();        //! use broadcast instead?
1069
1070     EndRedo();
1071 }
1072
1073 void __EXPORT ScUndoDetective::Repeat(SfxRepeatTarget& /* rTarget */)
1074 {
1075     //  hammanich
1076 }
1077
1078 BOOL __EXPORT ScUndoDetective::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1079 {
1080     return FALSE;
1081 }
1082
1083 // -----------------------------------------------------------------------
1084 //
1085 //              Benannte Bereiche
1086 //
1087
1088 ScUndoRangeNames::ScUndoRangeNames( ScDocShell* pNewDocShell,
1089                                     ScRangeName* pOld, ScRangeName* pNew ) :
1090     ScSimpleUndo( pNewDocShell ),
1091     pOldRanges  ( pOld ),
1092     pNewRanges  ( pNew )
1093 {
1094 }
1095
1096 __EXPORT ScUndoRangeNames::~ScUndoRangeNames()
1097 {
1098     delete pOldRanges;
1099     delete pNewRanges;
1100 }
1101
1102 String __EXPORT ScUndoRangeNames::GetComment() const
1103 {
1104     return ScGlobal::GetRscString( STR_UNDO_RANGENAMES );
1105 }
1106
1107 void ScUndoRangeNames::DoChange( BOOL bUndo )
1108 {
1109     ScDocument* pDoc = pDocShell->GetDocument();
1110     pDoc->CompileNameFormula( TRUE );   // CreateFormulaString
1111
1112     if ( bUndo )
1113         pDoc->SetRangeName( new ScRangeName( *pOldRanges ) );
1114     else
1115         pDoc->SetRangeName( new ScRangeName( *pNewRanges ) );
1116
1117     pDoc->CompileNameFormula( FALSE );  // CompileFormulaString
1118
1119     SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
1120 }
1121
1122 void __EXPORT ScUndoRangeNames::Undo()
1123 {
1124     BeginUndo();
1125     DoChange( TRUE );
1126     EndUndo();
1127 }
1128
1129 void __EXPORT ScUndoRangeNames::Redo()
1130 {
1131     BeginRedo();
1132     DoChange( FALSE );
1133     EndRedo();
1134 }
1135
1136 void __EXPORT ScUndoRangeNames::Repeat(SfxRepeatTarget& /* rTarget */)
1137 {
1138     //  hammanich
1139 }
1140
1141 BOOL __EXPORT ScUndoRangeNames::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1142 {
1143     return FALSE;
1144 }
1145
1146
1147
1148