sc/source/ui/undo/undoblk.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "scitems.hxx"
  21 #include <vcl/virdev.hxx>
  22 #include <vcl/waitobj.hxx>
  23 #include <editeng/boxitem.hxx>
  24 #include <editeng/justifyitem.hxx>
  25 #include <sfx2/app.hxx>
  26
  27 #include "undoblk.hxx"
  28 #include "undoutil.hxx"
  29 #include "document.hxx"
  30 #include "patattr.hxx"
  31 #include "docsh.hxx"
  32 #include "tabvwsh.hxx"
  33 #include "rangenam.hxx"
  34 #include "rangeutl.hxx"
  35 #include "dbdata.hxx"
  36 #include "stlpool.hxx"
  37 #include "stlsheet.hxx"
  38 #include "globstr.hrc"
  39 #include "global.hxx"
  40 #include "target.hxx"
  41 #include "docpool.hxx"
  42 #include "docfunc.hxx"
  43 #include "attrib.hxx"
  44 #include "chgtrack.hxx"
  45 #include "transobj.hxx"
  46 #include "refundo.hxx"
  47 #include "undoolk.hxx"
  48 #include "clipparam.hxx"
  49 #include <brdcst.hxx>
  50 #include "sc.hrc"
  51 #include <rowheightcontext.hxx>
  52 #include <refhint.hxx>
  53 #include <refupdatecontext.hxx>
  54 #include <validat.hxx>
  55 #include <gridwin.hxx>
  56 #include <svl/listener.hxx>
  57
  58 #include <set>
  59 #include <boost/scoped_ptr.hpp>
  60
  61 // STATIC DATA -----------------------------------------------------------
  62
  63 TYPEINIT1(ScUndoInsertCells,        SfxUndoAction);
  64 TYPEINIT1(ScUndoDeleteCells,        SfxUndoAction);
  65 TYPEINIT1(ScUndoDeleteMulti,        SfxUndoAction);
  66 TYPEINIT1(ScUndoCut,                ScBlockUndo);
  67 TYPEINIT1(ScUndoPaste,              SfxUndoAction);
  68 TYPEINIT1(ScUndoDragDrop,           SfxUndoAction);
  69 TYPEINIT1(ScUndoListNames,          SfxUndoAction);
  70 TYPEINIT1(ScUndoConditionalFormat,  SfxUndoAction);
  71 TYPEINIT1(ScUndoUseScenario,        SfxUndoAction);
  72 TYPEINIT1(ScUndoSelectionStyle,     SfxUndoAction);
  73 TYPEINIT1(ScUndoEnterMatrix,        ScBlockUndo);
  74 TYPEINIT1(ScUndoIndent,             ScBlockUndo);
  75 TYPEINIT1(ScUndoTransliterate,      ScBlockUndo);
  76 TYPEINIT1(ScUndoClearItems,         ScBlockUndo);
  77 TYPEINIT1(ScUndoRemoveBreaks,       SfxUndoAction);
  78 TYPEINIT1(ScUndoRemoveMerge,        ScBlockUndo);
  79 TYPEINIT1(ScUndoBorder,             ScBlockUndo);
  80
  81 // TODO:
  82 /*A*/   // SetOptimalHeight on Document, if no View
  83 /*B*/   // linked sheets
  84 /*C*/   // ScArea
  85 //?     // check later
  86
  87 ScUndoInsertCells::ScUndoInsertCells( ScDocShell* pNewDocShell,
  88                                 const ScRange& rRange, SCTAB nNewCount, SCTAB* pNewTabs, SCTAB* pNewScenarios,
  89                                 InsCellCmd eNewCmd, ScDocument* pUndoDocument, ScRefUndoData* pRefData,
  90                                 bool bNewPartOfPaste ) :
  91     ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFLAST ),
  92     aEffRange( rRange ),
  93     nCount( nNewCount ),
  94     pTabs( pNewTabs ),
  95     pScenarios( pNewScenarios ),
  96     eCmd( eNewCmd ),
  97     bPartOfPaste( bNewPartOfPaste ),
  98     pPasteUndo( NULL )
  99 {
 100     if (eCmd == INS_INSROWS)            // whole row?
 101     {
 102         aEffRange.aStart.SetCol(0);
 103         aEffRange.aEnd.SetCol(MAXCOL);
 104     }
 105
 106     if (eCmd == INS_INSCOLS)            // whole column?
 107     {
 108         aEffRange.aStart.SetRow(0);
 109         aEffRange.aEnd.SetRow(MAXROW);
 110     }
 111
 112     SetChangeTrack();
 113 }
 114
 115 ScUndoInsertCells::~ScUndoInsertCells()
 116 {
 117     delete pPasteUndo;
 118     delete []pTabs;
 119     delete []pScenarios;
 120 }
 121
 122 OUString ScUndoInsertCells::GetComment() const
 123 {
 124     return ScGlobal::GetRscString( pPasteUndo ? STR_UNDO_PASTE : STR_UNDO_INSERTCELLS );
 125 }
 126
 127 bool ScUndoInsertCells::Merge( SfxUndoAction* pNextAction )
 128 {
 129     //  If a paste undo action has already been added, append (detective) action there.
 130     if ( pPasteUndo )
 131         return pPasteUndo->Merge( pNextAction );
 132
 133     if ( bPartOfPaste && pNextAction->ISA( ScUndoWrapper ) )
 134     {
 135         ScUndoWrapper* pWrapper = static_cast<ScUndoWrapper*>(pNextAction);
 136         SfxUndoAction* pWrappedAction = pWrapper->GetWrappedUndo();
 137         if ( pWrappedAction && pWrappedAction->ISA( ScUndoPaste ) )
 138         {
 139             //  Store paste action if this is part of paste with inserting cells.
 140             //  A list action isn't used because Repeat wouldn't work (insert wrong cells).
 141
 142             pPasteUndo = pWrappedAction;
 143             pWrapper->ForgetWrappedUndo();      // pWrapper is deleted by UndoManager
 144             return true;
 145         }
 146     }
 147
 148     //  Call base class for detective handling
 149     return ScMoveUndo::Merge( pNextAction );
 150 }
 151
 152 void ScUndoInsertCells::SetChangeTrack()
 153 {
 154     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 155     if ( pChangeTrack )
 156     {
 157         pChangeTrack->AppendInsert( aEffRange );
 158         nEndChangeAction = pChangeTrack->GetActionMax();
 159     }
 160     else
 161         nEndChangeAction = 0;
 162 }
 163
 164 void ScUndoInsertCells::DoChange( const bool bUndo )
 165 {
 166     ScDocument& rDoc = pDocShell->GetDocument();
 167     SCTAB i;
 168
 169     if ( bUndo )
 170     {
 171         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 172         if ( pChangeTrack )
 173             pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
 174     }
 175     else
 176         SetChangeTrack();
 177
 178     // refresh of merged cells has to be after inserting/deleting
 179
 180     switch (eCmd)
 181     {
 182         case INS_INSROWS:
 183         case INS_CELLSDOWN:
 184             for( i=0; i<nCount; i++ )
 185             {
 186                 if (bUndo)
 187                     rDoc.DeleteRow( aEffRange.aStart.Col(), pTabs[i], aEffRange.aEnd.Col(), pTabs[i]+pScenarios[i],
 188                     aEffRange.aStart.Row(), static_cast<SCSIZE>(aEffRange.aEnd.Row()-aEffRange.aStart.Row()+1));
 189                 else
 190                     rDoc.InsertRow( aEffRange.aStart.Col(), pTabs[i], aEffRange.aEnd.Col(), pTabs[i]+pScenarios[i],
 191                     aEffRange.aStart.Row(), static_cast<SCSIZE>(aEffRange.aEnd.Row()-aEffRange.aStart.Row()+1));
 192             }
 193             break;
 194         case INS_INSCOLS:
 195         case INS_CELLSRIGHT:
 196             for( i=0; i<nCount; i++ )
 197             {
 198                 if (bUndo)
 199                     rDoc.DeleteCol( aEffRange.aStart.Row(), pTabs[i], aEffRange.aEnd.Row(), pTabs[i]+pScenarios[i],
 200                     aEffRange.aStart.Col(), static_cast<SCSIZE>(aEffRange.aEnd.Col()-aEffRange.aStart.Col()+1));
 201                 else
 202                     rDoc.InsertCol( aEffRange.aStart.Row(), pTabs[i], aEffRange.aEnd.Row(), pTabs[i]+pScenarios[i],
 203                     aEffRange.aStart.Col(), static_cast<SCSIZE>(aEffRange.aEnd.Col()-aEffRange.aStart.Col()+1));
 204             }
 205             break;
 206         default:
 207         {
 208             // added to avoid warnings
 209         }
 210     }
 211
 212     ScRange aWorkRange( aEffRange );
 213     if ( eCmd == INS_CELLSRIGHT )                   // only "shift right" requires refresh of the moved area
 214         aWorkRange.aEnd.SetCol(MAXCOL);
 215     for( i=0; i<nCount; i++ )
 216     {
 217         if ( rDoc.HasAttrib( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(), pTabs[i],
 218             aWorkRange.aEnd.Col(), aWorkRange.aEnd.Row(), pTabs[i], HASATTR_MERGED ) )
 219         {
 220             SCCOL nEndCol = aWorkRange.aEnd.Col();
 221             SCROW nEndRow = aWorkRange.aEnd.Row();
 222             rDoc.ExtendMerge( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(), nEndCol, nEndRow, pTabs[i], true );
 223         }
 224     }
 225
 226     // Undo for displaced attributes?
 227
 228     sal_uInt16 nPaint = PAINT_GRID;
 229     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 230     switch (eCmd)
 231     {
 232         case INS_INSROWS:
 233             nPaint |= PAINT_LEFT;
 234             aWorkRange.aEnd.SetRow(MAXROW);
 235             break;
 236         case INS_CELLSDOWN:
 237             for( i=0; i<nCount; i++ )
 238             {
 239                 aWorkRange.aEnd.SetRow(MAXROW);
 240                 if ( pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), pTabs[i] ))
 241                 {
 242                     aWorkRange.aStart.SetCol(0);
 243                     aWorkRange.aEnd.SetCol(MAXCOL);
 244                     nPaint |= PAINT_LEFT;
 245                 }
 246             }
 247             break;
 248         case INS_INSCOLS:
 249             nPaint |= PAINT_TOP;                // top bar
 250         case INS_CELLSRIGHT:
 251             for( i=0; i<nCount; i++ )
 252             {
 253                 aWorkRange.aEnd.SetCol(MAXCOL);     // to the far right
 254                 if ( pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), pTabs[i]) )
 255                 {                                   // AdjustDraw does not paint PAINT_TOP,
 256                     aWorkRange.aStart.SetCol(0);    // thus solved like this
 257                     aWorkRange.aEnd.SetRow(MAXROW);
 258                     nPaint |= PAINT_LEFT;
 259                 }
 260             }
 261             break;
 262         default:
 263         {
 264             // added to avoid warnings
 265         }
 266     }
 267
 268     for( i=0; i<nCount; i++ )
 269     {
 270         pDocShell->PostPaint( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(), pTabs[i],
 271             aWorkRange.aEnd.Col(), aWorkRange.aEnd.Row(), pTabs[i]+pScenarios[i], nPaint );
 272     }
 273     pDocShell->PostDataChanged();
 274     if (pViewShell)
 275         pViewShell->CellContentChanged();
 276 }
 277
 278 void ScUndoInsertCells::Undo()
 279 {
 280     if ( pPasteUndo )
 281         pPasteUndo->Undo();     // undo paste first
 282
 283     WaitObject aWait( ScDocShell::GetActiveDialogParent() );     // important due to TrackFormulas in UpdateReference
 284     BeginUndo();
 285     DoChange( true );
 286     EndUndo();
 287
 288     ScDocument& rDoc = pDocShell->GetDocument();
 289     for (SCTAB i = 0; i < nCount; ++i)
 290         rDoc.SetDrawPageSize(pTabs[i]);
 291 }
 292
 293 void ScUndoInsertCells::Redo()
 294 {
 295     WaitObject aWait( ScDocShell::GetActiveDialogParent() );     // important due to TrackFormulas in UpdateReference
 296     BeginRedo();
 297     DoChange( false );
 298     EndRedo();
 299
 300     if ( pPasteUndo )
 301         pPasteUndo->Redo();     // redo paste last
 302
 303     ScDocument& rDoc = pDocShell->GetDocument();
 304     for (SCTAB i = 0; i < nCount; ++i)
 305         rDoc.SetDrawPageSize(pTabs[i]);
 306 }
 307
 308 void ScUndoInsertCells::Repeat(SfxRepeatTarget& rTarget)
 309 {
 310     if (rTarget.ISA(ScTabViewTarget))
 311     {
 312         if ( pPasteUndo )
 313         {
 314             //  Repeat for paste with inserting cells is handled completely
 315             //  by the Paste undo action
 316
 317             pPasteUndo->Repeat( rTarget );
 318         }
 319         else
 320             static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->InsertCells( eCmd, true );
 321     }
 322 }
 323
 324 bool ScUndoInsertCells::CanRepeat(SfxRepeatTarget& rTarget) const
 325 {
 326     return rTarget.ISA(ScTabViewTarget);
 327 }
 328
 329 ScUndoDeleteCells::ScUndoDeleteCells( ScDocShell* pNewDocShell,
 330                                 const ScRange& rRange, SCTAB nNewCount, SCTAB* pNewTabs, SCTAB* pNewScenarios,
 331                                 DelCellCmd eNewCmd, ScDocument* pUndoDocument, ScRefUndoData* pRefData ) :
 332     ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFLAST ),
 333     aEffRange( rRange ),
 334     nCount( nNewCount ),
 335     pTabs( pNewTabs ),
 336     pScenarios( pNewScenarios ),
 337     eCmd( eNewCmd )
 338 {
 339     if (eCmd == DEL_DELROWS)            // whole row?
 340     {
 341         aEffRange.aStart.SetCol(0);
 342         aEffRange.aEnd.SetCol(MAXCOL);
 343     }
 344
 345     if (eCmd == DEL_DELCOLS)            // whole column?
 346     {
 347         aEffRange.aStart.SetRow(0);
 348         aEffRange.aEnd.SetRow(MAXROW);
 349     }
 350
 351     SetChangeTrack();
 352 }
 353
 354 ScUndoDeleteCells::~ScUndoDeleteCells()
 355 {
 356     delete []pTabs;
 357     delete []pScenarios;
 358 }
 359
 360 OUString ScUndoDeleteCells::GetComment() const
 361 {
 362     return ScGlobal::GetRscString( STR_UNDO_DELETECELLS ); // "Delete"
 363 }
 364
 365 void ScUndoDeleteCells::SetChangeTrack()
 366 {
 367     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 368     if ( pChangeTrack )
 369         pChangeTrack->AppendDeleteRange( aEffRange, pRefUndoDoc,
 370             nStartChangeAction, nEndChangeAction );
 371     else
 372         nStartChangeAction = nEndChangeAction = 0;
 373 }
 374
 375 void ScUndoDeleteCells::DoChange( const bool bUndo )
 376 {
 377     ScDocument& rDoc = pDocShell->GetDocument();
 378     SCTAB i;
 379
 380     if ( bUndo )
 381     {
 382         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 383         if ( pChangeTrack )
 384             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 385     }
 386     else
 387         SetChangeTrack();
 388
 389     switch (eCmd)
 390     {
 391         case DEL_DELROWS:
 392         case DEL_CELLSUP:
 393             for( i=0; i<nCount; i++ )
 394             {
 395                 if (bUndo)
 396                     rDoc.InsertRow( aEffRange.aStart.Col(), pTabs[i], aEffRange.aEnd.Col(), pTabs[i]+pScenarios[i],
 397                     aEffRange.aStart.Row(), static_cast<SCSIZE>(aEffRange.aEnd.Row()-aEffRange.aStart.Row()+1));
 398                 else
 399                     rDoc.DeleteRow( aEffRange.aStart.Col(), pTabs[i], aEffRange.aEnd.Col(), pTabs[i]+pScenarios[i],
 400                     aEffRange.aStart.Row(), static_cast<SCSIZE>(aEffRange.aEnd.Row()-aEffRange.aStart.Row()+1));
 401             }
 402             break;
 403         case DEL_DELCOLS:
 404         case DEL_CELLSLEFT:
 405             for( i=0; i<nCount; i++ )
 406             {
 407                 if (bUndo)
 408                     rDoc.InsertCol( aEffRange.aStart.Row(), pTabs[i], aEffRange.aEnd.Row(), pTabs[i]+pScenarios[i],
 409                     aEffRange.aStart.Col(), static_cast<SCSIZE>(aEffRange.aEnd.Col()-aEffRange.aStart.Col()+1));
 410                 else
 411                     rDoc.DeleteCol( aEffRange.aStart.Row(), pTabs[i], aEffRange.aEnd.Row(), pTabs[i]+pScenarios[i],
 412                     aEffRange.aStart.Col(), static_cast<SCSIZE>(aEffRange.aEnd.Col()-aEffRange.aStart.Col()+1));
 413             }
 414             break;
 415         default:
 416         {
 417             // added to avoid warnings
 418         }
 419     }
 420
 421     // if Undo, restore references
 422     for( i=0; i<nCount && bUndo; i++ )
 423     {
 424         pRefUndoDoc->CopyToDocument( aEffRange.aStart.Col(), aEffRange.aStart.Row(), pTabs[i], aEffRange.aEnd.Col(), aEffRange.aEnd.Row(), pTabs[i]+pScenarios[i],
 425             IDF_ALL | IDF_NOCAPTIONS, false, &rDoc );
 426     }
 427
 428     ScRange aWorkRange( aEffRange );
 429     if ( eCmd == DEL_CELLSLEFT )        // only "shift left" requires refresh of the moved area
 430         aWorkRange.aEnd.SetCol(MAXCOL);
 431
 432     for( i=0; i<nCount; i++ )
 433     {
 434         if ( rDoc.HasAttrib( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(), pTabs[i],
 435             aWorkRange.aEnd.Col(), aWorkRange.aEnd.Row(), pTabs[i], HASATTR_MERGED | HASATTR_OVERLAPPED ) )
 436         {
 437             // #i51445# old merge flag attributes must be deleted also for single cells,
 438             // not only for whole columns/rows
 439
 440             if ( !bUndo )
 441             {
 442                 if ( eCmd==DEL_DELCOLS || eCmd==DEL_CELLSLEFT )
 443                     aWorkRange.aEnd.SetCol(MAXCOL);
 444                 if ( eCmd==DEL_DELROWS || eCmd==DEL_CELLSUP )
 445                     aWorkRange.aEnd.SetRow(MAXROW);
 446                 ScMarkData aMarkData;
 447                 aMarkData.SelectOneTable( aWorkRange.aStart.Tab() );
 448                 ScPatternAttr aPattern( rDoc.GetPool() );
 449                 aPattern.GetItemSet().Put( ScMergeFlagAttr() );
 450                 rDoc.ApplyPatternArea( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(),
 451                     aWorkRange.aEnd.Col(),   aWorkRange.aEnd.Row(),
 452                     aMarkData, aPattern );
 453             }
 454
 455             SCCOL nEndCol = aWorkRange.aEnd.Col();
 456             SCROW nEndRow = aWorkRange.aEnd.Row();
 457             rDoc.ExtendMerge( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(), nEndCol, nEndRow, pTabs[i], true );
 458         }
 459     }
 460
 461     // Zeichnen
 462     sal_uInt16 nPaint = PAINT_GRID;
 463     switch (eCmd)
 464     {
 465         case DEL_DELROWS:
 466             nPaint |= PAINT_LEFT;
 467             aWorkRange.aEnd.SetRow(MAXROW);
 468             break;
 469         case DEL_CELLSUP:
 470             for( i=0; i<nCount; i++ )
 471             {
 472                 aWorkRange.aEnd.SetRow(MAXROW);
 473                 if ( pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), pTabs[i] ))
 474                 {
 475                     aWorkRange.aStart.SetCol(0);
 476                     aWorkRange.aEnd.SetCol(MAXCOL);
 477                     nPaint |= PAINT_LEFT;
 478                 }
 479             }
 480             break;
 481         case DEL_DELCOLS:
 482             nPaint |= PAINT_TOP;                // top bar
 483         case DEL_CELLSLEFT:
 484             for( i=0; i<nCount; i++ )
 485             {
 486                 aWorkRange.aEnd.SetCol(MAXCOL);     // to the far right
 487                 if ( pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), pTabs[i] ) )
 488                 {
 489                     aWorkRange.aStart.SetCol(0);
 490                     aWorkRange.aEnd.SetRow(MAXROW);
 491                     nPaint |= PAINT_LEFT;
 492                 }
 493             }
 494             break;
 495         default:
 496         {
 497             // added to avoid warnings
 498         }
 499     }
 500
 501     for( i=0; i<nCount; i++ )
 502     {
 503         pDocShell->PostPaint( aWorkRange.aStart.Col(), aWorkRange.aStart.Row(), pTabs[i],
 504             aWorkRange.aEnd.Col(), aWorkRange.aEnd.Row(), pTabs[i]+pScenarios[i], nPaint, SC_PF_LINES );
 505     }
 506     // Selection not until EndUndo
 507
 508     pDocShell->PostDataChanged();
 509     //  CellContentChanged comes with the selection
 510 }
 511
 512 void ScUndoDeleteCells::Undo()
 513 {
 514     WaitObject aWait( ScDocShell::GetActiveDialogParent() );     // important because of TrackFormulas in UpdateReference
 515     BeginUndo();
 516     DoChange( true );
 517     EndUndo();
 518     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
 519
 520     // Selection not until EndUndo
 521     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 522     if (pViewShell)
 523     {
 524         for( SCTAB i=0; i<nCount; i++ )
 525         {
 526             pViewShell->MarkRange( ScRange(aEffRange.aStart.Col(), aEffRange.aStart.Row(), pTabs[i], aEffRange.aEnd.Col(), aEffRange.aEnd.Row(), pTabs[i]+pScenarios[i]) );
 527         }
 528     }
 529
 530     ScDocument& rDoc = pDocShell->GetDocument();
 531     for (SCTAB i = 0; i < nCount; ++i)
 532         rDoc.SetDrawPageSize(pTabs[i]);
 533 }
 534
 535 void ScUndoDeleteCells::Redo()
 536 {
 537     WaitObject aWait( ScDocShell::GetActiveDialogParent() );     // important because of TrackFormulas in UpdateReference
 538     BeginRedo();
 539     DoChange( false);
 540     EndRedo();
 541     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
 542
 543     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 544     if (pViewShell)
 545         pViewShell->DoneBlockMode();            // current way
 546
 547     ScDocument& rDoc = pDocShell->GetDocument();
 548     for (SCTAB i = 0; i < nCount; ++i)
 549         rDoc.SetDrawPageSize(pTabs[i]);
 550 }
 551
 552 void ScUndoDeleteCells::Repeat(SfxRepeatTarget& rTarget)
 553 {
 554     if (rTarget.ISA(ScTabViewTarget))
 555         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->DeleteCells( eCmd, true );
 556 }
 557
 558 bool ScUndoDeleteCells::CanRepeat(SfxRepeatTarget& rTarget) const
 559 {
 560     return rTarget.ISA(ScTabViewTarget);
 561 }
 562
 563 // delete cells in multiselection
 564 ScUndoDeleteMulti::ScUndoDeleteMulti(
 565     ScDocShell* pNewDocShell,
 566     bool bNewRows, bool bNeedsRefresh, SCTAB nNewTab,
 567     const std::vector<sc::ColRowSpan>& rSpans,
 568     ScDocument* pUndoDocument, ScRefUndoData* pRefData ) :
 569     ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFLAST ),
 570     mbRows(bNewRows),
 571     mbRefresh(bNeedsRefresh),
 572     nTab( nNewTab ),
 573     maSpans(rSpans)
 574 {
 575     SetChangeTrack();
 576 }
 577
 578 ScUndoDeleteMulti::~ScUndoDeleteMulti()
 579 {
 580 }
 581
 582 OUString ScUndoDeleteMulti::GetComment() const
 583 {
 584     return ScGlobal::GetRscString( STR_UNDO_DELETECELLS );  // like DeleteCells
 585 }
 586
 587 void ScUndoDeleteMulti::DoChange() const
 588 {
 589     SCCOL nStartCol;
 590     SCROW nStartRow;
 591     sal_uInt16 nPaint;
 592     if (mbRows)
 593     {
 594         nStartCol = 0;
 595         nStartRow = static_cast<SCROW>(maSpans[0].mnStart);
 596         nPaint = PAINT_GRID | PAINT_LEFT;
 597     }
 598     else
 599     {
 600         nStartCol = static_cast<SCCOL>(maSpans[0].mnStart);
 601         nStartRow = 0;
 602         nPaint = PAINT_GRID | PAINT_TOP;
 603     }
 604
 605     if (mbRefresh)
 606     {
 607         ScDocument& rDoc = pDocShell->GetDocument();
 608         SCCOL nEndCol = MAXCOL;
 609         SCROW nEndRow = MAXROW;
 610         rDoc.RemoveFlagsTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
 611         rDoc.ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab, true );
 612     }
 613
 614     pDocShell->PostPaint( nStartCol, nStartRow, nTab, MAXCOL, MAXROW, nTab, nPaint );
 615     pDocShell->PostDataChanged();
 616     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 617     if (pViewShell)
 618         pViewShell->CellContentChanged();
 619
 620     ShowTable( nTab );
 621 }
 622
 623 void ScUndoDeleteMulti::SetChangeTrack()
 624 {
 625     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 626     if ( pChangeTrack )
 627     {
 628         nStartChangeAction = pChangeTrack->GetActionMax() + 1;
 629         ScRange aRange( 0, 0, nTab, 0, 0, nTab );
 630         if (mbRows)
 631             aRange.aEnd.SetCol( MAXCOL );
 632         else
 633             aRange.aEnd.SetRow( MAXROW );
 634         // delete in reverse
 635         std::vector<sc::ColRowSpan>::const_reverse_iterator ri = maSpans.rbegin(), riEnd = maSpans.rend();
 636         for (; ri != riEnd; ++ri)
 637         {
 638             SCCOLROW nEnd = ri->mnEnd;
 639             SCCOLROW nStart = ri->mnStart;
 640             if (mbRows)
 641             {
 642                 aRange.aStart.SetRow( nStart );
 643                 aRange.aEnd.SetRow( nEnd );
 644             }
 645             else
 646             {
 647                 aRange.aStart.SetCol( static_cast<SCCOL>(nStart) );
 648                 aRange.aEnd.SetCol( static_cast<SCCOL>(nEnd) );
 649             }
 650             sal_uLong nDummyStart;
 651             pChangeTrack->AppendDeleteRange( aRange, pRefUndoDoc,
 652                 nDummyStart, nEndChangeAction );
 653         }
 654     }
 655     else
 656         nStartChangeAction = nEndChangeAction = 0;
 657 }
 658
 659 void ScUndoDeleteMulti::Undo()
 660 {
 661     WaitObject aWait( ScDocShell::GetActiveDialogParent() );     // important because of TrackFormulas in UpdateReference
 662     BeginUndo();
 663
 664     ScDocument& rDoc = pDocShell->GetDocument();
 665
 666     // reverse delete -> forward insert
 667     std::vector<sc::ColRowSpan>::const_iterator it = maSpans.begin(), itEnd = maSpans.end();
 668     for (; it != itEnd; ++it)
 669     {
 670         SCCOLROW nStart = it->mnStart;
 671         SCCOLROW nEnd = it->mnEnd;
 672         if (mbRows)
 673             rDoc.InsertRow( 0,nTab, MAXCOL,nTab, nStart,static_cast<SCSIZE>(nEnd-nStart+1) );
 674         else
 675             rDoc.InsertCol( 0,nTab, MAXROW,nTab, static_cast<SCCOL>(nStart), static_cast<SCSIZE>(nEnd-nStart+1) );
 676     }
 677
 678     it = maSpans.begin();
 679     for (; it != itEnd; ++it)
 680     {
 681         SCCOLROW nStart = it->mnStart;
 682         SCCOLROW nEnd = it->mnEnd;
 683         if (mbRows)
 684             pRefUndoDoc->CopyToDocument( 0,nStart,nTab, MAXCOL,nEnd,nTab, IDF_ALL,false, &rDoc );
 685         else
 686             pRefUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart),0,nTab,
 687                     static_cast<SCCOL>(nEnd),MAXROW,nTab, IDF_ALL,false, &rDoc );
 688     }
 689
 690     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 691     if ( pChangeTrack )
 692         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 693
 694     DoChange();
 695
 696     //! redrawing the selection is not possible at the moment
 697     //! since no data for selection exist
 698
 699     EndUndo();
 700     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
 701 }
 702
 703 void ScUndoDeleteMulti::Redo()
 704 {
 705     WaitObject aWait( ScDocShell::GetActiveDialogParent() );     // important because of TrackFormulas in UpdateReference
 706     BeginRedo();
 707
 708     ScDocument& rDoc = pDocShell->GetDocument();
 709
 710     // reverse delete
 711     std::vector<sc::ColRowSpan>::const_reverse_iterator ri = maSpans.rbegin(), riEnd = maSpans.rend();
 712     for (; ri != riEnd; ++ri)
 713     {
 714         SCCOLROW nEnd = ri->mnEnd;
 715         SCCOLROW nStart = ri->mnStart;
 716         if (mbRows)
 717             rDoc.DeleteRow( 0,nTab, MAXCOL,nTab, nStart,static_cast<SCSIZE>(nEnd-nStart+1) );
 718         else
 719             rDoc.DeleteCol( 0,nTab, MAXROW,nTab, static_cast<SCCOL>(nStart), static_cast<SCSIZE>(nEnd-nStart+1) );
 720     }
 721
 722     SetChangeTrack();
 723
 724     DoChange();
 725
 726     EndRedo();
 727     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
 728 }
 729
 730 void ScUndoDeleteMulti::Repeat(SfxRepeatTarget& rTarget)
 731 {
 732     // if single selection
 733     if (rTarget.ISA(ScTabViewTarget))
 734         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->DeleteCells( DEL_DELROWS, true );
 735 }
 736
 737 bool ScUndoDeleteMulti::CanRepeat(SfxRepeatTarget& rTarget) const
 738 {
 739     return rTarget.ISA(ScTabViewTarget);
 740 }
 741
 742 ScUndoCut::ScUndoCut( ScDocShell* pNewDocShell,
 743                 ScRange aRange, ScAddress aOldEnd, const ScMarkData& rMark,
 744                 ScDocument* pNewUndoDoc ) :
 745     ScBlockUndo( pNewDocShell, ScRange(aRange.aStart, aOldEnd), SC_UNDO_AUTOHEIGHT ),
 746     aMarkData( rMark ),
 747     pUndoDoc( pNewUndoDoc ),
 748     aExtendedRange( aRange )
 749 {
 750     SetChangeTrack();
 751 }
 752
 753 ScUndoCut::~ScUndoCut()
 754 {
 755     delete pUndoDoc;
 756 }
 757
 758 OUString ScUndoCut::GetComment() const
 759 {
 760     return ScGlobal::GetRscString( STR_UNDO_CUT ); // "cut"
 761 }
 762
 763 void ScUndoCut::SetChangeTrack()
 764 {
 765     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 766     if ( pChangeTrack )
 767         pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
 768             nStartChangeAction, nEndChangeAction, SC_CACM_CUT );
 769     else
 770         nStartChangeAction = nEndChangeAction = 0;
 771 }
 772
 773 void ScUndoCut::DoChange( const bool bUndo )
 774 {
 775     ScDocument& rDoc = pDocShell->GetDocument();
 776     sal_uInt16 nExtFlags = 0;
 777
 778     // do not undo/redo objects and note captions, they are handled via drawing undo
 779     InsertDeleteFlags nUndoFlags = (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
 780
 781     if (bUndo)  // only for Undo
 782     {
 783         //  all sheets - CopyToDocument skips those that don't exist in pUndoDoc
 784         SCTAB nTabCount = rDoc.GetTableCount();
 785         ScRange aCopyRange = aExtendedRange;
 786         aCopyRange.aStart.SetTab(0);
 787         aCopyRange.aEnd.SetTab(nTabCount-1);
 788         pUndoDoc->CopyToDocument( aCopyRange, nUndoFlags, false, &rDoc );
 789         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 790         if ( pChangeTrack )
 791             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 792
 793         BroadcastChanges(aCopyRange);
 794     }
 795     else        // only for Redo
 796     {
 797         pDocShell->UpdatePaintExt( nExtFlags, aExtendedRange );
 798         rDoc.DeleteArea( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
 799                           aBlockRange.aEnd.Col(), aBlockRange.aEnd.Row(), aMarkData, nUndoFlags );
 800         SetChangeTrack();
 801     }
 802
 803     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 804     if ( !( (pViewShell) && pViewShell->AdjustBlockHeight() ) )
 805 /*A*/   pDocShell->PostPaint( aExtendedRange, PAINT_GRID, nExtFlags );
 806
 807     if ( !bUndo )                               //   draw redo after updating row heights
 808         RedoSdrUndoAction( pDrawUndo );         //! include in ScBlockUndo?
 809
 810     pDocShell->PostDataChanged();
 811     if (pViewShell)
 812         pViewShell->CellContentChanged();
 813 }
 814
 815 void ScUndoCut::Undo()
 816 {
 817     BeginUndo();
 818     DoChange( true );
 819     EndUndo();
 820 }
 821
 822 void ScUndoCut::Redo()
 823 {
 824     BeginRedo();
 825     ScDocument& rDoc = pDocShell->GetDocument();
 826     EnableDrawAdjust( &rDoc, false );                //! include in ScBlockUndo?
 827     DoChange( false );
 828     EnableDrawAdjust( &rDoc, true );                 //! include in ScBlockUndo?
 829     EndRedo();
 830 }
 831
 832 void ScUndoCut::Repeat(SfxRepeatTarget& rTarget)
 833 {
 834     if (rTarget.ISA(ScTabViewTarget))
 835         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->CutToClip( NULL, true );
 836 }
 837
 838 bool ScUndoCut::CanRepeat(SfxRepeatTarget& rTarget) const
 839 {
 840     return rTarget.ISA(ScTabViewTarget);
 841 }
 842
 843 ScUndoPaste::ScUndoPaste( ScDocShell* pNewDocShell, const ScRangeList& rRanges,
 844                 const ScMarkData& rMark,
 845                 ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc,
 846                 InsertDeleteFlags nNewFlags,
 847                 ScRefUndoData* pRefData,
 848                 bool bRedoIsFilled, const ScUndoPasteOptions* pOptions ) :
 849     ScMultiBlockUndo( pNewDocShell, rRanges, SC_UNDO_SIMPLE ),
 850     aMarkData( rMark ),
 851     pUndoDoc( pNewUndoDoc ),
 852     pRedoDoc( pNewRedoDoc ),
 853     nFlags( nNewFlags ),
 854     pRefUndoData( pRefData ),
 855     pRefRedoData( NULL ),
 856     bRedoFilled( bRedoIsFilled )
 857 {
 858     if ( pRefUndoData )
 859         pRefUndoData->DeleteUnchanged( &pDocShell->GetDocument() );
 860
 861     if ( pOptions )
 862         aPasteOptions = *pOptions;      // used only for Repeat
 863
 864     SetChangeTrack();
 865 }
 866
 867 ScUndoPaste::~ScUndoPaste()
 868 {
 869     delete pUndoDoc;
 870     delete pRedoDoc;
 871     delete pRefUndoData;
 872     delete pRefRedoData;
 873 }
 874
 875 OUString ScUndoPaste::GetComment() const
 876 {
 877     return ScGlobal::GetRscString( STR_UNDO_PASTE ); // "paste"
 878 }
 879
 880 void ScUndoPaste::SetChangeTrack()
 881 {
 882     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 883     if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
 884     {
 885         for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 886         {
 887             pChangeTrack->AppendContentRange(*maBlockRanges[i], pUndoDoc,
 888                 nStartChangeAction, nEndChangeAction, SC_CACM_PASTE );
 889         }
 890     }
 891     else
 892         nStartChangeAction = nEndChangeAction = 0;
 893 }
 894
 895 void ScUndoPaste::DoChange(bool bUndo)
 896 {
 897     ScDocument& rDoc = pDocShell->GetDocument();
 898
 899     //  RefUndoData for redo is created before first undo
 900     //  (with DeleteUnchanged after the DoUndo call)
 901     bool bCreateRedoData = ( bUndo && pRefUndoData && !pRefRedoData );
 902     if ( bCreateRedoData )
 903         pRefRedoData = new ScRefUndoData( &rDoc );
 904
 905     ScRefUndoData* pWorkRefData = bUndo ? pRefUndoData : pRefRedoData;
 906
 907     // Always back-up either all or none of the content for Undo
 908     InsertDeleteFlags nUndoFlags = IDF_NONE;
 909     if (nFlags & IDF_CONTENTS)
 910         nUndoFlags |= IDF_CONTENTS;
 911     if (nFlags & IDF_ATTRIB)
 912         nUndoFlags |= IDF_ATTRIB;
 913
 914     // do not undo/redo objects and note captions, they are handled via drawing undo
 915     (nUndoFlags &= ~IDF_OBJECTS) |= IDF_NOCAPTIONS;
 916
 917     bool bPaintAll = false;
 918
 919     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 920
 921     SCTAB nTabCount = rDoc.GetTableCount();
 922     if ( bUndo && !bRedoFilled )
 923     {
 924         if (!pRedoDoc)
 925         {
 926             bool bColInfo = true;
 927             bool bRowInfo = true;
 928             for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 929             {
 930                 const ScRange& r = *maBlockRanges[i];
 931                 bColInfo &= (r.aStart.Row() == 0 && r.aEnd.Row() == MAXROW);
 932                 bRowInfo &= (r.aStart.Col() == 0 && r.aEnd.Col() == MAXCOL);
 933                 if (!bColInfo && !bRowInfo)
 934                     break;
 935             }
 936
 937             pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
 938             pRedoDoc->InitUndoSelected( &rDoc, aMarkData, bColInfo, bRowInfo );
 939         }
 940         //  read "redo" data from the document in the first undo
 941         //  all sheets - CopyToDocument skips those that don't exist in pRedoDoc
 942         for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 943         {
 944             ScRange aCopyRange = *maBlockRanges[i];
 945             aCopyRange.aStart.SetTab(0);
 946             aCopyRange.aEnd.SetTab(nTabCount-1);
 947             rDoc.CopyToDocument( aCopyRange, nUndoFlags, false, pRedoDoc );
 948             bRedoFilled = true;
 949         }
 950     }
 951
 952     sal_uInt16 nExtFlags = 0;
 953     pDocShell->UpdatePaintExt(nExtFlags, maBlockRanges.Combine());
 954
 955     rDoc.ForgetNoteCaptions(maBlockRanges);
 956     aMarkData.MarkToMulti();
 957     rDoc.DeleteSelection(nUndoFlags, aMarkData, false); // no broadcasting here
 958     for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 959         rDoc.BroadcastCells(*maBlockRanges[i], SC_HINT_DATACHANGED);
 960
 961     aMarkData.MarkToSimple();
 962
 963     SCTAB nFirstSelected = aMarkData.GetFirstSelected();
 964
 965     if ( !bUndo && pRedoDoc )       // Redo: UndoToDocument before handling RefData
 966     {
 967         for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 968         {
 969             ScRange aRange = *maBlockRanges[i];
 970             aRange.aStart.SetTab(nFirstSelected);
 971             aRange.aEnd.SetTab(nFirstSelected);
 972             pRedoDoc->UndoToDocument(aRange, nUndoFlags, false, &rDoc);
 973             ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
 974             for (; itr != itrEnd && *itr < nTabCount; ++itr)
 975             {
 976                 if (*itr == nFirstSelected)
 977                     continue;
 978
 979                 aRange.aStart.SetTab(*itr);
 980                 aRange.aEnd.SetTab(*itr);
 981                 pRedoDoc->CopyToDocument( aRange, nUndoFlags, false, &rDoc );
 982             }
 983         }
 984     }
 985
 986     if (pWorkRefData)
 987     {
 988         pWorkRefData->DoUndo( &rDoc, true );     // true = bSetChartRangeLists for SetChartListenerCollection
 989         if (!maBlockRanges.empty() &&
 990             rDoc.RefreshAutoFilter(0, 0, MAXCOL, MAXROW, maBlockRanges[0]->aStart.Tab()))
 991             bPaintAll = true;
 992     }
 993
 994     if ( bCreateRedoData && pRefRedoData )
 995         pRefRedoData->DeleteUnchanged( &rDoc );
 996
 997     if (bUndo)      // Undo: UndoToDocument after handling RefData
 998     {
 999         for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
1000         {
1001             ScRange aRange = *maBlockRanges[i];
1002             ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
1003             for (; itr != itrEnd && *itr < nTabCount; ++itr)
1004             {
1005                 aRange.aStart.SetTab(*itr);
1006                 aRange.aEnd.SetTab(*itr);
1007                 pUndoDoc->UndoToDocument(aRange, nUndoFlags, false, &rDoc);
1008             }
1009         }
1010     }
1011
1012     if ( bUndo )
1013     {
1014         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1015         if ( pChangeTrack )
1016             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1017     }
1018     else
1019         SetChangeTrack();
1020
1021     ScRangeList aDrawRanges(maBlockRanges);
1022     sal_uInt16 nPaint = PAINT_GRID;
1023     for (size_t i = 0, n = aDrawRanges.size(); i < n; ++i)
1024     {
1025         ScRange& rDrawRange = *aDrawRanges[i];
1026         rDoc.ExtendMerge(rDrawRange, true);      // only needed for single sheet (text/rtf etc.)
1027         if (bPaintAll)
1028         {
1029             rDrawRange.aStart.SetCol(0);
1030             rDrawRange.aStart.SetRow(0);
1031             rDrawRange.aEnd.SetCol(MAXCOL);
1032             rDrawRange.aEnd.SetRow(MAXROW);
1033             nPaint |= PAINT_TOP | PAINT_LEFT;
1034             if (pViewShell)
1035                 pViewShell->AdjustBlockHeight(false);
1036         }
1037         else
1038         {
1039             if (maBlockRanges[i]->aStart.Row() == 0 && maBlockRanges[i]->aEnd.Row() == MAXROW) // whole column
1040             {
1041                 nPaint |= PAINT_TOP;
1042                 rDrawRange.aEnd.SetCol(MAXCOL);
1043             }
1044             if (maBlockRanges[i]->aStart.Col() == 0 && maBlockRanges[i]->aEnd.Col() == MAXCOL) // whole row
1045             {
1046                 nPaint |= PAINT_LEFT;
1047                 rDrawRange.aEnd.SetRow(MAXROW);
1048             }
1049             if (pViewShell && pViewShell->AdjustBlockHeight(false))
1050             {
1051                 rDrawRange.aStart.SetCol(0);
1052                 rDrawRange.aStart.SetRow(0);
1053                 rDrawRange.aEnd.SetCol(MAXCOL);
1054                 rDrawRange.aEnd.SetRow(MAXROW);
1055                 nPaint |= PAINT_LEFT;
1056             }
1057             pDocShell->UpdatePaintExt(nExtFlags, rDrawRange);
1058         }
1059     }
1060
1061     if ( !bUndo )                               //   draw redo after updating row heights
1062         RedoSdrUndoAction(mpDrawUndo);
1063
1064     pDocShell->PostPaint(aDrawRanges, nPaint, nExtFlags);
1065
1066     pDocShell->PostDataChanged();
1067     if (pViewShell)
1068         pViewShell->CellContentChanged();
1069 }
1070
1071 void ScUndoPaste::Undo()
1072 {
1073     BeginUndo();
1074     DoChange(true);
1075     if (!maBlockRanges.empty())
1076         ShowTable(*maBlockRanges.front());
1077     EndUndo();
1078     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1079 }
1080
1081 void ScUndoPaste::Redo()
1082 {
1083     BeginRedo();
1084     ScDocument& rDoc = pDocShell->GetDocument();
1085     EnableDrawAdjust( &rDoc, false );                //! include in ScBlockUndo?
1086     DoChange( false );
1087     EnableDrawAdjust( &rDoc, true );                 //! include in ScBlockUndo?
1088     EndRedo();
1089     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1090 }
1091
1092 void ScUndoPaste::Repeat(SfxRepeatTarget& rTarget)
1093 {
1094     if (rTarget.ISA(ScTabViewTarget))
1095     {
1096         ScTabViewShell* pViewSh = static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
1097         ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( pViewSh->GetActiveWin() );
1098         if (pOwnClip)
1099         {
1100             // keep a reference in case the clipboard is changed during PasteFromClip
1101             com::sun::star::uno::Reference<com::sun::star::datatransfer::XTransferable> aOwnClipRef( pOwnClip );
1102             pViewSh->PasteFromClip( nFlags, pOwnClip->GetDocument(),
1103                                     aPasteOptions.nFunction, aPasteOptions.bSkipEmpty, aPasteOptions.bTranspose,
1104                                     aPasteOptions.bAsLink, aPasteOptions.eMoveMode, IDF_NONE,
1105                                     true );     // allow warning dialog
1106         }
1107     }
1108 }
1109
1110 bool ScUndoPaste::CanRepeat(SfxRepeatTarget& rTarget) const
1111 {
1112     return rTarget.ISA(ScTabViewTarget);
1113 }
1114
1115 ScUndoDragDrop::ScUndoDragDrop( ScDocShell* pNewDocShell,
1116                     const ScRange& rRange, ScAddress aNewDestPos, bool bNewCut,
1117                     ScDocument* pUndoDocument, ScRefUndoData* pRefData, bool bScenario ) :
1118     ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFFIRST ),
1119     mnPaintExtFlags( 0 ),
1120     aSrcRange( rRange ),
1121     bCut( bNewCut ),
1122     bKeepScenarioFlags( bScenario )
1123 {
1124     ScAddress aDestEnd(aNewDestPos);
1125     aDestEnd.IncRow(aSrcRange.aEnd.Row() - aSrcRange.aStart.Row());
1126     aDestEnd.IncCol(aSrcRange.aEnd.Col() - aSrcRange.aStart.Col());
1127     aDestEnd.IncTab(aSrcRange.aEnd.Tab() - aSrcRange.aStart.Tab());
1128
1129     bool bIncludeFiltered = bCut;
1130     if ( !bIncludeFiltered )
1131     {
1132         // find number of non-filtered rows
1133         SCROW nPastedCount = pDocShell->GetDocument().CountNonFilteredRows(
1134             aSrcRange.aStart.Row(), aSrcRange.aEnd.Row(), aSrcRange.aStart.Tab());
1135
1136         if ( nPastedCount == 0 )
1137             nPastedCount = 1;
1138         aDestEnd.SetRow( aNewDestPos.Row() + nPastedCount - 1 );
1139     }
1140
1141     aDestRange.aStart = aNewDestPos;
1142     aDestRange.aEnd = aDestEnd;
1143
1144     SetChangeTrack();
1145 }
1146
1147 ScUndoDragDrop::~ScUndoDragDrop()
1148 {
1149 }
1150
1151 OUString ScUndoDragDrop::GetComment() const
1152 {   // "Move" : "Copy"
1153     return bCut ?
1154         ScGlobal::GetRscString( STR_UNDO_MOVE ) :
1155         ScGlobal::GetRscString( STR_UNDO_COPY );
1156 }
1157
1158 void ScUndoDragDrop::SetChangeTrack()
1159 {
1160     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
1161     if ( pChangeTrack )
1162     {
1163         if ( bCut )
1164         {
1165             nStartChangeAction = pChangeTrack->GetActionMax() + 1;
1166             pChangeTrack->AppendMove( aSrcRange, aDestRange, pRefUndoDoc );
1167             nEndChangeAction = pChangeTrack->GetActionMax();
1168         }
1169         else
1170             pChangeTrack->AppendContentRange( aDestRange, pRefUndoDoc,
1171                 nStartChangeAction, nEndChangeAction );
1172     }
1173     else
1174         nStartChangeAction = nEndChangeAction = 0;
1175 }
1176
1177 void ScUndoDragDrop::PaintArea( ScRange aRange, sal_uInt16 nExtFlags ) const
1178 {
1179     sal_uInt16 nPaint = PAINT_GRID;
1180     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1181     ScDocument& rDoc = pDocShell->GetDocument();
1182
1183     if (pViewShell)
1184     {
1185         ScopedVclPtrInstance< VirtualDevice > pVirtDev;
1186         ScViewData& rViewData = pViewShell->GetViewData();
1187         sc::RowHeightContext aCxt(
1188             rViewData.GetPPTX(), rViewData.GetPPTY(), rViewData.GetZoomX(), rViewData.GetZoomY(),
1189             pVirtDev);
1190
1191         if (rDoc.SetOptimalHeight(aCxt, aRange.aStart.Row(), aRange.aEnd.Row(), aRange.aStart.Tab()))
1192         {
1193             aRange.aStart.SetCol(0);
1194             aRange.aEnd.SetCol(MAXCOL);
1195             aRange.aEnd.SetRow(MAXROW);
1196             nPaint |= PAINT_LEFT;
1197         }
1198     }
1199
1200     if ( bKeepScenarioFlags )
1201     {
1202         //  Copy scenario -> also paint scenario boarder
1203         aRange.aStart.SetCol(0);
1204         aRange.aStart.SetRow(0);
1205         aRange.aEnd.SetCol(MAXCOL);
1206         aRange.aEnd.SetRow(MAXROW);
1207     }
1208
1209     //  column/row info (width/height) included if whole columns/rows were copied
1210     if ( aSrcRange.aStart.Col() == 0 && aSrcRange.aEnd.Col() == MAXCOL )
1211     {
1212         nPaint |= PAINT_LEFT;
1213         aRange.aEnd.SetRow(MAXROW);
1214     }
1215     if ( aSrcRange.aStart.Row() == 0 && aSrcRange.aEnd.Row() == MAXROW )
1216     {
1217         nPaint |= PAINT_TOP;
1218         aRange.aEnd.SetCol(MAXCOL);
1219     }
1220
1221     pDocShell->PostPaint( aRange, nPaint, nExtFlags );
1222 }
1223
1224 void ScUndoDragDrop::DoUndo( ScRange aRange )
1225 {
1226     ScDocument& rDoc = pDocShell->GetDocument();
1227
1228     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1229     if ( pChangeTrack )
1230         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1231
1232     // Database range before data, so that the Autofilter button match up in ExtendMerge
1233
1234     ScRange aPaintRange = aRange;
1235     rDoc.ExtendMerge( aPaintRange );           // before deleting
1236
1237     pDocShell->UpdatePaintExt(mnPaintExtFlags, aPaintRange);
1238
1239     // do not undo objects and note captions, they are handled via drawing undo
1240     InsertDeleteFlags nUndoFlags = (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
1241
1242     // Additionally discard/forget caption ownership during deletion, as
1243     // Drag&Drop is a special case in that the Undo holds captions of the
1244     // transfered target range, which would get deleted and
1245     // SdrGroupUndo::Undo() would attempt to access invalidated captions and
1246     // crash, tdf#92995
1247     InsertDeleteFlags nDelFlags = nUndoFlags | IDF_FORGETCAPTIONS;
1248
1249     rDoc.DeleteAreaTab( aRange, nDelFlags );
1250     pRefUndoDoc->CopyToDocument( aRange, nUndoFlags, false, &rDoc );
1251     if ( rDoc.HasAttrib( aRange, HASATTR_MERGED ) )
1252         rDoc.ExtendMerge( aRange, true );
1253
1254     aPaintRange.aEnd.SetCol( std::max( aPaintRange.aEnd.Col(), aRange.aEnd.Col() ) );
1255     aPaintRange.aEnd.SetRow( std::max( aPaintRange.aEnd.Row(), aRange.aEnd.Row() ) );
1256
1257     pDocShell->UpdatePaintExt(mnPaintExtFlags, aPaintRange);
1258     maPaintRanges.Join(aPaintRange);
1259 }
1260
1261 namespace {
1262
1263 class DataChangeNotifier : std::unary_function<SvtListener*, void>
1264 {
1265     ScHint maHint;
1266 public:
1267     DataChangeNotifier() : maHint(SC_HINT_DATACHANGED, ScAddress()) {}
1268
1269     void operator() ( SvtListener* p )
1270     {
1271         p->Notify(maHint);
1272     }
1273 };
1274
1275 }
1276
1277 void ScUndoDragDrop::Undo()
1278 {
1279     mnPaintExtFlags = 0;
1280     maPaintRanges.RemoveAll();
1281
1282     BeginUndo();
1283
1284     if (bCut)
1285     {
1286         // During undo, we move cells from aDestRange to aSrcRange.
1287
1288         ScDocument& rDoc = pDocShell->GetDocument();
1289
1290         SCCOL nColDelta = aSrcRange.aStart.Col() - aDestRange.aStart.Col();
1291         SCROW nRowDelta = aSrcRange.aStart.Row() - aDestRange.aStart.Row();
1292         SCTAB nTabDelta = aSrcRange.aStart.Tab() - aDestRange.aStart.Tab();
1293
1294         sc::RefUpdateContext aCxt(rDoc);
1295         aCxt.meMode = URM_MOVE;
1296         aCxt.maRange = aSrcRange;
1297         aCxt.mnColDelta = nColDelta;
1298         aCxt.mnRowDelta = nRowDelta;
1299         aCxt.mnTabDelta = nTabDelta;
1300
1301         // Global range names.
1302         ScRangeName* pName = rDoc.GetRangeName();
1303         if (pName)
1304             pName->UpdateReference(aCxt);
1305
1306         SCTAB nTabCount = rDoc.GetTableCount();
1307         for (SCTAB nTab = 0; nTab < nTabCount; ++nTab)
1308         {
1309             // Sheet-local range names.
1310             pName = rDoc.GetRangeName(nTab);
1311             if (pName)
1312                 pName->UpdateReference(aCxt, nTab);
1313         }
1314
1315         // Notify all listeners of the destination range, and have them update their references.
1316         sc::RefMovedHint aHint(aDestRange, ScAddress(nColDelta, nRowDelta, nTabDelta), aCxt);
1317         rDoc.BroadcastRefMoved(aHint);
1318
1319         ScValidationDataList* pValidList = rDoc.GetValidationList();
1320         if (pValidList)
1321         {
1322             // Update the references of validation entries.
1323             pValidList->UpdateReference(aCxt);
1324         }
1325
1326         DoUndo(aDestRange);
1327         DoUndo(aSrcRange);
1328
1329         // Notify all area listeners whose listened areas are partially moved, to
1330         // recalculate.
1331         std::vector<SvtListener*> aListeners;
1332         rDoc.CollectAllAreaListeners(aListeners, aSrcRange, sc::AreaPartialOverlap);
1333
1334         // Remove any duplicate listener entries.  We must ensure that we notify
1335         // each unique listener only once.
1336         std::sort(aListeners.begin(), aListeners.end());
1337         aListeners.erase(std::unique(aListeners.begin(), aListeners.end()), aListeners.end());
1338
1339         std::for_each(aListeners.begin(), aListeners.end(), DataChangeNotifier());
1340     }
1341     else
1342         DoUndo(aDestRange);
1343
1344     for (size_t i = 0; i < maPaintRanges.size(); ++i)
1345     {
1346         const ScRange* p = maPaintRanges[i];
1347         PaintArea(*p, mnPaintExtFlags);
1348     }
1349
1350     EndUndo();
1351     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1352 }
1353
1354 void ScUndoDragDrop::Redo()
1355 {
1356     BeginRedo();
1357
1358     ScDocument& rDoc = pDocShell->GetDocument();
1359     boost::scoped_ptr<ScDocument> pClipDoc(new ScDocument( SCDOCMODE_CLIP ));
1360
1361     EnableDrawAdjust( &rDoc, false );                //! include in ScBlockUndo?
1362
1363     // do not undo/redo objects and note captions, they are handled via drawing undo
1364     InsertDeleteFlags nRedoFlags = (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
1365
1366     /*  TODO: Redoing note captions is quite tricky due to the fact that a
1367         helper clip document is used. While (re-)pasting the contents to the
1368         destination area, the original pointers to the captions created while
1369         dropping have to be restored. A simple CopyFromClip() would create new
1370         caption objects that are not tracked by drawing undo, and the captions
1371         restored by drawing redo would live without cell note objects pointing
1372         to them. So, first, CopyToClip() and CopyFromClip() are called without
1373         cloning the caption objects. This leads to cell notes pointing to the
1374         wrong captions from source area that will be removed by drawing redo
1375         later. Second, the pointers to the new captions have to be restored.
1376         Sadly, currently these pointers are not stored anywhere but in the list
1377         of drawing undo actions. */
1378
1379     SCTAB nTab;
1380     ScMarkData aSourceMark;
1381     for (nTab=aSrcRange.aStart.Tab(); nTab<=aSrcRange.aEnd.Tab(); nTab++)
1382         aSourceMark.SelectTable( nTab, true );
1383
1384     // do not clone objects and note captions into clipdoc (see above)
1385     // but at least copy notes
1386     ScClipParam aClipParam(aSrcRange, bCut);
1387     rDoc.CopyToClip(aClipParam, pClipDoc.get(), &aSourceMark, false, bKeepScenarioFlags, false, true);
1388
1389     if (bCut)
1390     {
1391         ScRange aSrcPaintRange = aSrcRange;
1392         rDoc.ExtendMerge( aSrcPaintRange );            // before deleting
1393         sal_uInt16 nExtFlags = 0;
1394         pDocShell->UpdatePaintExt( nExtFlags, aSrcPaintRange );
1395         rDoc.DeleteAreaTab( aSrcRange, nRedoFlags );
1396         PaintArea( aSrcPaintRange, nExtFlags );
1397     }
1398
1399     ScMarkData aDestMark;
1400     for (nTab=aDestRange.aStart.Tab(); nTab<=aDestRange.aEnd.Tab(); nTab++)
1401         aDestMark.SelectTable( nTab, true );
1402
1403     bool bIncludeFiltered = bCut;
1404     // TODO: restore old note captions instead of cloning new captions...
1405     rDoc.CopyFromClip( aDestRange, aDestMark, IDF_ALL & ~IDF_OBJECTS, NULL, pClipDoc.get(), true, false, bIncludeFiltered );
1406
1407     if (bCut)
1408         for (nTab=aSrcRange.aStart.Tab(); nTab<=aSrcRange.aEnd.Tab(); nTab++)
1409             rDoc.RefreshAutoFilter( aSrcRange.aStart.Col(), aSrcRange.aStart.Row(),
1410                                      aSrcRange.aEnd.Col(),   aSrcRange.aEnd.Row(), nTab );
1411
1412     // skipped rows and merged cells don't mix
1413     if ( !bIncludeFiltered && pClipDoc->HasClipFilteredRows() )
1414         pDocShell->GetDocFunc().UnmergeCells( aDestRange, false );
1415
1416     for (nTab=aDestRange.aStart.Tab(); nTab<=aDestRange.aEnd.Tab(); nTab++)
1417     {
1418         SCCOL nEndCol = aDestRange.aEnd.Col();
1419         SCROW nEndRow = aDestRange.aEnd.Row();
1420         rDoc.ExtendMerge( aDestRange.aStart.Col(), aDestRange.aStart.Row(),
1421                             nEndCol, nEndRow, nTab, true );
1422         PaintArea( ScRange( aDestRange.aStart.Col(), aDestRange.aStart.Row(), nTab,
1423                             nEndCol, nEndRow, nTab ), 0 );
1424     }
1425
1426     SetChangeTrack();
1427
1428     pClipDoc.reset();
1429     ShowTable( aDestRange.aStart.Tab() );
1430
1431     RedoSdrUndoAction( pDrawUndo );             //! include in ScBlockUndo?
1432     EnableDrawAdjust( &rDoc, true );             //! include in ScBlockUndo?
1433
1434     EndRedo();
1435     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1436 }
1437
1438 void ScUndoDragDrop::Repeat(SfxRepeatTarget& /* rTarget */)
1439 {
1440 }
1441
1442 bool ScUndoDragDrop::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1443 {
1444     return false;           // not possible
1445 }
1446
1447 //      Insert list containing range names
1448 //      (Insert|Name|Insert =>[List])
1449 ScUndoListNames::ScUndoListNames( ScDocShell* pNewDocShell, const ScRange& rRange,
1450                 ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc ) :
1451     ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
1452     pUndoDoc( pNewUndoDoc ),
1453     pRedoDoc( pNewRedoDoc )
1454 {
1455 }
1456
1457 ScUndoListNames::~ScUndoListNames()
1458 {
1459     delete pUndoDoc;
1460     delete pRedoDoc;
1461 }
1462
1463 OUString ScUndoListNames::GetComment() const
1464 {
1465     return ScGlobal::GetRscString( STR_UNDO_LISTNAMES );
1466 }
1467
1468 void ScUndoListNames::DoChange( ScDocument* pSrcDoc ) const
1469 {
1470     ScDocument& rDoc = pDocShell->GetDocument();
1471
1472     rDoc.DeleteAreaTab( aBlockRange, IDF_ALL );
1473     pSrcDoc->CopyToDocument( aBlockRange, IDF_ALL, false, &rDoc );
1474     pDocShell->PostPaint( aBlockRange, PAINT_GRID );
1475     pDocShell->PostDataChanged();
1476     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1477     if (pViewShell)
1478         pViewShell->CellContentChanged();
1479 }
1480
1481 void ScUndoListNames::Undo()
1482 {
1483     BeginUndo();
1484     DoChange(pUndoDoc);
1485     EndUndo();
1486 }
1487
1488 void ScUndoListNames::Redo()
1489 {
1490     BeginRedo();
1491     DoChange(pRedoDoc);
1492     EndRedo();
1493 }
1494
1495 void ScUndoListNames::Repeat(SfxRepeatTarget& rTarget)
1496 {
1497     if (rTarget.ISA(ScTabViewTarget))
1498         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->InsertNameList();
1499 }
1500
1501 bool ScUndoListNames::CanRepeat(SfxRepeatTarget& rTarget) const
1502 {
1503     return rTarget.ISA(ScTabViewTarget);
1504 }
1505
1506 ScUndoConditionalFormat::ScUndoConditionalFormat(ScDocShell* pNewDocShell,
1507         ScDocument* pUndoDoc, ScDocument* pRedoDoc, const ScRange& rRange):
1508     ScSimpleUndo( pNewDocShell ),
1509     mpUndoDoc(pUndoDoc),
1510     mpRedoDoc(pRedoDoc),
1511     maRange(rRange)
1512 {
1513 }
1514
1515 ScUndoConditionalFormat::~ScUndoConditionalFormat()
1516 {
1517 }
1518
1519 OUString ScUndoConditionalFormat::GetComment() const
1520 {
1521     return ScGlobal::GetRscString( STR_UNDO_CONDFORMAT );
1522 }
1523
1524 void ScUndoConditionalFormat::Undo()
1525 {
1526     DoChange(mpUndoDoc.get());
1527 }
1528
1529 void ScUndoConditionalFormat::Redo()
1530 {
1531     DoChange(mpRedoDoc.get());
1532 }
1533
1534 void ScUndoConditionalFormat::DoChange(ScDocument* pSrcDoc)
1535 {
1536     ScDocument& rDoc = pDocShell->GetDocument();
1537
1538     rDoc.DeleteAreaTab( maRange, IDF_ALL );
1539     pSrcDoc->CopyToDocument( maRange, IDF_ALL, false, &rDoc );
1540     pDocShell->PostPaint( maRange, PAINT_GRID );
1541     pDocShell->PostDataChanged();
1542     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1543     if (pViewShell)
1544         pViewShell->CellContentChanged();
1545 }
1546
1547 void ScUndoConditionalFormat::Repeat(SfxRepeatTarget& )
1548 {
1549 }
1550
1551 bool ScUndoConditionalFormat::CanRepeat(SfxRepeatTarget& ) const
1552 {
1553     return false;
1554 }
1555
1556 ScUndoUseScenario::ScUndoUseScenario( ScDocShell* pNewDocShell,
1557                         const ScMarkData& rMark,
1558 /*C*/                   const ScArea& rDestArea,
1559                               ScDocument* pNewUndoDoc,
1560                         const OUString& rNewName ) :
1561     ScSimpleUndo( pNewDocShell ),
1562     pUndoDoc( pNewUndoDoc ),
1563     aMarkData( rMark ),
1564     aName( rNewName )
1565 {
1566     aRange.aStart.SetCol(rDestArea.nColStart);
1567     aRange.aStart.SetRow(rDestArea.nRowStart);
1568     aRange.aStart.SetTab(rDestArea.nTab);
1569     aRange.aEnd.SetCol(rDestArea.nColEnd);
1570     aRange.aEnd.SetRow(rDestArea.nRowEnd);
1571     aRange.aEnd.SetTab(rDestArea.nTab);
1572 }
1573
1574 ScUndoUseScenario::~ScUndoUseScenario()
1575 {
1576     delete pUndoDoc;
1577 }
1578
1579 OUString ScUndoUseScenario::GetComment() const
1580 {
1581     return ScGlobal::GetRscString( STR_UNDO_USESCENARIO );
1582 }
1583
1584 void ScUndoUseScenario::Undo()
1585 {
1586     BeginUndo();
1587
1588     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1589     if (pViewShell)
1590     {
1591         pViewShell->DoneBlockMode();
1592         pViewShell->InitOwnBlockMode();
1593     }
1594
1595     ScDocument& rDoc = pDocShell->GetDocument();
1596     rDoc.DeleteSelection( IDF_ALL, aMarkData );
1597     pUndoDoc->CopyToDocument( aRange, IDF_ALL, true, &rDoc, &aMarkData );
1598
1599     // scenario table
1600     bool bFrame = false;
1601     SCTAB nTab = aRange.aStart.Tab();
1602     SCTAB nEndTab = nTab;
1603     while ( pUndoDoc->HasTable(nEndTab+1) && pUndoDoc->IsScenario(nEndTab+1) )
1604         ++nEndTab;
1605     for (SCTAB i = nTab+1; i<=nEndTab; i++)
1606     {
1607         // Flags always
1608         OUString aComment;
1609         Color  aColor;
1610         sal_uInt16 nScenFlags;
1611         pUndoDoc->GetScenarioData( i, aComment, aColor, nScenFlags );
1612         rDoc.SetScenarioData( i, aComment, aColor, nScenFlags );
1613         bool bActive = pUndoDoc->IsActiveScenario( i );
1614         rDoc.SetActiveScenario( i, bActive );
1615         //  For copy-back scenario also consider content
1616         if ( nScenFlags & SC_SCENARIO_TWOWAY )
1617         {
1618             rDoc.DeleteAreaTab( 0,0, MAXCOL,MAXROW, i, IDF_ALL );
1619             pUndoDoc->CopyToDocument( 0,0,i, MAXCOL,MAXROW,i, IDF_ALL,false, &rDoc );
1620         }
1621         if ( nScenFlags & SC_SCENARIO_SHOWFRAME )
1622             bFrame = true;
1623     }
1624
1625     // if visible borders, then paint all
1626     if (bFrame)
1627         pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_EXTRAS );
1628     else
1629         pDocShell->PostPaint( aRange, PAINT_GRID | PAINT_EXTRAS );
1630     pDocShell->PostDataChanged();
1631     if (pViewShell)
1632         pViewShell->CellContentChanged();
1633
1634     ShowTable( aRange.aStart.Tab() );
1635
1636     EndUndo();
1637 }
1638
1639 void ScUndoUseScenario::Redo()
1640 {
1641     SCTAB nTab = aRange.aStart.Tab();
1642     BeginRedo();
1643
1644     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1645     if (pViewShell)
1646     {
1647         pViewShell->SetTabNo( nTab );
1648         pViewShell->DoneBlockMode();
1649         pViewShell->InitOwnBlockMode();
1650     }
1651
1652     pDocShell->UseScenario( nTab, aName, false );
1653
1654     EndRedo();
1655 }
1656
1657 void ScUndoUseScenario::Repeat(SfxRepeatTarget& rTarget)
1658 {
1659     if (rTarget.ISA(ScTabViewTarget))
1660     {
1661         OUString aTemp = aName;
1662         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->UseScenario(aTemp);
1663     }
1664 }
1665
1666 bool ScUndoUseScenario::CanRepeat(SfxRepeatTarget& rTarget) const
1667 {
1668     if (rTarget.ISA(ScTabViewTarget))
1669     {
1670         ScViewData& rViewData = static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData();
1671         return !rViewData.GetDocument()->IsScenario( rViewData.GetTabNo() );
1672     }
1673     return false;
1674 }
1675
1676 ScUndoSelectionStyle::ScUndoSelectionStyle( ScDocShell* pNewDocShell,
1677                                       const ScMarkData& rMark,
1678                                       const ScRange& rRange,
1679                                       const OUString& rName,
1680                                             ScDocument* pNewUndoDoc ) :
1681     ScSimpleUndo( pNewDocShell ),
1682     aMarkData( rMark ),
1683     pUndoDoc( pNewUndoDoc ),
1684     aStyleName( rName ),
1685     aRange( rRange )
1686 {
1687     aMarkData.MarkToMulti();
1688 }
1689
1690 ScUndoSelectionStyle::~ScUndoSelectionStyle()
1691 {
1692     delete pUndoDoc;
1693 }
1694
1695 OUString ScUndoSelectionStyle::GetComment() const
1696 {
1697     return ScGlobal::GetRscString( STR_UNDO_APPLYCELLSTYLE );
1698 }
1699
1700 void ScUndoSelectionStyle::DoChange( const bool bUndo )
1701 {
1702     ScDocument& rDoc = pDocShell->GetDocument();
1703
1704     SetViewMarkData( aMarkData );
1705
1706     ScRange aWorkRange( aRange );
1707     if ( rDoc.HasAttrib( aWorkRange, HASATTR_MERGED ) )        // Merged cells?
1708         rDoc.ExtendMerge( aWorkRange, true );
1709
1710     sal_uInt16 nExtFlags = 0;
1711     pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
1712
1713     if (bUndo)      // if Undo then push back all old data again
1714     {
1715         SCTAB nTabCount = rDoc.GetTableCount();
1716         ScRange aCopyRange = aWorkRange;
1717         aCopyRange.aStart.SetTab(0);
1718         aCopyRange.aEnd.SetTab(nTabCount-1);
1719         pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, true, &rDoc, &aMarkData );
1720     }
1721     else            // if Redo, then reapply style
1722     {
1723         ScStyleSheetPool* pStlPool = rDoc.GetStyleSheetPool();
1724         ScStyleSheet* pStyleSheet =
1725             static_cast<ScStyleSheet*>( pStlPool->Find( aStyleName, SFX_STYLE_FAMILY_PARA ) );
1726         if (!pStyleSheet)
1727         {
1728             OSL_FAIL("StyleSheet not found");
1729             return;
1730         }
1731         rDoc.ApplySelectionStyle( *pStyleSheet, aMarkData );
1732     }
1733
1734     pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
1735
1736     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1737     if ( !( (pViewShell) && pViewShell->AdjustBlockHeight() ) )
1738 /*A*/   pDocShell->PostPaint( aWorkRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );
1739
1740     ShowTable( aWorkRange.aStart.Tab() );
1741 }
1742
1743 void ScUndoSelectionStyle::Undo()
1744 {
1745     BeginUndo();
1746     DoChange( true );
1747     EndUndo();
1748 }
1749
1750 void ScUndoSelectionStyle::Redo()
1751 {
1752     BeginRedo();
1753     DoChange( false );
1754     EndRedo();
1755 }
1756
1757 void ScUndoSelectionStyle::Repeat(SfxRepeatTarget& rTarget)
1758 {
1759     if (rTarget.ISA(ScTabViewTarget))
1760     {
1761         ScDocument& rDoc = pDocShell->GetDocument();
1762         ScStyleSheetPool* pStlPool = rDoc.GetStyleSheetPool();
1763         ScStyleSheet* pStyleSheet = static_cast<ScStyleSheet*>( pStlPool->
1764                                             Find( aStyleName, SFX_STYLE_FAMILY_PARA ));
1765         if (!pStyleSheet)
1766         {
1767             OSL_FAIL("StyleSheet not found");
1768             return;
1769         }
1770
1771         ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
1772         rViewShell.SetStyleSheetToMarked( pStyleSheet, true );
1773     }
1774 }
1775
1776 bool ScUndoSelectionStyle::CanRepeat(SfxRepeatTarget& rTarget) const
1777 {
1778     return rTarget.ISA(ScTabViewTarget);
1779 }
1780
1781 sal_uInt16 ScUndoSelectionStyle::GetId() const
1782 {
1783     return STR_UNDO_APPLYCELLSTYLE;
1784 }
1785
1786 ScUndoEnterMatrix::ScUndoEnterMatrix( ScDocShell* pNewDocShell, const ScRange& rArea,
1787                                       ScDocument* pNewUndoDoc, const OUString& rForm ) :
1788     ScBlockUndo( pNewDocShell, rArea, SC_UNDO_SIMPLE ),
1789     pUndoDoc( pNewUndoDoc ),
1790     aFormula( rForm )
1791 {
1792     SetChangeTrack();
1793 }
1794
1795 ScUndoEnterMatrix::~ScUndoEnterMatrix()
1796 {
1797     delete pUndoDoc;
1798 }
1799
1800 OUString ScUndoEnterMatrix::GetComment() const
1801 {
1802     return ScGlobal::GetRscString( STR_UNDO_ENTERMATRIX );
1803 }
1804
1805 void ScUndoEnterMatrix::SetChangeTrack()
1806 {
1807     ScDocument& rDoc = pDocShell->GetDocument();
1808     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1809     if ( pChangeTrack )
1810         pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
1811             nStartChangeAction, nEndChangeAction );
1812     else
1813         nStartChangeAction = nEndChangeAction = 0;
1814 }
1815
1816 void ScUndoEnterMatrix::Undo()
1817 {
1818     BeginUndo();
1819
1820     ScDocument& rDoc = pDocShell->GetDocument();
1821
1822     rDoc.DeleteAreaTab( aBlockRange, IDF_ALL & ~IDF_NOTE );
1823     pUndoDoc->CopyToDocument( aBlockRange, IDF_ALL & ~IDF_NOTE, false, &rDoc );
1824     pDocShell->PostPaint( aBlockRange, PAINT_GRID );
1825     pDocShell->PostDataChanged();
1826     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1827     if (pViewShell)
1828         pViewShell->CellContentChanged();
1829
1830     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1831     if ( pChangeTrack )
1832         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1833
1834     EndUndo();
1835 }
1836
1837 void ScUndoEnterMatrix::Redo()
1838 {
1839     BeginRedo();
1840
1841     ScDocument& rDoc = pDocShell->GetDocument();
1842
1843     ScMarkData aDestMark;
1844     aDestMark.SelectOneTable( aBlockRange.aStart.Tab() );
1845     aDestMark.SetMarkArea( aBlockRange );
1846
1847     rDoc.InsertMatrixFormula( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
1848                                aBlockRange.aEnd.Col(),   aBlockRange.aEnd.Row(),
1849                                aDestMark, aFormula );
1850
1851     SetChangeTrack();
1852
1853     EndRedo();
1854 }
1855
1856 void ScUndoEnterMatrix::Repeat(SfxRepeatTarget& rTarget)
1857 {
1858     if (rTarget.ISA(ScTabViewTarget))
1859     {
1860         OUString aTemp = aFormula;
1861         ScDocument& rDoc = pDocShell->GetDocument();
1862         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->EnterMatrix(aTemp, rDoc.GetGrammar());
1863     }
1864 }
1865
1866 bool ScUndoEnterMatrix::CanRepeat(SfxRepeatTarget& rTarget) const
1867 {
1868     return rTarget.ISA(ScTabViewTarget);
1869 }
1870
1871 static ScRange lcl_GetMultiMarkRange( const ScMarkData& rMark )
1872 {
1873     OSL_ENSURE( rMark.IsMultiMarked(), "wrong mark type" );
1874
1875     ScRange aRange;
1876     rMark.GetMultiMarkArea( aRange );
1877     return aRange;
1878 }
1879
1880 ScUndoIndent::ScUndoIndent( ScDocShell* pNewDocShell, const ScMarkData& rMark,
1881                             ScDocument* pNewUndoDoc, bool bIncrement ) :
1882     ScBlockUndo( pNewDocShell, lcl_GetMultiMarkRange(rMark), SC_UNDO_AUTOHEIGHT ),
1883     aMarkData( rMark ),
1884     pUndoDoc( pNewUndoDoc ),
1885     bIsIncrement( bIncrement )
1886 {
1887 }
1888
1889 ScUndoIndent::~ScUndoIndent()
1890 {
1891     delete pUndoDoc;
1892 }
1893
1894 OUString ScUndoIndent::GetComment() const
1895 {
1896     sal_uInt16 nId = bIsIncrement ? STR_UNDO_INC_INDENT : STR_UNDO_DEC_INDENT;
1897     return ScGlobal::GetRscString( nId );
1898 }
1899
1900 void ScUndoIndent::Undo()
1901 {
1902     BeginUndo();
1903
1904     ScDocument& rDoc = pDocShell->GetDocument();
1905     SCTAB nTabCount = rDoc.GetTableCount();
1906     ScRange aCopyRange = aBlockRange;
1907     aCopyRange.aStart.SetTab(0);
1908     aCopyRange.aEnd.SetTab(nTabCount-1);
1909     pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, true, &rDoc, &aMarkData );
1910     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
1911
1912     EndUndo();
1913 }
1914
1915 void ScUndoIndent::Redo()
1916 {
1917     BeginRedo();
1918
1919     ScDocument& rDoc = pDocShell->GetDocument();
1920     rDoc.ChangeSelectionIndent( bIsIncrement, aMarkData );
1921     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
1922
1923     EndRedo();
1924 }
1925
1926 void ScUndoIndent::Repeat(SfxRepeatTarget& rTarget)
1927 {
1928     if (rTarget.ISA(ScTabViewTarget))
1929         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->ChangeIndent( bIsIncrement );
1930 }
1931
1932 bool ScUndoIndent::CanRepeat(SfxRepeatTarget& rTarget) const
1933 {
1934     return rTarget.ISA(ScTabViewTarget);
1935 }
1936
1937 ScUndoTransliterate::ScUndoTransliterate( ScDocShell* pNewDocShell, const ScMarkData& rMark,
1938                             ScDocument* pNewUndoDoc, sal_Int32 nType ) :
1939     ScBlockUndo( pNewDocShell, lcl_GetMultiMarkRange(rMark), SC_UNDO_AUTOHEIGHT ),
1940     aMarkData( rMark ),
1941     pUndoDoc( pNewUndoDoc ),
1942     nTransliterationType( nType )
1943 {
1944 }
1945
1946 ScUndoTransliterate::~ScUndoTransliterate()
1947 {
1948     delete pUndoDoc;
1949 }
1950
1951 OUString ScUndoTransliterate::GetComment() const
1952 {
1953     return ScGlobal::GetRscString( STR_UNDO_TRANSLITERATE );
1954 }
1955
1956 void ScUndoTransliterate::Undo()
1957 {
1958     BeginUndo();
1959
1960     ScDocument& rDoc = pDocShell->GetDocument();
1961     SCTAB nTabCount = rDoc.GetTableCount();
1962     ScRange aCopyRange = aBlockRange;
1963     aCopyRange.aStart.SetTab(0);
1964     aCopyRange.aEnd.SetTab(nTabCount-1);
1965     pUndoDoc->CopyToDocument( aCopyRange, IDF_CONTENTS, true, &rDoc, &aMarkData );
1966     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
1967
1968     EndUndo();
1969 }
1970
1971 void ScUndoTransliterate::Redo()
1972 {
1973     BeginRedo();
1974
1975     ScDocument& rDoc = pDocShell->GetDocument();
1976     rDoc.TransliterateText( aMarkData, nTransliterationType );
1977     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
1978
1979     EndRedo();
1980 }
1981
1982 void ScUndoTransliterate::Repeat(SfxRepeatTarget& rTarget)
1983 {
1984     if (rTarget.ISA(ScTabViewTarget))
1985         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->TransliterateText( nTransliterationType );
1986 }
1987
1988 bool ScUndoTransliterate::CanRepeat(SfxRepeatTarget& rTarget) const
1989 {
1990     return rTarget.ISA(ScTabViewTarget);
1991 }
1992
1993 ScUndoClearItems::ScUndoClearItems( ScDocShell* pNewDocShell, const ScMarkData& rMark,
1994                             ScDocument* pNewUndoDoc, const sal_uInt16* pW ) :
1995     ScBlockUndo( pNewDocShell, lcl_GetMultiMarkRange(rMark), SC_UNDO_AUTOHEIGHT ),
1996     aMarkData( rMark ),
1997     pUndoDoc( pNewUndoDoc ),
1998     pWhich( NULL )
1999 {
2000     OSL_ENSURE( pW, "ScUndoClearItems: Which-Pointer ist 0" );
2001
2002     sal_uInt16 nCount = 0;
2003     while ( pW[nCount] )
2004         ++nCount;
2005     pWhich = new sal_uInt16[nCount+1];
2006     for (sal_uInt16 i=0; i<=nCount; i++)
2007         pWhich[i] = pW[i];
2008 }
2009
2010 ScUndoClearItems::~ScUndoClearItems()
2011 {
2012     delete pUndoDoc;
2013     delete pWhich;
2014 }
2015
2016 OUString ScUndoClearItems::GetComment() const
2017 {
2018     return ScGlobal::GetRscString( STR_UNDO_DELETECONTENTS );
2019 }
2020
2021 void ScUndoClearItems::Undo()
2022 {
2023     BeginUndo();
2024
2025     ScDocument& rDoc = pDocShell->GetDocument();
2026     pUndoDoc->CopyToDocument( aBlockRange, IDF_ATTRIB, true, &rDoc, &aMarkData );
2027     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
2028
2029     EndUndo();
2030 }
2031
2032 void ScUndoClearItems::Redo()
2033 {
2034     BeginRedo();
2035
2036     ScDocument& rDoc = pDocShell->GetDocument();
2037     rDoc.ClearSelectionItems( pWhich, aMarkData );
2038     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
2039
2040     EndRedo();
2041 }
2042
2043 void ScUndoClearItems::Repeat(SfxRepeatTarget& rTarget)
2044 {
2045     if (rTarget.ISA(ScTabViewTarget))
2046     {
2047         ScViewData& rViewData = static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData();
2048         rViewData.GetDocFunc().ClearItems( rViewData.GetMarkData(), pWhich, false );
2049     }
2050 }
2051
2052 bool ScUndoClearItems::CanRepeat(SfxRepeatTarget& rTarget) const
2053 {
2054     return rTarget.ISA(ScTabViewTarget);
2055 }
2056
2057 // remove all line breaks of a table
2058 ScUndoRemoveBreaks::ScUndoRemoveBreaks( ScDocShell* pNewDocShell,
2059                                     SCTAB nNewTab, ScDocument* pNewUndoDoc ) :
2060     ScSimpleUndo( pNewDocShell ),
2061     nTab( nNewTab ),
2062     pUndoDoc( pNewUndoDoc )
2063 {
2064 }
2065
2066 ScUndoRemoveBreaks::~ScUndoRemoveBreaks()
2067 {
2068     delete pUndoDoc;
2069 }
2070
2071 OUString ScUndoRemoveBreaks::GetComment() const
2072 {
2073     return ScGlobal::GetRscString( STR_UNDO_REMOVEBREAKS );
2074 }
2075
2076 void ScUndoRemoveBreaks::Undo()
2077 {
2078     BeginUndo();
2079
2080     ScDocument& rDoc = pDocShell->GetDocument();
2081     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2082
2083     pUndoDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, false, &rDoc );
2084     if (pViewShell)
2085         pViewShell->UpdatePageBreakData( true );
2086     pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
2087
2088     EndUndo();
2089 }
2090
2091 void ScUndoRemoveBreaks::Redo()
2092 {
2093     BeginRedo();
2094
2095     ScDocument& rDoc = pDocShell->GetDocument();
2096     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2097
2098     rDoc.RemoveManualBreaks(nTab);
2099     rDoc.UpdatePageBreaks(nTab);
2100     if (pViewShell)
2101         pViewShell->UpdatePageBreakData( true );
2102     pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
2103
2104     EndRedo();
2105 }
2106
2107 void ScUndoRemoveBreaks::Repeat(SfxRepeatTarget& rTarget)
2108 {
2109     if (rTarget.ISA(ScTabViewTarget))
2110     {
2111         ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
2112         rViewShell.RemoveManualBreaks();
2113     }
2114 }
2115
2116 bool ScUndoRemoveBreaks::CanRepeat(SfxRepeatTarget& rTarget) const
2117 {
2118     return rTarget.ISA(ScTabViewTarget);
2119 }
2120
2121 ScUndoRemoveMerge::ScUndoRemoveMerge( ScDocShell* pNewDocShell,
2122                                       const ScCellMergeOption& rOption, ScDocument* pNewUndoDoc ) :
2123     ScBlockUndo( pNewDocShell, rOption.getFirstSingleRange(), SC_UNDO_SIMPLE ),
2124     maOption(rOption),
2125     pUndoDoc( pNewUndoDoc )
2126 {
2127 }
2128
2129 ScUndoRemoveMerge::~ScUndoRemoveMerge()
2130 {
2131     delete pUndoDoc;
2132 }
2133
2134 OUString ScUndoRemoveMerge::GetComment() const
2135 {
2136     return ScGlobal::GetRscString( STR_UNDO_REMERGE );  // "remove merge"
2137 }
2138
2139 void ScUndoRemoveMerge::Undo()
2140 {
2141     using ::std::set;
2142
2143     SetCurTab();
2144     BeginUndo();
2145
2146     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2147
2148     ScDocument& rDoc = pDocShell->GetDocument();
2149     for (set<SCTAB>::const_iterator itr = maOption.maTabs.begin(), itrEnd = maOption.maTabs.end();
2150           itr != itrEnd; ++itr)
2151     {
2152         OSL_ENSURE(pUndoDoc, "NULL pUndoDoc!");
2153         if (!pUndoDoc)
2154             continue;
2155         // There is no need to extend merge area because it's already been extended.
2156         ScRange aRange = maOption.getSingleRange(*itr);
2157         rDoc.DeleteAreaTab(aRange, IDF_ATTRIB);
2158         pUndoDoc->CopyToDocument(aRange, IDF_ATTRIB, false, &rDoc);
2159
2160         bool bDidPaint = false;
2161         if ( pViewShell )
2162         {
2163             pViewShell->SetTabNo(*itr);
2164             bDidPaint = pViewShell->AdjustRowHeight(maOption.mnStartRow, maOption.mnEndRow);
2165         }
2166         if (!bDidPaint)
2167             ScUndoUtil::PaintMore(pDocShell, aRange);
2168     }
2169
2170     EndUndo();
2171 }
2172
2173 void ScUndoRemoveMerge::Redo()
2174 {
2175     using ::std::set;
2176
2177     SetCurTab();
2178     BeginRedo();
2179
2180     ScDocument& rDoc = pDocShell->GetDocument();
2181     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2182
2183     for (set<SCTAB>::const_iterator itr = maOption.maTabs.begin(), itrEnd = maOption.maTabs.end();
2184           itr != itrEnd; ++itr)
2185     {
2186         SCTAB nTab = *itr;
2187         // There is no need to extend merge area because it's already been extended.
2188         ScRange aRange = maOption.getSingleRange(nTab);
2189
2190         const SfxPoolItem& rDefAttr = rDoc.GetPool()->GetDefaultItem( ATTR_MERGE );
2191         ScPatternAttr aPattern( rDoc.GetPool() );
2192         aPattern.GetItemSet().Put( rDefAttr );
2193         rDoc.ApplyPatternAreaTab( maOption.mnStartCol, maOption.mnStartRow,
2194                                    maOption.mnEndCol, maOption.mnEndRow, nTab,
2195                                    aPattern );
2196
2197         rDoc.RemoveFlagsTab( maOption.mnStartCol, maOption.mnStartRow,
2198                               maOption.mnEndCol, maOption.mnEndRow, nTab,
2199                               SC_MF_HOR | SC_MF_VER );
2200
2201         rDoc.ExtendMerge(aRange, true);
2202
2203         //  Paint
2204
2205         bool bDidPaint = false;
2206         if ( pViewShell )
2207         {
2208             pViewShell->SetTabNo(nTab);
2209             bDidPaint = pViewShell->AdjustRowHeight(maOption.mnStartRow, maOption.mnEndRow);
2210         }
2211         if (!bDidPaint)
2212             ScUndoUtil::PaintMore(pDocShell, aRange);
2213     }
2214
2215     EndRedo();
2216 }
2217
2218 void ScUndoRemoveMerge::Repeat(SfxRepeatTarget& rTarget)
2219 {
2220     if (rTarget.ISA(ScTabViewTarget))
2221         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->RemoveMerge();
2222 }
2223
2224 bool ScUndoRemoveMerge::CanRepeat(SfxRepeatTarget& rTarget) const
2225 {
2226     return rTarget.ISA(ScTabViewTarget);
2227 }
2228
2229 void ScUndoRemoveMerge::SetCurTab()
2230 {
2231     SCTAB nCurTab = ScDocShell::GetCurTab();
2232     aBlockRange.aStart.SetTab(nCurTab);
2233     aBlockRange.aEnd.SetTab(nCurTab);
2234 }
2235
2236 /** set only border, for ScRangeList (StarOne) */
2237 static ScRange lcl_TotalRange( const ScRangeList& rRanges )
2238 {
2239     ScRange aTotal;
2240     if ( !rRanges.empty() )
2241     {
2242         aTotal = *rRanges[ 0 ];
2243         for ( size_t i = 1, nCount = rRanges.size(); i < nCount; ++i )
2244         {
2245             ScRange aRange = *rRanges[ i ];
2246             if (aRange.aStart.Col() < aTotal.aStart.Col()) aTotal.aStart.SetCol(aRange.aStart.Col());
2247             if (aRange.aStart.Row() < aTotal.aStart.Row()) aTotal.aStart.SetRow(aRange.aStart.Row());
2248             if (aRange.aStart.Tab() < aTotal.aStart.Tab()) aTotal.aStart.SetTab(aRange.aStart.Tab());
2249             if (aRange.aEnd.Col()   > aTotal.aEnd.Col()  ) aTotal.aEnd.SetCol(  aRange.aEnd.Col()  );
2250             if (aRange.aEnd.Row()   > aTotal.aEnd.Row()  ) aTotal.aEnd.SetRow(  aRange.aEnd.Row()  );
2251             if (aRange.aEnd.Tab()   > aTotal.aEnd.Tab()  ) aTotal.aEnd.SetTab(aRange.aEnd.Tab()    );
2252         }
2253     }
2254     return aTotal;
2255 }
2256
2257 ScUndoBorder::ScUndoBorder( ScDocShell* pNewDocShell,
2258                             const ScRangeList& rRangeList, ScDocument* pNewUndoDoc,
2259                             const SvxBoxItem& rNewOuter, const SvxBoxInfoItem& rNewInner ) :
2260     ScBlockUndo( pNewDocShell, lcl_TotalRange(rRangeList), SC_UNDO_SIMPLE ),
2261     pUndoDoc( pNewUndoDoc )
2262 {
2263     pRanges = new ScRangeList(rRangeList);
2264     pOuter = new SvxBoxItem(rNewOuter);
2265     pInner = new SvxBoxInfoItem(rNewInner);
2266 }
2267
2268 ScUndoBorder::~ScUndoBorder()
2269 {
2270     delete pUndoDoc;
2271     delete pRanges;
2272     delete pOuter;
2273     delete pInner;
2274 }
2275
2276 OUString ScUndoBorder::GetComment() const
2277 {
2278     return ScGlobal::GetRscString( STR_UNDO_SELATTRLINES );     //! eigener String?
2279 }
2280
2281 void ScUndoBorder::Undo()
2282 {
2283     BeginUndo();
2284
2285     ScDocument& rDoc = pDocShell->GetDocument();
2286     ScMarkData aMarkData;
2287     aMarkData.MarkFromRangeList( *pRanges, false );
2288     pUndoDoc->CopyToDocument( aBlockRange, IDF_ATTRIB, true, &rDoc, &aMarkData );
2289     pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
2290
2291     EndUndo();
2292 }
2293
2294 void ScUndoBorder::Redo()
2295 {
2296     BeginRedo();
2297
2298     ScDocument& rDoc = pDocShell->GetDocument();        // call function at docfunc
2299     size_t nCount = pRanges->size();
2300     for (size_t i = 0; i < nCount; ++i )
2301     {
2302         ScRange aRange = *(*pRanges)[i];
2303         SCTAB nTab = aRange.aStart.Tab();
2304
2305         ScMarkData aMark;
2306         aMark.SetMarkArea( aRange );
2307         aMark.SelectTable( nTab, true );
2308
2309         rDoc.ApplySelectionFrame( aMark, pOuter, pInner );
2310     }
2311     for (size_t i = 0; i < nCount; ++i)
2312         pDocShell->PostPaint( *(*pRanges)[i], PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
2313
2314     EndRedo();
2315 }
2316
2317 void ScUndoBorder::Repeat(SfxRepeatTarget& /* rTarget */)
2318 {
2319     //TODO later (when the function has moved from cellsuno to docfunc)
2320 }
2321
2322 bool ScUndoBorder::CanRepeat(SfxRepeatTarget& /* rTarget */) const
2323 {
2324     return false;   // See above
2325 }
2326
2327 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */