LCOV - code coverage report
Current view: top level - sc/source/ui/undo - undoblk3.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 215 915 23.5 %
Date: 2014-11-03 Functions: 51 201 25.4 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <svx/algitem.hxx>
      22             : #include <editeng/boxitem.hxx>
      23             : #include <editeng/justifyitem.hxx>
      24             : #include <svl/srchitem.hxx>
      25             : #include <sfx2/linkmgr.hxx>
      26             : #include <sfx2/bindings.hxx>
      27             : #include <vcl/virdev.hxx>
      28             : #include <sfx2/app.hxx>
      29             : 
      30             : #include "undoblk.hxx"
      31             : #include "sc.hrc"
      32             : #include "globstr.hrc"
      33             : #include "global.hxx"
      34             : #include "rangenam.hxx"
      35             : #include "arealink.hxx"
      36             : #include "patattr.hxx"
      37             : #include "target.hxx"
      38             : #include "document.hxx"
      39             : #include "docpool.hxx"
      40             : #include "table.hxx"
      41             : #include "docsh.hxx"
      42             : #include "tabvwsh.hxx"
      43             : #include "undoolk.hxx"
      44             : #include "undoutil.hxx"
      45             : #include "chgtrack.hxx"
      46             : #include "dociter.hxx"
      47             : #include "formulacell.hxx"
      48             : #include "paramisc.hxx"
      49             : #include "postit.hxx"
      50             : #include "docuno.hxx"
      51             : #include "progress.hxx"
      52             : #include "editutil.hxx"
      53             : #include "editdataarray.hxx"
      54             : #include <rowheightcontext.hxx>
      55             : 
      56             : // STATIC DATA ---------------------------------------------------------------
      57             : 
      58           0 : TYPEINIT1(ScUndoDeleteContents,     SfxUndoAction);
      59           0 : TYPEINIT1(ScUndoFillTable,          SfxUndoAction);
      60           0 : TYPEINIT1(ScUndoSelectionAttr,      SfxUndoAction);
      61           0 : TYPEINIT1(ScUndoAutoFill,           SfxUndoAction);
      62           0 : TYPEINIT1(ScUndoMerge,              SfxUndoAction);
      63           0 : TYPEINIT1(ScUndoAutoFormat,         SfxUndoAction);
      64           0 : TYPEINIT1(ScUndoReplace,            SfxUndoAction);
      65           0 : TYPEINIT1(ScUndoTabOp,              SfxUndoAction);
      66           0 : TYPEINIT1(ScUndoConversion,         SfxUndoAction);
      67           0 : TYPEINIT1(ScUndoRefConversion,      SfxUndoAction);
      68           0 : TYPEINIT1(ScUndoRefreshLink,        SfxUndoAction);
      69           0 : TYPEINIT1(ScUndoInsertAreaLink,     SfxUndoAction);
      70           0 : TYPEINIT1(ScUndoRemoveAreaLink,     SfxUndoAction);
      71           0 : TYPEINIT1(ScUndoUpdateAreaLink,     SfxUndoAction);
      72             : 
      73             : // TODO:
      74             : /*A*/   // SetOptimalHeight on Document, when no View
      75             : 
      76         156 : ScUndoDeleteContents::ScUndoDeleteContents(
      77             :                 ScDocShell* pNewDocShell,
      78             :                 const ScMarkData& rMark, const ScRange& rRange,
      79             :                 ScDocument* pNewUndoDoc, bool bNewMulti,
      80             :                 InsertDeleteFlags nNewFlags, bool bObjects )
      81             :     :   ScSimpleUndo( pNewDocShell ),
      82             :         aRange      ( rRange ),
      83             :         aMarkData   ( rMark ),
      84             :         pUndoDoc    ( pNewUndoDoc ),
      85             :         pDrawUndo   ( NULL ),
      86             :         nFlags      ( nNewFlags ),
      87         156 :         bMulti      ( bNewMulti )   // unnecessary
      88             : {
      89         156 :     if (bObjects)
      90          12 :         pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
      91             : 
      92         156 :     if ( !(aMarkData.IsMarked() || aMarkData.IsMultiMarked()) )     // if no cell is selected:
      93           0 :         aMarkData.SetMarkArea( aRange );                            // select cell under cursor
      94             : 
      95         156 :     SetChangeTrack();
      96         156 : }
      97             : 
      98         466 : ScUndoDeleteContents::~ScUndoDeleteContents()
      99             : {
     100         156 :     delete pUndoDoc;
     101         156 :     DeleteSdrUndoAction( pDrawUndo );
     102         310 : }
     103             : 
     104         160 : OUString ScUndoDeleteContents::GetComment() const
     105             : {
     106         160 :     return ScGlobal::GetRscString( STR_UNDO_DELETECONTENTS );    // "Delete"
     107             : }
     108             : 
     109         154 : void ScUndoDeleteContents::SetDataSpans( const boost::shared_ptr<DataSpansType>& pSpans )
     110             : {
     111         154 :     mpDataSpans = pSpans;
     112         154 : }
     113             : 
     114         160 : void ScUndoDeleteContents::SetChangeTrack()
     115             : {
     116         160 :     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
     117         160 :     if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
     118             :         pChangeTrack->AppendContentRange( aRange, pUndoDoc,
     119           0 :             nStartChangeAction, nEndChangeAction );
     120             :     else
     121         160 :         nStartChangeAction = nEndChangeAction = 0;
     122         160 : }
     123             : 
     124          10 : void ScUndoDeleteContents::DoChange( const bool bUndo )
     125             : {
     126          10 :     ScDocument& rDoc = pDocShell->GetDocument();
     127             : 
     128          10 :     SetViewMarkData( aMarkData );
     129             : 
     130          10 :     sal_uInt16 nExtFlags = 0;
     131             : 
     132          10 :     if (bUndo)  // only Undo
     133             :     {
     134           6 :         InsertDeleteFlags nUndoFlags = IDF_NONE; // copy either all or none of the content
     135           6 :         if (nFlags & IDF_CONTENTS)        // (Only the correct ones have been copied into UndoDoc)
     136           6 :             nUndoFlags |= IDF_CONTENTS;
     137           6 :         if (nFlags & IDF_ATTRIB)
     138           2 :             nUndoFlags |= IDF_ATTRIB;
     139           6 :         if (nFlags & IDF_EDITATTR)          // Edit-Engine attribute
     140           0 :             nUndoFlags |= IDF_STRING;       // -> Cells will be changed
     141             :         // do not create clones of note captions, they will be restored via drawing undo
     142           6 :         nUndoFlags |= IDF_NOCAPTIONS;
     143             : 
     144           6 :         ScRange aCopyRange = aRange;
     145           6 :         SCTAB nTabCount = rDoc.GetTableCount();
     146           6 :         aCopyRange.aStart.SetTab(0);
     147           6 :         aCopyRange.aEnd.SetTab(nTabCount-1);
     148             : 
     149           6 :         pUndoDoc->CopyToDocument( aCopyRange, nUndoFlags, bMulti, &rDoc, &aMarkData );
     150             : 
     151           6 :         DoSdrUndoAction( pDrawUndo, &rDoc );
     152             : 
     153           6 :         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
     154           6 :         if ( pChangeTrack )
     155           0 :             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
     156             : 
     157           6 :         pDocShell->UpdatePaintExt( nExtFlags, aRange );             // content after the change
     158             :     }
     159             :     else        // only Redo
     160             :     {
     161           4 :         pDocShell->UpdatePaintExt( nExtFlags, aRange );             // content before the change
     162             : 
     163           4 :         aMarkData.MarkToMulti();
     164           4 :         RedoSdrUndoAction( pDrawUndo );
     165             :         // do not delete objects and note captions, they have been removed via drawing undo
     166           4 :         InsertDeleteFlags nRedoFlags = (nFlags & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
     167           4 :         rDoc.DeleteSelection( nRedoFlags, aMarkData );
     168           4 :         aMarkData.MarkToSimple();
     169             : 
     170           4 :         SetChangeTrack();
     171             :     }
     172             : 
     173          10 :     if (nFlags & IDF_CONTENTS)
     174             :     {
     175             :         // Broadcast only when the content changes. fdo#74687
     176          10 :         if (mpDataSpans)
     177           6 :             BroadcastChanges(*mpDataSpans);
     178             :         else
     179           4 :             BroadcastChanges(aRange);
     180             :     }
     181             : 
     182          10 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     183          10 :     if ( !( (pViewShell) && pViewShell->AdjustRowHeight(
     184          10 :                                 aRange.aStart.Row(), aRange.aEnd.Row() ) ) )
     185          10 : /*A*/   pDocShell->PostPaint( aRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );
     186             : 
     187          10 :     if (pViewShell)
     188           0 :         pViewShell->CellContentChanged();
     189             : 
     190          10 :     ShowTable( aRange );
     191          10 : }
     192             : 
     193           6 : void ScUndoDeleteContents::Undo()
     194             : {
     195           6 :     BeginUndo();
     196           6 :     DoChange( true );
     197           6 :     EndUndo();
     198             : 
     199           6 :     HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, aRange);
     200           6 : }
     201             : 
     202           4 : void ScUndoDeleteContents::Redo()
     203             : {
     204           4 :     BeginRedo();
     205           4 :     DoChange( false );
     206           4 :     EndRedo();
     207             : 
     208           4 :     HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, aRange);
     209           4 : }
     210             : 
     211           0 : void ScUndoDeleteContents::Repeat(SfxRepeatTarget& rTarget)
     212             : {
     213           0 :     if (rTarget.ISA(ScTabViewTarget))
     214           0 :         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->DeleteContents( nFlags, true );
     215           0 : }
     216             : 
     217           0 : bool ScUndoDeleteContents::CanRepeat(SfxRepeatTarget& rTarget) const
     218             : {
     219           0 :     return rTarget.ISA(ScTabViewTarget);
     220             : }
     221             : 
     222           0 : ScUndoFillTable::ScUndoFillTable( ScDocShell* pNewDocShell,
     223             :                 const ScMarkData& rMark,
     224             :                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
     225             :                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
     226             :                 ScDocument* pNewUndoDoc, bool bNewMulti, SCTAB nSrc,
     227             :                 InsertDeleteFlags nFlg, sal_uInt16 nFunc, bool bSkip, bool bLink )
     228             :     :   ScSimpleUndo( pNewDocShell ),
     229             :         aRange      ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
     230             :         aMarkData   ( rMark ),
     231             :         pUndoDoc    ( pNewUndoDoc ),
     232             :         nFlags      ( nFlg ),
     233             :         nFunction   ( nFunc ),
     234             :         nSrcTab     ( nSrc ),
     235             :         bMulti      ( bNewMulti ),
     236             :         bSkipEmpty  ( bSkip ),
     237           0 :         bAsLink     ( bLink )
     238             : {
     239           0 :     SetChangeTrack();
     240           0 : }
     241             : 
     242           0 : ScUndoFillTable::~ScUndoFillTable()
     243             : {
     244           0 :     delete pUndoDoc;
     245           0 : }
     246             : 
     247           0 : OUString ScUndoFillTable::GetComment() const
     248             : {
     249           0 :     return ScGlobal::GetRscString( STR_FILL_TAB );
     250             : }
     251             : 
     252           0 : void ScUndoFillTable::SetChangeTrack()
     253             : {
     254           0 :     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
     255           0 :     if ( pChangeTrack )
     256             :     {
     257           0 :         SCTAB nTabCount = pDocShell->GetDocument().GetTableCount();
     258           0 :         ScRange aWorkRange(aRange);
     259           0 :         nStartChangeAction = 0;
     260             :         sal_uLong nTmpAction;
     261           0 :         ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
     262           0 :         for (; itr != itrEnd && *itr < nTabCount; ++itr)
     263             :         {
     264           0 :             if (*itr != nSrcTab)
     265             :             {
     266           0 :                 aWorkRange.aStart.SetTab(*itr);
     267           0 :                 aWorkRange.aEnd.SetTab(*itr);
     268             :                 pChangeTrack->AppendContentRange( aWorkRange, pUndoDoc,
     269           0 :                     nTmpAction, nEndChangeAction );
     270           0 :                 if ( !nStartChangeAction )
     271           0 :                     nStartChangeAction = nTmpAction;
     272             :             }
     273             :         }
     274             :     }
     275             :     else
     276           0 :         nStartChangeAction = nEndChangeAction = 0;
     277           0 : }
     278             : 
     279           0 : void ScUndoFillTable::DoChange( const bool bUndo )
     280             : {
     281           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     282             : 
     283           0 :     SetViewMarkData( aMarkData );
     284             : 
     285           0 :     if (bUndo)  // only Undo
     286             :     {
     287           0 :         SCTAB nTabCount = rDoc.GetTableCount();
     288           0 :         ScRange aWorkRange(aRange);
     289           0 :         ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
     290           0 :         for (; itr != itrEnd && *itr < nTabCount; ++itr)
     291           0 :             if (*itr != nSrcTab)
     292             :             {
     293           0 :                 aWorkRange.aStart.SetTab(*itr);
     294           0 :                 aWorkRange.aEnd.SetTab(*itr);
     295           0 :                 if (bMulti)
     296           0 :                     rDoc.DeleteSelectionTab( *itr, IDF_ALL, aMarkData );
     297             :                 else
     298           0 :                     rDoc.DeleteAreaTab( aWorkRange, IDF_ALL );
     299           0 :                 pUndoDoc->CopyToDocument( aWorkRange, IDF_ALL, bMulti, &rDoc, &aMarkData );
     300             :             }
     301             : 
     302           0 :         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
     303           0 :         if ( pChangeTrack )
     304           0 :             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
     305             :     }
     306             :     else        // only Redo
     307             :     {
     308           0 :         aMarkData.MarkToMulti();
     309           0 :         rDoc.FillTabMarked( nSrcTab, aMarkData, nFlags, nFunction, bSkipEmpty, bAsLink );
     310           0 :         aMarkData.MarkToSimple();
     311           0 :         SetChangeTrack();
     312             :     }
     313             : 
     314           0 :     pDocShell->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_EXTRAS);
     315           0 :     pDocShell->PostDataChanged();
     316             : 
     317             :     //  CellContentChanged comes with the selection
     318             : 
     319           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     320           0 :     if (pViewShell)
     321             :     {
     322           0 :         SCTAB nTab = pViewShell->GetViewData().GetTabNo();
     323           0 :         if ( !aMarkData.GetTableSelect(nTab) )
     324           0 :             pViewShell->SetTabNo( nSrcTab );
     325             : 
     326           0 :         pViewShell->DoneBlockMode();    // causes problems otherwise since selection is on the wrong sheet.
     327             :     }
     328           0 : }
     329             : 
     330           0 : void ScUndoFillTable::Undo()
     331             : {
     332           0 :     BeginUndo();
     333           0 :     DoChange( true );
     334           0 :     EndUndo();
     335           0 : }
     336             : 
     337           0 : void ScUndoFillTable::Redo()
     338             : {
     339           0 :     BeginRedo();
     340           0 :     DoChange( false );
     341           0 :     EndRedo();
     342           0 : }
     343             : 
     344           0 : void ScUndoFillTable::Repeat(SfxRepeatTarget& rTarget)
     345             : {
     346           0 :     if (rTarget.ISA(ScTabViewTarget))
     347           0 :         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->FillTab( nFlags, nFunction, bSkipEmpty, bAsLink );
     348           0 : }
     349             : 
     350           0 : bool ScUndoFillTable::CanRepeat(SfxRepeatTarget& rTarget) const
     351             : {
     352           0 :     return rTarget.ISA(ScTabViewTarget);
     353             : }
     354             : 
     355         940 : ScUndoSelectionAttr::ScUndoSelectionAttr( ScDocShell* pNewDocShell,
     356             :                 const ScMarkData& rMark,
     357             :                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
     358             :                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
     359             :                 ScDocument* pNewUndoDoc, bool bNewMulti,
     360             :                 const ScPatternAttr* pNewApply,
     361             :                 const SvxBoxItem* pNewOuter, const SvxBoxInfoItem* pNewInner )
     362             :     :   ScSimpleUndo( pNewDocShell ),
     363             :         aMarkData   ( rMark ),
     364             :         aRange      ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
     365         940 :         mpDataArray(new ScEditDataArray),
     366             :         pUndoDoc    ( pNewUndoDoc ),
     367        1880 :         bMulti      ( bNewMulti )
     368             : {
     369         940 :     ScDocumentPool* pPool = pDocShell->GetDocument().GetPool();
     370         940 :     pApplyPattern = const_cast<ScPatternAttr*>(static_cast<const ScPatternAttr*>( &pPool->Put( *pNewApply ) ));
     371         940 :     pLineOuter = pNewOuter ? const_cast<SvxBoxItem*>(static_cast<const SvxBoxItem*>( &pPool->Put( *pNewOuter ) )) : NULL;
     372         940 :     pLineInner = pNewInner ? const_cast<SvxBoxInfoItem*>(static_cast<const SvxBoxInfoItem*>( &pPool->Put( *pNewInner ) )) : NULL;
     373         940 : }
     374             : 
     375        2820 : ScUndoSelectionAttr::~ScUndoSelectionAttr()
     376             : {
     377         940 :     ScDocumentPool* pPool = pDocShell->GetDocument().GetPool();
     378         940 :     pPool->Remove(*pApplyPattern);
     379         940 :     if (pLineOuter)
     380           0 :         pPool->Remove(*pLineOuter);
     381         940 :     if (pLineInner)
     382           0 :         pPool->Remove(*pLineInner);
     383             : 
     384         940 :     delete pUndoDoc;
     385        1880 : }
     386             : 
     387         980 : OUString ScUndoSelectionAttr::GetComment() const
     388             : {
     389             :     //"Attribute" "/Lines"
     390         980 :     return ScGlobal::GetRscString( pLineOuter ? STR_UNDO_SELATTRLINES : STR_UNDO_SELATTR );
     391             : }
     392             : 
     393           0 : ScEditDataArray* ScUndoSelectionAttr::GetDataArray()
     394             : {
     395           0 :     return mpDataArray.get();
     396             : }
     397             : 
     398           0 : void ScUndoSelectionAttr::DoChange( const bool bUndo )
     399             : {
     400           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     401             : 
     402           0 :     SetViewMarkData( aMarkData );
     403             : 
     404           0 :     ScRange aEffRange( aRange );
     405           0 :     if ( rDoc.HasAttrib( aEffRange, HASATTR_MERGED ) )         // merged cells?
     406           0 :         rDoc.ExtendMerge( aEffRange );
     407             : 
     408           0 :     sal_uInt16 nExtFlags = 0;
     409           0 :     pDocShell->UpdatePaintExt( nExtFlags, aEffRange );
     410             : 
     411           0 :     ChangeEditData(bUndo);
     412             : 
     413           0 :     if (bUndo)  // only for Undo
     414             :     {
     415           0 :         ScRange aCopyRange = aRange;
     416           0 :         SCTAB nTabCount = rDoc.GetTableCount();
     417           0 :         aCopyRange.aStart.SetTab(0);
     418           0 :         aCopyRange.aEnd.SetTab(nTabCount-1);
     419           0 :         pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, &rDoc, &aMarkData );
     420             :     }
     421             :     else        // only for Redo
     422             :     {
     423           0 :         aMarkData.MarkToMulti();
     424           0 :         rDoc.ApplySelectionPattern( *pApplyPattern, aMarkData );
     425           0 :         aMarkData.MarkToSimple();
     426             : 
     427           0 :         if (pLineOuter)
     428           0 :             rDoc.ApplySelectionFrame( aMarkData, pLineOuter, pLineInner );
     429             :     }
     430             : 
     431           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     432           0 :     if ( !( (pViewShell) && pViewShell->AdjustBlockHeight() ) )
     433           0 : /*A*/   pDocShell->PostPaint( aEffRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );
     434             : 
     435           0 :     ShowTable( aRange );
     436           0 : }
     437             : 
     438           0 : void ScUndoSelectionAttr::ChangeEditData( const bool bUndo )
     439             : {
     440           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     441           0 :     for (const ScEditDataArray::Item* pItem = mpDataArray->First(); pItem; pItem = mpDataArray->Next())
     442             :     {
     443           0 :         ScAddress aPos(pItem->GetCol(), pItem->GetRow(), pItem->GetTab());
     444           0 :         if (rDoc.GetCellType(aPos) != CELLTYPE_EDIT)
     445           0 :             continue;
     446             : 
     447           0 :         if (bUndo)
     448             :         {
     449           0 :             if (pItem->GetOldData())
     450           0 :                 rDoc.SetEditText(aPos, *pItem->GetOldData(), NULL);
     451             :             else
     452           0 :                 rDoc.SetEmptyCell(aPos);
     453             :         }
     454             :         else
     455             :         {
     456           0 :             if (pItem->GetNewData())
     457           0 :                 rDoc.SetEditText(aPos, *pItem->GetNewData(), NULL);
     458             :             else
     459           0 :                 rDoc.SetEmptyCell(aPos);
     460             :         }
     461             :     }
     462           0 : }
     463             : 
     464           0 : void ScUndoSelectionAttr::Undo()
     465             : {
     466           0 :     BeginUndo();
     467           0 :     DoChange( true );
     468           0 :     EndUndo();
     469           0 : }
     470             : 
     471           0 : void ScUndoSelectionAttr::Redo()
     472             : {
     473           0 :     BeginRedo();
     474           0 :     DoChange( false );
     475           0 :     EndRedo();
     476           0 : }
     477             : 
     478           0 : void ScUndoSelectionAttr::Repeat(SfxRepeatTarget& rTarget)
     479             : {
     480           0 :     if (rTarget.ISA(ScTabViewTarget))
     481             :     {
     482           0 :         ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
     483           0 :         if (pLineOuter)
     484           0 :             rViewShell.ApplyPatternLines( *pApplyPattern, pLineOuter, pLineInner, true );
     485             :         else
     486           0 :             rViewShell.ApplySelectionPattern( *pApplyPattern, true );
     487             :     }
     488           0 : }
     489             : 
     490          20 : bool ScUndoSelectionAttr::CanRepeat(SfxRepeatTarget& rTarget) const
     491             : {
     492          20 :     return rTarget.ISA(ScTabViewTarget);
     493             : }
     494             : 
     495          32 : ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,
     496             :                 const ScRange& rRange, const ScRange& rSourceArea,
     497             :                 ScDocument* pNewUndoDoc, const ScMarkData& rMark,
     498             :                 FillDir eNewFillDir, FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,
     499             :                 double fNewStartValue, double fNewStepValue, double fNewMaxValue )
     500             :     :   ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
     501             :         aSource         ( rSourceArea ),
     502             :         aMarkData       ( rMark ),
     503             :         pUndoDoc        ( pNewUndoDoc ),
     504             :         eFillDir        ( eNewFillDir ),
     505             :         eFillCmd        ( eNewFillCmd ),
     506             :         eFillDateCmd    ( eNewFillDateCmd ),
     507             :         fStartValue     ( fNewStartValue ),
     508             :         fStepValue      ( fNewStepValue ),
     509          32 :         fMaxValue       ( fNewMaxValue )
     510             : {
     511          32 :     SetChangeTrack();
     512          32 : }
     513             : 
     514          96 : ScUndoAutoFill::~ScUndoAutoFill()
     515             : {
     516          32 :     delete pUndoDoc;
     517          64 : }
     518             : 
     519          44 : OUString ScUndoAutoFill::GetComment() const
     520             : {
     521          44 :     return ScGlobal::GetRscString( STR_UNDO_AUTOFILL ); //"Fill"
     522             : }
     523             : 
     524          34 : void ScUndoAutoFill::SetChangeTrack()
     525             : {
     526          34 :     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
     527          34 :     if ( pChangeTrack )
     528             :         pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
     529           0 :             nStartChangeAction, nEndChangeAction );
     530             :     else
     531          34 :         nStartChangeAction = nEndChangeAction = 0;
     532          34 : }
     533             : 
     534           2 : void ScUndoAutoFill::Undo()
     535             : {
     536           2 :     BeginUndo();
     537             : 
     538           2 :     ScDocument& rDoc = pDocShell->GetDocument();
     539             : 
     540           2 :     SCTAB nTabCount = rDoc.GetTableCount();
     541           2 :     ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
     542           4 :     for (; itr != itrEnd && *itr < nTabCount; ++itr)
     543             :     {
     544           2 :         ScRange aWorkRange = aBlockRange;
     545           2 :         aWorkRange.aStart.SetTab(*itr);
     546           2 :         aWorkRange.aEnd.SetTab(*itr);
     547             : 
     548           2 :         sal_uInt16 nExtFlags = 0;
     549           2 :         pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
     550           2 :         rDoc.DeleteAreaTab( aWorkRange, IDF_AUTOFILL );
     551           2 :         pUndoDoc->CopyToDocument( aWorkRange, IDF_AUTOFILL, false, &rDoc );
     552             : 
     553           2 :         rDoc.ExtendMerge( aWorkRange, true );
     554           2 :         pDocShell->PostPaint( aWorkRange, PAINT_GRID, nExtFlags );
     555             :     }
     556           2 :     pDocShell->PostDataChanged();
     557           2 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     558           2 :     if (pViewShell)
     559           0 :         pViewShell->CellContentChanged();
     560             : 
     561           2 :     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
     562           2 :     if ( pChangeTrack )
     563           0 :         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
     564             : 
     565           2 :     EndUndo();
     566           2 : }
     567             : 
     568           2 : void ScUndoAutoFill::Redo()
     569             : {
     570           2 :     BeginRedo();
     571             : 
     572             : //! Select sheet
     573             : 
     574           2 :     SCCOLROW nCount = 0;
     575           2 :     switch (eFillDir)
     576             :     {
     577             :         case FILL_TO_BOTTOM:
     578           2 :             nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();
     579           2 :             break;
     580             :         case FILL_TO_RIGHT:
     581           0 :             nCount = aBlockRange.aEnd.Col() - aSource.aEnd.Col();
     582           0 :             break;
     583             :         case FILL_TO_TOP:
     584           0 :             nCount = aSource.aStart.Row() - aBlockRange.aStart.Row();
     585           0 :             break;
     586             :         case FILL_TO_LEFT:
     587           0 :             nCount = aSource.aStart.Col() - aBlockRange.aStart.Col();
     588           0 :             break;
     589             :     }
     590             : 
     591           2 :     ScDocument& rDoc = pDocShell->GetDocument();
     592           2 :     if ( fStartValue != MAXDOUBLE )
     593             :     {
     594           0 :         SCCOL nValX = (eFillDir == FILL_TO_LEFT) ? aSource.aEnd.Col() : aSource.aStart.Col();
     595           0 :         SCROW nValY = (eFillDir == FILL_TO_TOP ) ? aSource.aEnd.Row() : aSource.aStart.Row();
     596           0 :         SCTAB nTab = aSource.aStart.Tab();
     597           0 :         rDoc.SetValue( nValX, nValY, nTab, fStartValue );
     598             :     }
     599             :     sal_uLong nProgCount;
     600           2 :     if (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP)
     601           2 :         nProgCount = aSource.aEnd.Col() - aSource.aStart.Col() + 1;
     602             :     else
     603           0 :         nProgCount = aSource.aEnd.Row() - aSource.aStart.Row() + 1;
     604           2 :     nProgCount *= nCount;
     605             :     ScProgress aProgress( rDoc.GetDocumentShell(),
     606           2 :             ScGlobal::GetRscString(STR_FILL_SERIES_PROGRESS), nProgCount );
     607             : 
     608           2 :     rDoc.Fill( aSource.aStart.Col(), aSource.aStart.Row(),
     609           2 :             aSource.aEnd.Col(), aSource.aEnd.Row(), &aProgress,
     610             :             aMarkData, nCount,
     611             :             eFillDir, eFillCmd, eFillDateCmd,
     612           6 :             fStepValue, fMaxValue );
     613             : 
     614           2 :     SetChangeTrack();
     615             : 
     616           2 :     pDocShell->PostPaint( aBlockRange, PAINT_GRID );
     617           2 :     pDocShell->PostDataChanged();
     618           2 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     619           2 :     if (pViewShell)
     620           0 :         pViewShell->CellContentChanged();
     621             : 
     622           2 :     EndRedo();
     623           2 : }
     624             : 
     625           0 : void ScUndoAutoFill::Repeat(SfxRepeatTarget& rTarget)
     626             : {
     627           0 :     if (rTarget.ISA(ScTabViewTarget))
     628             :     {
     629           0 :         ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
     630           0 :         if (eFillCmd==FILL_SIMPLE)
     631           0 :             rViewShell.FillSimple( eFillDir, true );
     632             :         else
     633             :             rViewShell.FillSeries( eFillDir, eFillCmd, eFillDateCmd,
     634           0 :                                    fStartValue, fStepValue, fMaxValue, true );
     635             :     }
     636           0 : }
     637             : 
     638           4 : bool ScUndoAutoFill::CanRepeat(SfxRepeatTarget& rTarget) const
     639             : {
     640           4 :     return rTarget.ISA(ScTabViewTarget);
     641             : }
     642             : 
     643           8 : ScUndoMerge::ScUndoMerge( ScDocShell* pNewDocShell, const ScCellMergeOption& rOption,
     644             :                           bool bMergeContents, ScDocument* pUndoDoc, SdrUndoAction* pDrawUndo )
     645             :     :   ScSimpleUndo( pNewDocShell ),
     646             :         maOption(rOption),
     647             :         mbMergeContents( bMergeContents ),
     648             :         mpUndoDoc( pUndoDoc ),
     649           8 :         mpDrawUndo( pDrawUndo )
     650             : {
     651           8 : }
     652             : 
     653          24 : ScUndoMerge::~ScUndoMerge()
     654             : {
     655           8 :     delete mpUndoDoc;
     656           8 :     DeleteSdrUndoAction( mpDrawUndo );
     657          16 : }
     658             : 
     659           8 : OUString ScUndoMerge::GetComment() const
     660             : {
     661           8 :     return ScGlobal::GetRscString( STR_UNDO_MERGE );
     662             : }
     663             : 
     664           0 : void ScUndoMerge::DoChange( bool bUndo ) const
     665             : {
     666             :     using ::std::set;
     667             : 
     668           0 :     if (maOption.maTabs.empty())
     669             :         // Nothing to do.
     670           0 :         return;
     671             : 
     672           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     673           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     674             : 
     675           0 :     ScRange aCurRange = maOption.getSingleRange(ScDocShell::GetCurTab());
     676           0 :     ScUndoUtil::MarkSimpleBlock(pDocShell, aCurRange);
     677             : 
     678           0 :     for (set<SCTAB>::const_iterator itr = maOption.maTabs.begin(), itrEnd = maOption.maTabs.end();
     679             :           itr != itrEnd; ++itr)
     680             :     {
     681           0 :         SCTAB nTab = *itr;
     682           0 :         ScRange aRange = maOption.getSingleRange(nTab);
     683             : 
     684           0 :         if (bUndo)
     685             :             // remove merge (contents are copied back below from undo document)
     686           0 :             rDoc.RemoveMerge( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab() );
     687             :         else
     688             :         {
     689             :             // repeat merge, but do not remove note captions (will be done by drawing redo below)
     690           0 :             rDoc.DoMerge( aRange.aStart.Tab(),
     691           0 :                            aRange.aStart.Col(), aRange.aStart.Row(),
     692           0 :                            aRange.aEnd.Col(),   aRange.aEnd.Row(), false );
     693             : 
     694           0 :             if (maOption.mbCenter)
     695             :             {
     696           0 :                 rDoc.ApplyAttr( aRange.aStart.Col(), aRange.aStart.Row(),
     697           0 :                                  aRange.aStart.Tab(),
     698           0 :                                  SvxHorJustifyItem( SVX_HOR_JUSTIFY_CENTER, ATTR_HOR_JUSTIFY ) );
     699           0 :                 rDoc.ApplyAttr( aRange.aStart.Col(), aRange.aStart.Row(),
     700           0 :                                  aRange.aStart.Tab(),
     701           0 :                                  SvxVerJustifyItem( SVX_VER_JUSTIFY_CENTER, ATTR_VER_JUSTIFY ) );
     702             :             }
     703             :         }
     704             : 
     705             :         // undo -> copy back deleted contents
     706           0 :         if (bUndo && mpUndoDoc)
     707             :         {
     708           0 :             rDoc.DeleteAreaTab( aRange, IDF_CONTENTS|IDF_NOCAPTIONS );
     709           0 :             mpUndoDoc->CopyToDocument( aRange, IDF_ALL|IDF_NOCAPTIONS, false, &rDoc );
     710             :         }
     711             : 
     712             :         // redo -> merge contents again
     713           0 :         else if (!bUndo && mbMergeContents)
     714             :         {
     715           0 :             rDoc.DoMergeContents( aRange.aStart.Tab(),
     716           0 :                                    aRange.aStart.Col(), aRange.aStart.Row(),
     717           0 :                                    aRange.aEnd.Col(), aRange.aEnd.Row() );
     718             :         }
     719             : 
     720           0 :         if (bUndo)
     721           0 :             DoSdrUndoAction( mpDrawUndo, &rDoc );
     722             :         else
     723           0 :             RedoSdrUndoAction( mpDrawUndo );
     724             : 
     725           0 :         bool bDidPaint = false;
     726           0 :         if ( pViewShell )
     727             :         {
     728           0 :             pViewShell->SetTabNo(nTab);
     729           0 :             bDidPaint = pViewShell->AdjustRowHeight(maOption.mnStartRow, maOption.mnEndRow);
     730             :         }
     731             : 
     732           0 :         if (!bDidPaint)
     733           0 :             ScUndoUtil::PaintMore(pDocShell, aRange);
     734             :     }
     735             : 
     736           0 :     ShowTable(aCurRange);
     737             : }
     738             : 
     739           0 : void ScUndoMerge::Undo()
     740             : {
     741           0 :     BeginUndo();
     742           0 :     DoChange( true );
     743           0 :     EndUndo();
     744           0 : }
     745             : 
     746           0 : void ScUndoMerge::Redo()
     747             : {
     748           0 :     BeginRedo();
     749           0 :     DoChange( false );
     750           0 :     EndRedo();
     751           0 : }
     752             : 
     753           0 : void ScUndoMerge::Repeat(SfxRepeatTarget& rTarget)
     754             : {
     755           0 :     if (rTarget.ISA(ScTabViewTarget))
     756             :     {
     757           0 :         ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
     758           0 :         bool bCont = false;
     759           0 :         rViewShell.MergeCells( false, bCont, true );
     760             :     }
     761           0 : }
     762             : 
     763           0 : bool ScUndoMerge::CanRepeat(SfxRepeatTarget& rTarget) const
     764             : {
     765           0 :     return rTarget.ISA(ScTabViewTarget);
     766             : }
     767             : 
     768           0 : ScUndoAutoFormat::ScUndoAutoFormat( ScDocShell* pNewDocShell,
     769             :                         const ScRange& rRange, ScDocument* pNewUndoDoc,
     770             :                         const ScMarkData& rMark, bool bNewSize, sal_uInt16 nNewFormatNo )
     771             :     :   ScBlockUndo( pNewDocShell, rRange, bNewSize ? SC_UNDO_MANUALHEIGHT : SC_UNDO_AUTOHEIGHT ),
     772             :         pUndoDoc    ( pNewUndoDoc ),
     773             :         aMarkData   ( rMark ),
     774             :         bSize       ( bNewSize ),
     775           0 :         nFormatNo   ( nNewFormatNo )
     776             : {
     777           0 : }
     778             : 
     779           0 : ScUndoAutoFormat::~ScUndoAutoFormat()
     780             : {
     781           0 :     delete pUndoDoc;
     782           0 : }
     783             : 
     784           0 : OUString ScUndoAutoFormat::GetComment() const
     785             : {
     786           0 :     return ScGlobal::GetRscString( STR_UNDO_AUTOFORMAT );   //"Auto-Format"
     787             : }
     788             : 
     789           0 : void ScUndoAutoFormat::Undo()
     790             : {
     791           0 :     BeginUndo();
     792             : 
     793           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     794             : 
     795           0 :     SCTAB nTabCount = rDoc.GetTableCount();
     796           0 :     rDoc.DeleteArea( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
     797           0 :                       aBlockRange.aEnd.Col(), aBlockRange.aEnd.Row(),
     798           0 :                       aMarkData, IDF_ATTRIB );
     799           0 :     ScRange aCopyRange = aBlockRange;
     800           0 :     aCopyRange.aStart.SetTab(0);
     801           0 :     aCopyRange.aEnd.SetTab(nTabCount-1);
     802           0 :     pUndoDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, false, &rDoc, &aMarkData );
     803             : 
     804             :     // cell heights and widths (IDF_NONE)
     805           0 :     if (bSize)
     806             :     {
     807           0 :         SCCOL nStartX = aBlockRange.aStart.Col();
     808           0 :         SCROW nStartY = aBlockRange.aStart.Row();
     809           0 :         SCTAB nStartZ = aBlockRange.aStart.Tab();
     810           0 :         SCCOL nEndX = aBlockRange.aEnd.Col();
     811           0 :         SCROW nEndY = aBlockRange.aEnd.Row();
     812           0 :         SCTAB nEndZ = aBlockRange.aEnd.Tab();
     813             : 
     814             :         pUndoDoc->CopyToDocument( nStartX, 0, 0, nEndX, MAXROW, nTabCount-1,
     815           0 :                                     IDF_NONE, false, &rDoc, &aMarkData );
     816             :         pUndoDoc->CopyToDocument( 0, nStartY, 0, MAXCOL, nEndY, nTabCount-1,
     817           0 :                                     IDF_NONE, false, &rDoc, &aMarkData );
     818             :         pDocShell->PostPaint( 0, 0, nStartZ, MAXCOL, MAXROW, nEndZ,
     819           0 :                               PAINT_GRID | PAINT_LEFT | PAINT_TOP, SC_PF_LINES );
     820             :     }
     821             :     else
     822           0 :         pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES );
     823             : 
     824           0 :     EndUndo();
     825           0 : }
     826             : 
     827           0 : void ScUndoAutoFormat::Redo()
     828             : {
     829           0 :     BeginRedo();
     830             : 
     831           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     832             : 
     833           0 :     SCCOL nStartX = aBlockRange.aStart.Col();
     834           0 :     SCROW nStartY = aBlockRange.aStart.Row();
     835           0 :     SCTAB nStartZ = aBlockRange.aStart.Tab();
     836           0 :     SCCOL nEndX = aBlockRange.aEnd.Col();
     837           0 :     SCROW nEndY = aBlockRange.aEnd.Row();
     838           0 :     SCTAB nEndZ = aBlockRange.aEnd.Tab();
     839             : 
     840           0 :     rDoc.AutoFormat( nStartX, nStartY, nEndX, nEndY, nFormatNo, aMarkData );
     841             : 
     842           0 :     if (bSize)
     843             :     {
     844           0 :         VirtualDevice aVirtDev;
     845           0 :         Fraction aZoomX(1,1);
     846           0 :         Fraction aZoomY = aZoomX;
     847             :         double nPPTX,nPPTY;
     848           0 :         ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     849           0 :         if (pViewShell)
     850             :         {
     851           0 :             ScViewData& rData = pViewShell->GetViewData();
     852           0 :             nPPTX = rData.GetPPTX();
     853           0 :             nPPTY = rData.GetPPTY();
     854           0 :             aZoomX = rData.GetZoomX();
     855           0 :             aZoomY = rData.GetZoomY();
     856             :         }
     857             :         else
     858             :         {
     859             :             // Keep zoom at 100
     860           0 :             nPPTX = ScGlobal::nScreenPPTX;
     861           0 :             nPPTY = ScGlobal::nScreenPPTY;
     862             :         }
     863             : 
     864           0 :         bool bFormula = false;  // remember
     865             : 
     866           0 :         sc::RowHeightContext aCxt(nPPTX, nPPTY, aZoomX, aZoomY, &aVirtDev);
     867           0 :         for (SCTAB nTab=nStartZ; nTab<=nEndZ; nTab++)
     868             :         {
     869           0 :             ScMarkData aDestMark;
     870           0 :             aDestMark.SelectOneTable( nTab );
     871           0 :             aDestMark.SetMarkArea( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
     872           0 :             aDestMark.MarkToMulti();
     873             : 
     874             :             // as SC_SIZE_VISOPT
     875           0 :             for (SCROW nRow=nStartY; nRow<=nEndY; nRow++)
     876             :             {
     877           0 :                 sal_uInt8 nOld = rDoc.GetRowFlags(nRow,nTab);
     878           0 :                 bool bHidden = rDoc.RowHidden(nRow, nTab);
     879           0 :                 if ( !bHidden && ( nOld & CR_MANUALSIZE ) )
     880           0 :                     rDoc.SetRowFlags( nRow, nTab, nOld & ~CR_MANUALSIZE );
     881             :             }
     882             : 
     883           0 :             rDoc.SetOptimalHeight(aCxt, nStartY, nEndY, nTab);
     884             : 
     885           0 :             for (SCCOL nCol=nStartX; nCol<=nEndX; nCol++)
     886           0 :                 if (!rDoc.ColHidden(nCol, nTab))
     887             :                 {
     888             :                     sal_uInt16 nThisSize = STD_EXTRA_WIDTH + rDoc.GetOptimalColWidth( nCol, nTab,
     889             :                                                 &aVirtDev, nPPTX, nPPTY, aZoomX, aZoomY, bFormula,
     890           0 :                                                 &aDestMark );
     891           0 :                     rDoc.SetColWidth( nCol, nTab, nThisSize );
     892           0 :                     rDoc.ShowCol( nCol, nTab, true );
     893             :                 }
     894           0 :         }
     895             : 
     896             :         pDocShell->PostPaint( 0,      0,      nStartZ,
     897             :                               MAXCOL, MAXROW, nEndZ,
     898           0 :                               PAINT_GRID | PAINT_LEFT | PAINT_TOP, SC_PF_LINES);
     899             :     }
     900             :     else
     901           0 :         pDocShell->PostPaint( aBlockRange, PAINT_GRID, SC_PF_LINES );
     902             : 
     903           0 :     EndRedo();
     904           0 : }
     905             : 
     906           0 : void ScUndoAutoFormat::Repeat(SfxRepeatTarget& rTarget)
     907             : {
     908           0 :     if (rTarget.ISA(ScTabViewTarget))
     909           0 :         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->AutoFormat( nFormatNo, true );
     910           0 : }
     911             : 
     912           0 : bool ScUndoAutoFormat::CanRepeat(SfxRepeatTarget& rTarget) const
     913             : {
     914           0 :     return rTarget.ISA(ScTabViewTarget);
     915             : }
     916             : 
     917          44 : ScUndoReplace::ScUndoReplace( ScDocShell* pNewDocShell, const ScMarkData& rMark,
     918             :                                     SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
     919             :                                     const OUString& rNewUndoStr, ScDocument* pNewUndoDoc,
     920             :                                     const SvxSearchItem* pItem )
     921             :     :   ScSimpleUndo( pNewDocShell ),
     922             :         aCursorPos  ( nCurX, nCurY, nCurZ ),
     923             :         aMarkData   ( rMark ),
     924             :         aUndoStr    ( rNewUndoStr ),
     925          44 :         pUndoDoc    ( pNewUndoDoc )
     926             : {
     927          44 :     pSearchItem = new SvxSearchItem( *pItem );
     928          44 :     SetChangeTrack();
     929          44 : }
     930             : 
     931         132 : ScUndoReplace::~ScUndoReplace()
     932             : {
     933          44 :     delete pUndoDoc;
     934          44 :     delete pSearchItem;
     935          88 : }
     936             : 
     937          44 : void ScUndoReplace::SetChangeTrack()
     938             : {
     939          44 :     ScDocument& rDoc = pDocShell->GetDocument();
     940          44 :     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
     941          44 :     if ( pChangeTrack )
     942             :     {
     943           0 :         if ( pUndoDoc )
     944             :         {   //! UndoDoc includes only the changed cells,
     945             :             // that is why an Iterator can be used
     946             :             pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
     947           0 :                 nStartChangeAction, nEndChangeAction );
     948             :         }
     949             :         else
     950             :         {
     951           0 :             nStartChangeAction = pChangeTrack->GetActionMax() + 1;
     952             :             ScChangeActionContent* pContent = new ScChangeActionContent(
     953           0 :                 ScRange( aCursorPos) );
     954           0 :             ScCellValue aCell;
     955           0 :             aCell.assign(rDoc, aCursorPos);
     956           0 :             pContent->SetOldValue( aUndoStr, &rDoc );
     957           0 :             pContent->SetNewValue(aCell, &rDoc);
     958           0 :             pChangeTrack->Append( pContent );
     959           0 :             nEndChangeAction = pChangeTrack->GetActionMax();
     960             :         }
     961             :     }
     962             :     else
     963          44 :         nStartChangeAction = nEndChangeAction = 0;
     964          44 : }
     965             : 
     966          44 : OUString ScUndoReplace::GetComment() const
     967             : {
     968          44 :     return ScGlobal::GetRscString( STR_UNDO_REPLACE );  // "Replace"
     969             : }
     970             : 
     971           0 : void ScUndoReplace::Undo()
     972             : {
     973           0 :     BeginUndo();
     974             : 
     975           0 :     ScDocument& rDoc = pDocShell->GetDocument();
     976           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
     977             : 
     978           0 :     ShowTable( aCursorPos.Tab() );
     979             : 
     980           0 :     if (pUndoDoc)       // only for ReplaceAll !!
     981             :     {
     982             :         OSL_ENSURE(pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE_ALL,
     983             :                    "ScUndoReplace:: Wrong Mode");
     984             : 
     985           0 :         SetViewMarkData( aMarkData );
     986             : 
     987             : //! selected sheet
     988             : //! select range ?
     989             : 
     990             :         // Undo document has no row/column information, thus copy with
     991             :         // bColRowFlags = FALSE to not destroy Outline groups
     992             : 
     993           0 :         InsertDeleteFlags nUndoFlags = (pSearchItem->GetPattern()) ? IDF_ATTRIB : IDF_CONTENTS;
     994             :         pUndoDoc->CopyToDocument( 0,      0,      0,
     995             :                                   MAXCOL, MAXROW, MAXTAB,
     996           0 :                                   nUndoFlags, false, &rDoc, NULL, false );   // without row flags
     997           0 :         pDocShell->PostPaintGridAll();
     998             :     }
     999           0 :     else if (pSearchItem->GetPattern() &&
    1000           0 :              pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
    1001             :     {
    1002           0 :         OUString aTempStr = pSearchItem->GetSearchString();       // toggle
    1003           0 :         pSearchItem->SetSearchString(pSearchItem->GetReplaceString());
    1004           0 :         pSearchItem->SetReplaceString(aTempStr);
    1005             :         rDoc.ReplaceStyle( *pSearchItem,
    1006           0 :                             aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
    1007           0 :                             aMarkData, true);
    1008           0 :         pSearchItem->SetReplaceString(pSearchItem->GetSearchString());
    1009           0 :         pSearchItem->SetSearchString(aTempStr);
    1010           0 :         if (pViewShell)
    1011           0 :             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
    1012           0 :                                        SC_FOLLOW_JUMP, false, false );
    1013           0 :         pDocShell->PostPaintGridAll();
    1014             :     }
    1015           0 :     else if (pSearchItem->GetCellType() == SVX_SEARCHIN_NOTE)
    1016             :     {
    1017           0 :         ScPostIt* pNote = rDoc.GetNote(aCursorPos);
    1018             :         OSL_ENSURE( pNote, "ScUndoReplace::Undo - cell does not contain a note" );
    1019           0 :         if (pNote)
    1020           0 :             pNote->SetText( aCursorPos, aUndoStr );
    1021           0 :         if (pViewShell)
    1022           0 :             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
    1023           0 :                                        SC_FOLLOW_JUMP, false, false );
    1024             :     }
    1025             :     else
    1026             :     {
    1027             :         // aUndoStr may contain line breaks
    1028           0 :         if ( aUndoStr.indexOf('\n') != -1 )
    1029             :         {
    1030           0 :             ScFieldEditEngine& rEngine = rDoc.GetEditEngine();
    1031           0 :             rEngine.SetText(aUndoStr);
    1032           0 :             rDoc.SetEditText(aCursorPos, rEngine.CreateTextObject());
    1033             :         }
    1034             :         else
    1035           0 :             rDoc.SetString( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(), aUndoStr );
    1036           0 :         if (pViewShell)
    1037           0 :             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
    1038           0 :                                        SC_FOLLOW_JUMP, false, false );
    1039           0 :         pDocShell->PostPaintGridAll();
    1040             :     }
    1041             : 
    1042           0 :     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
    1043           0 :     if ( pChangeTrack )
    1044           0 :         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
    1045             : 
    1046           0 :     EndUndo();
    1047           0 : }
    1048             : 
    1049           0 : void ScUndoReplace::Redo()
    1050             : {
    1051           0 :     BeginRedo();
    1052             : 
    1053           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1054           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
    1055             : 
    1056           0 :     if (pViewShell)
    1057           0 :         pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
    1058           0 :                                    SC_FOLLOW_JUMP, false, false );
    1059           0 :     if (pUndoDoc)
    1060             :     {
    1061           0 :         if (pViewShell)
    1062             :         {
    1063           0 :             SetViewMarkData( aMarkData );
    1064             : 
    1065           0 :             pViewShell->SearchAndReplace( pSearchItem, false, true );
    1066             :         }
    1067             :     }
    1068           0 :     else if (pSearchItem->GetPattern() &&
    1069           0 :              pSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
    1070             :     {
    1071             :         rDoc.ReplaceStyle( *pSearchItem,
    1072           0 :                             aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
    1073           0 :                             aMarkData, true);
    1074           0 :         pDocShell->PostPaintGridAll();
    1075             :     }
    1076             :     else
    1077           0 :         if (pViewShell)
    1078           0 :             pViewShell->SearchAndReplace( pSearchItem, false, true );
    1079             : 
    1080           0 :     SetChangeTrack();
    1081             : 
    1082           0 :     EndRedo();
    1083           0 : }
    1084             : 
    1085           0 : void ScUndoReplace::Repeat(SfxRepeatTarget& rTarget)
    1086             : {
    1087           0 :     if (rTarget.ISA(ScTabViewTarget))
    1088           0 :         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->SearchAndReplace( pSearchItem, true, false );
    1089           0 : }
    1090             : 
    1091           0 : bool ScUndoReplace::CanRepeat(SfxRepeatTarget& rTarget) const
    1092             : {
    1093           0 :     return rTarget.ISA(ScTabViewTarget);
    1094             : }
    1095             : 
    1096             : // multi-operation (only simple blocks)
    1097           6 : ScUndoTabOp::ScUndoTabOp( ScDocShell* pNewDocShell,
    1098             :                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
    1099             :                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ, ScDocument* pNewUndoDoc,
    1100             :                 const ScRefAddress& rFormulaCell,
    1101             :                 const ScRefAddress& rFormulaEnd,
    1102             :                 const ScRefAddress& rRowCell,
    1103             :                 const ScRefAddress& rColCell,
    1104             :                 ScTabOpParam::Mode eMode )
    1105             :     :   ScSimpleUndo( pNewDocShell ),
    1106             :         aRange          ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
    1107             :         pUndoDoc        ( pNewUndoDoc ),
    1108             :         theFormulaCell  ( rFormulaCell ),
    1109             :         theFormulaEnd   ( rFormulaEnd ),
    1110             :         theRowCell      ( rRowCell ),
    1111             :         theColCell      ( rColCell ),
    1112           6 :         meMode(eMode)
    1113             : {
    1114           6 : }
    1115             : 
    1116          18 : ScUndoTabOp::~ScUndoTabOp()
    1117             : {
    1118           6 :     delete pUndoDoc;
    1119          12 : }
    1120             : 
    1121           6 : OUString ScUndoTabOp::GetComment() const
    1122             : {
    1123           6 :     return ScGlobal::GetRscString( STR_UNDO_TABOP );    // "Multiple operation"
    1124             : }
    1125             : 
    1126           0 : void ScUndoTabOp::Undo()
    1127             : {
    1128           0 :     BeginUndo();
    1129             : 
    1130           0 :     ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );
    1131             : 
    1132           0 :     sal_uInt16 nExtFlags = 0;
    1133           0 :     pDocShell->UpdatePaintExt( nExtFlags, aRange );
    1134             : 
    1135           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1136           0 :     rDoc.DeleteAreaTab( aRange,IDF_ALL & ~IDF_NOTE );
    1137           0 :     pUndoDoc->CopyToDocument( aRange, IDF_ALL & ~IDF_NOTE, false, &rDoc );
    1138           0 :     pDocShell->PostPaint( aRange, PAINT_GRID, nExtFlags );
    1139           0 :     pDocShell->PostDataChanged();
    1140           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
    1141           0 :     if (pViewShell)
    1142           0 :         pViewShell->CellContentChanged();
    1143             : 
    1144           0 :     EndUndo();
    1145           0 : }
    1146             : 
    1147           0 : void ScUndoTabOp::Redo()
    1148             : {
    1149           0 :     BeginRedo();
    1150             : 
    1151           0 :     ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );
    1152             : 
    1153           0 :     ScTabOpParam aParam(theFormulaCell, theFormulaEnd, theRowCell, theColCell, meMode);
    1154             : 
    1155           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
    1156           0 :     if (pViewShell)
    1157           0 :         pViewShell->TabOp( aParam, false);
    1158             : 
    1159           0 :     EndRedo();
    1160           0 : }
    1161             : 
    1162           0 : void ScUndoTabOp::Repeat(SfxRepeatTarget& /* rTarget */)
    1163             : {
    1164           0 : }
    1165             : 
    1166           0 : bool ScUndoTabOp::CanRepeat(SfxRepeatTarget& /* rTarget */) const
    1167             : {
    1168           0 :     return false;
    1169             : }
    1170             : 
    1171           0 : ScUndoConversion::ScUndoConversion(
    1172             :         ScDocShell* pNewDocShell, const ScMarkData& rMark,
    1173             :         SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, ScDocument* pNewUndoDoc,
    1174             :         SCCOL nNewX, SCROW nNewY, SCTAB nNewZ, ScDocument* pNewRedoDoc,
    1175             :         const ScConversionParam& rConvParam ) :
    1176             :     ScSimpleUndo( pNewDocShell ),
    1177             :     aMarkData( rMark ),
    1178             :     aCursorPos( nCurX, nCurY, nCurZ ),
    1179             :     pUndoDoc( pNewUndoDoc ),
    1180             :     aNewCursorPos( nNewX, nNewY, nNewZ ),
    1181             :     pRedoDoc( pNewRedoDoc ),
    1182           0 :     maConvParam( rConvParam )
    1183             : {
    1184           0 :     SetChangeTrack();
    1185           0 : }
    1186             : 
    1187           0 : ScUndoConversion::~ScUndoConversion()
    1188             : {
    1189           0 :     delete pUndoDoc;
    1190           0 :     delete pRedoDoc;
    1191           0 : }
    1192             : 
    1193           0 : void ScUndoConversion::SetChangeTrack()
    1194             : {
    1195           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1196           0 :     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
    1197           0 :     if ( pChangeTrack )
    1198             :     {
    1199           0 :         if ( pUndoDoc )
    1200             :             pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
    1201           0 :                 nStartChangeAction, nEndChangeAction );
    1202             :         else
    1203             :         {
    1204             :             OSL_FAIL( "ScUndoConversion::SetChangeTrack: no UndoDoc" );
    1205           0 :             nStartChangeAction = nEndChangeAction = 0;
    1206             :         }
    1207             :     }
    1208             :     else
    1209           0 :         nStartChangeAction = nEndChangeAction = 0;
    1210           0 : }
    1211             : 
    1212           0 : OUString ScUndoConversion::GetComment() const
    1213             : {
    1214           0 :     OUString aText;
    1215           0 :     switch( maConvParam.GetType() )
    1216             :     {
    1217           0 :         case SC_CONVERSION_SPELLCHECK:      aText = ScGlobal::GetRscString( STR_UNDO_SPELLING );    break;
    1218           0 :         case SC_CONVERSION_HANGULHANJA:     aText = ScGlobal::GetRscString( STR_UNDO_HANGULHANJA ); break;
    1219           0 :         case SC_CONVERSION_CHINESE_TRANSL:  aText = ScGlobal::GetRscString( STR_UNDO_CHINESE_TRANSLATION ); break;
    1220             :         default: OSL_FAIL( "ScUndoConversion::GetComment - unknown conversion type" );
    1221             :     }
    1222           0 :     return aText;
    1223             : }
    1224             : 
    1225           0 : void ScUndoConversion::DoChange( ScDocument* pRefDoc, const ScAddress& rCursorPos )
    1226             : {
    1227           0 :     if (pRefDoc)
    1228             :     {
    1229           0 :         ScDocument& rDoc = pDocShell->GetDocument();
    1230           0 :         ShowTable( rCursorPos.Tab() );
    1231             : 
    1232           0 :         SetViewMarkData( aMarkData );
    1233             : 
    1234           0 :         SCTAB nTabCount = rDoc.GetTableCount();
    1235             :         //  Undo/Redo-doc has only selected tables
    1236             : 
    1237           0 :         bool bMulti = aMarkData.IsMultiMarked();
    1238             :         pRefDoc->CopyToDocument( 0,      0,      0,
    1239             :                                  MAXCOL, MAXROW, nTabCount-1,
    1240           0 :                                  IDF_CONTENTS, bMulti, &rDoc, &aMarkData );
    1241           0 :         pDocShell->PostPaintGridAll();
    1242             :     }
    1243             :     else
    1244             :     {
    1245             :         OSL_FAIL("no Un-/RedoDoc for Un-/RedoSpelling");
    1246             :     }
    1247           0 : }
    1248             : 
    1249           0 : void ScUndoConversion::Undo()
    1250             : {
    1251           0 :     BeginUndo();
    1252           0 :     DoChange( pUndoDoc, aCursorPos );
    1253           0 :     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
    1254           0 :     if ( pChangeTrack )
    1255           0 :         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
    1256           0 :     EndUndo();
    1257           0 : }
    1258             : 
    1259           0 : void ScUndoConversion::Redo()
    1260             : {
    1261           0 :     BeginRedo();
    1262           0 :     DoChange( pRedoDoc, aNewCursorPos );
    1263           0 :     SetChangeTrack();
    1264           0 :     EndRedo();
    1265           0 : }
    1266             : 
    1267           0 : void ScUndoConversion::Repeat( SfxRepeatTarget& rTarget )
    1268             : {
    1269           0 :     if( rTarget.ISA( ScTabViewTarget ) )
    1270           0 :         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->DoSheetConversion( maConvParam, true );
    1271           0 : }
    1272             : 
    1273           0 : bool ScUndoConversion::CanRepeat(SfxRepeatTarget& rTarget) const
    1274             : {
    1275           0 :     return rTarget.ISA( ScTabViewTarget );
    1276             : }
    1277             : 
    1278           0 : ScUndoRefConversion::ScUndoRefConversion( ScDocShell* pNewDocShell,
    1279             :                                          const ScRange& aMarkRange, const ScMarkData& rMark,
    1280             :                                          ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc, bool bNewMulti, InsertDeleteFlags nNewFlag) :
    1281             : ScSimpleUndo( pNewDocShell ),
    1282             : aMarkData   ( rMark ),
    1283             : pUndoDoc    ( pNewUndoDoc ),
    1284             : pRedoDoc    ( pNewRedoDoc ),
    1285             : aRange      ( aMarkRange ),
    1286             : bMulti      ( bNewMulti ),
    1287           0 : nFlags      ( nNewFlag )
    1288             : {
    1289           0 :     SetChangeTrack();
    1290           0 : }
    1291             : 
    1292           0 : ScUndoRefConversion::~ScUndoRefConversion()
    1293             : {
    1294           0 :     delete pUndoDoc;
    1295           0 :     delete pRedoDoc;
    1296           0 : }
    1297             : 
    1298           0 : OUString ScUndoRefConversion::GetComment() const
    1299             : {
    1300           0 :     return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Input"
    1301             : }
    1302             : 
    1303           0 : void ScUndoRefConversion::SetChangeTrack()
    1304             : {
    1305           0 :     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
    1306           0 :     if ( pChangeTrack && (nFlags & IDF_FORMULA) )
    1307             :         pChangeTrack->AppendContentsIfInRefDoc( pUndoDoc,
    1308           0 :             nStartChangeAction, nEndChangeAction );
    1309             :     else
    1310           0 :         nStartChangeAction = nEndChangeAction = 0;
    1311           0 : }
    1312             : 
    1313           0 : void ScUndoRefConversion::DoChange( ScDocument* pRefDoc)
    1314             : {
    1315           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1316             : 
    1317           0 :     ShowTable(aRange);
    1318             : 
    1319           0 :     SetViewMarkData( aMarkData );
    1320             : 
    1321           0 :     ScRange aCopyRange = aRange;
    1322           0 :     SCTAB nTabCount = rDoc.GetTableCount();
    1323           0 :     aCopyRange.aStart.SetTab(0);
    1324           0 :     aCopyRange.aEnd.SetTab(nTabCount-1);
    1325           0 :     pRefDoc->CopyToDocument( aCopyRange, nFlags, bMulti, &rDoc, &aMarkData );
    1326           0 :     pDocShell->PostPaint( aRange, PAINT_GRID);
    1327           0 :     pDocShell->PostDataChanged();
    1328           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
    1329           0 :     if (pViewShell)
    1330           0 :         pViewShell->CellContentChanged();
    1331           0 : }
    1332             : 
    1333           0 : void ScUndoRefConversion::Undo()
    1334             : {
    1335           0 :     BeginUndo();
    1336           0 :     if (pUndoDoc)
    1337           0 :         DoChange(pUndoDoc);
    1338           0 :     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
    1339           0 :     if ( pChangeTrack )
    1340           0 :         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
    1341           0 :     EndUndo();
    1342           0 : }
    1343             : 
    1344           0 : void ScUndoRefConversion::Redo()
    1345             : {
    1346           0 :     BeginRedo();
    1347           0 :     if (pRedoDoc)
    1348           0 :         DoChange(pRedoDoc);
    1349           0 :     SetChangeTrack();
    1350           0 :     EndRedo();
    1351           0 : }
    1352             : 
    1353           0 : void ScUndoRefConversion::Repeat(SfxRepeatTarget& rTarget)
    1354             : {
    1355           0 :     if (rTarget.ISA(ScTabViewTarget))
    1356           0 :         static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->DoRefConversion();
    1357           0 : }
    1358             : 
    1359           0 : bool ScUndoRefConversion::CanRepeat(SfxRepeatTarget& rTarget) const
    1360             : {
    1361           0 :     return rTarget.ISA(ScTabViewTarget);
    1362             : }
    1363             : 
    1364           4 : ScUndoRefreshLink::ScUndoRefreshLink( ScDocShell* pNewDocShell,
    1365             :                                     ScDocument* pNewUndoDoc )
    1366             :     :   ScSimpleUndo( pNewDocShell ),
    1367             :         pUndoDoc( pNewUndoDoc ),
    1368           4 :         pRedoDoc( NULL )
    1369             : {
    1370           4 : }
    1371             : 
    1372          12 : ScUndoRefreshLink::~ScUndoRefreshLink()
    1373             : {
    1374           4 :     delete pUndoDoc;
    1375           4 :     delete pRedoDoc;
    1376           8 : }
    1377             : 
    1378          12 : OUString ScUndoRefreshLink::GetComment() const
    1379             : {
    1380          12 :     return ScGlobal::GetRscString( STR_UNDO_UPDATELINK );
    1381             : }
    1382             : 
    1383           0 : void ScUndoRefreshLink::Undo()
    1384             : {
    1385           0 :     BeginUndo();
    1386             : 
    1387           0 :     bool bMakeRedo = !pRedoDoc;
    1388           0 :     if (bMakeRedo)
    1389           0 :         pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
    1390             : 
    1391           0 :     bool bFirst = true;
    1392           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1393           0 :     SCTAB nCount = rDoc.GetTableCount();
    1394           0 :     for (SCTAB nTab=0; nTab<nCount; nTab++)
    1395           0 :         if (pUndoDoc->HasTable(nTab))
    1396             :         {
    1397           0 :             ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab);
    1398           0 :             if (bMakeRedo)
    1399             :             {
    1400           0 :                 if (bFirst)
    1401           0 :                     pRedoDoc->InitUndo( &rDoc, nTab, nTab, true, true );
    1402             :                 else
    1403           0 :                     pRedoDoc->AddUndoTab( nTab, nTab, true, true );
    1404           0 :                 bFirst = false;
    1405           0 :                 rDoc.CopyToDocument(aRange, IDF_ALL, false, pRedoDoc);
    1406             :                 pRedoDoc->SetLink( nTab,
    1407           0 :                                    rDoc.GetLinkMode(nTab),
    1408             :                                    rDoc.GetLinkDoc(nTab),
    1409             :                                    rDoc.GetLinkFlt(nTab),
    1410             :                                    rDoc.GetLinkOpt(nTab),
    1411             :                                    rDoc.GetLinkTab(nTab),
    1412           0 :                                    rDoc.GetLinkRefreshDelay(nTab) );
    1413           0 :                 pRedoDoc->SetTabBgColor( nTab, rDoc.GetTabBgColor(nTab) );
    1414             :             }
    1415             : 
    1416           0 :             rDoc.DeleteAreaTab( aRange,IDF_ALL );
    1417           0 :             pUndoDoc->CopyToDocument( aRange, IDF_ALL, false, &rDoc );
    1418           0 :             rDoc.SetLink( nTab, pUndoDoc->GetLinkMode(nTab), pUndoDoc->GetLinkDoc(nTab),
    1419             :                                  pUndoDoc->GetLinkFlt(nTab),  pUndoDoc->GetLinkOpt(nTab),
    1420             :                                  pUndoDoc->GetLinkTab(nTab),
    1421           0 :                                  pUndoDoc->GetLinkRefreshDelay(nTab) );
    1422           0 :             rDoc.SetTabBgColor( nTab, pUndoDoc->GetTabBgColor(nTab) );
    1423             :         }
    1424             : 
    1425           0 :     pDocShell->PostPaintGridAll();
    1426           0 :         pDocShell->PostPaintExtras();
    1427             : 
    1428           0 :     EndUndo();
    1429           0 : }
    1430             : 
    1431           0 : void ScUndoRefreshLink::Redo()
    1432             : {
    1433             :     OSL_ENSURE(pRedoDoc, "No RedoDoc for ScUndoRefreshLink::Redo");
    1434             : 
    1435           0 :     BeginUndo();
    1436             : 
    1437           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1438           0 :     SCTAB nCount = rDoc.GetTableCount();
    1439           0 :     for (SCTAB nTab=0; nTab<nCount; nTab++)
    1440           0 :         if (pRedoDoc->HasTable(nTab))
    1441             :         {
    1442           0 :             ScRange aRange(0,0,nTab,MAXCOL,MAXROW,nTab);
    1443             : 
    1444           0 :             rDoc.DeleteAreaTab( aRange, IDF_ALL );
    1445           0 :             pRedoDoc->CopyToDocument( aRange, IDF_ALL, false, &rDoc );
    1446             :             rDoc.SetLink( nTab,
    1447           0 :                            pRedoDoc->GetLinkMode(nTab),
    1448             :                            pRedoDoc->GetLinkDoc(nTab),
    1449             :                            pRedoDoc->GetLinkFlt(nTab),
    1450             :                            pRedoDoc->GetLinkOpt(nTab),
    1451             :                            pRedoDoc->GetLinkTab(nTab),
    1452           0 :                            pRedoDoc->GetLinkRefreshDelay(nTab) );
    1453           0 :             rDoc.SetTabBgColor( nTab, pRedoDoc->GetTabBgColor(nTab) );
    1454             :         }
    1455             : 
    1456           0 :     pDocShell->PostPaintGridAll();
    1457           0 :         pDocShell->PostPaintExtras();
    1458             : 
    1459           0 :     EndUndo();
    1460           0 : }
    1461             : 
    1462           0 : void ScUndoRefreshLink::Repeat(SfxRepeatTarget& /* rTarget */)
    1463             : {
    1464             :     // makes no sense
    1465           0 : }
    1466             : 
    1467           8 : bool ScUndoRefreshLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
    1468             : {
    1469           8 :     return false;
    1470             : }
    1471             : 
    1472           0 : static ScAreaLink* lcl_FindAreaLink( sfx2::LinkManager* pLinkManager, const OUString& rDoc,
    1473             :                             const OUString& rFlt, const OUString& rOpt,
    1474             :                             const OUString& rSrc, const ScRange& rDest )
    1475             : {
    1476           0 :     const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
    1477           0 :     sal_uInt16 nCount = pLinkManager->GetLinks().size();
    1478           0 :     for (sal_uInt16 i=0; i<nCount; i++)
    1479             :     {
    1480           0 :         ::sfx2::SvBaseLink* pBase = *rLinks[i];
    1481           0 :         if (pBase->ISA(ScAreaLink))
    1482           0 :             if ( static_cast<ScAreaLink*>(pBase)->IsEqual( rDoc, rFlt, rOpt, rSrc, rDest ) )
    1483           0 :                 return static_cast<ScAreaLink*>(pBase);
    1484             :     }
    1485             : 
    1486             :     OSL_FAIL("ScAreaLink not found");
    1487           0 :     return NULL;
    1488             : }
    1489             : 
    1490          32 : ScUndoInsertAreaLink::ScUndoInsertAreaLink( ScDocShell* pShell,
    1491             :                             const OUString& rDoc,
    1492             :                             const OUString& rFlt, const OUString& rOpt,
    1493             :                             const OUString& rArea, const ScRange& rDestRange,
    1494             :                             sal_uLong nRefresh )
    1495             :     :   ScSimpleUndo    ( pShell ),
    1496             :         aDocName        ( rDoc ),
    1497             :         aFltName        ( rFlt ),
    1498             :         aOptions        ( rOpt ),
    1499             :         aAreaName       ( rArea ),
    1500             :         aRange          ( rDestRange ),
    1501          32 :         nRefreshDelay   ( nRefresh )
    1502             : {
    1503          32 : }
    1504             : 
    1505          64 : ScUndoInsertAreaLink::~ScUndoInsertAreaLink()
    1506             : {
    1507          64 : }
    1508             : 
    1509          32 : OUString ScUndoInsertAreaLink::GetComment() const
    1510             : {
    1511          32 :     return ScGlobal::GetRscString( STR_UNDO_INSERTAREALINK );
    1512             : }
    1513             : 
    1514           0 : void ScUndoInsertAreaLink::Undo()
    1515             : {
    1516           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1517           0 :     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
    1518             : 
    1519             :     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
    1520           0 :                                             aAreaName, aRange );
    1521           0 :     if (pLink)
    1522           0 :         pLinkManager->Remove( pLink );
    1523             : 
    1524           0 :     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );     // Navigator
    1525           0 : }
    1526             : 
    1527           0 : void ScUndoInsertAreaLink::Redo()
    1528             : {
    1529           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1530           0 :     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
    1531             : 
    1532             :     ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
    1533           0 :                                             aAreaName, aRange.aStart, nRefreshDelay );
    1534           0 :     pLink->SetInCreate( true );
    1535           0 :     pLink->SetDestArea( aRange );
    1536           0 :     pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName, &aAreaName );
    1537           0 :     pLink->Update();
    1538           0 :     pLink->SetInCreate( false );
    1539             : 
    1540           0 :     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );     // Navigator
    1541           0 : }
    1542             : 
    1543           0 : void ScUndoInsertAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
    1544             : {
    1545             :     // makes no sense
    1546           0 : }
    1547             : 
    1548           0 : bool ScUndoInsertAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
    1549             : {
    1550           0 :     return false;
    1551             : }
    1552             : 
    1553           0 : ScUndoRemoveAreaLink::ScUndoRemoveAreaLink( ScDocShell* pShell,
    1554             :                             const OUString& rDoc, const OUString& rFlt, const OUString& rOpt,
    1555             :                             const OUString& rArea, const ScRange& rDestRange,
    1556             :                             sal_uLong nRefresh )
    1557             :     :   ScSimpleUndo    ( pShell ),
    1558             :         aDocName        ( rDoc ),
    1559             :         aFltName        ( rFlt ),
    1560             :         aOptions        ( rOpt ),
    1561             :         aAreaName       ( rArea ),
    1562             :         aRange          ( rDestRange ),
    1563           0 :         nRefreshDelay   ( nRefresh )
    1564             : {
    1565           0 : }
    1566             : 
    1567           0 : ScUndoRemoveAreaLink::~ScUndoRemoveAreaLink()
    1568             : {
    1569           0 : }
    1570             : 
    1571           0 : OUString ScUndoRemoveAreaLink::GetComment() const
    1572             : {
    1573           0 :     return ScGlobal::GetRscString( STR_UNDO_REMOVELINK );   //! eigener Text ??
    1574             : }
    1575             : 
    1576           0 : void ScUndoRemoveAreaLink::Undo()
    1577             : {
    1578           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1579           0 :     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
    1580             : 
    1581             :     ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
    1582           0 :                                         aAreaName, aRange.aStart, nRefreshDelay );
    1583           0 :     pLink->SetInCreate( true );
    1584           0 :     pLink->SetDestArea( aRange );
    1585           0 :     pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aDocName, &aFltName, &aAreaName );
    1586           0 :     pLink->Update();
    1587           0 :     pLink->SetInCreate( false );
    1588             : 
    1589           0 :     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );     // Navigator
    1590           0 : }
    1591             : 
    1592           0 : void ScUndoRemoveAreaLink::Redo()
    1593             : {
    1594           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1595           0 :     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
    1596             : 
    1597             :     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
    1598           0 :                                             aAreaName, aRange );
    1599           0 :     if (pLink)
    1600           0 :         pLinkManager->Remove( pLink );
    1601             : 
    1602           0 :     SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );     // Navigator
    1603           0 : }
    1604             : 
    1605           0 : void ScUndoRemoveAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
    1606             : {
    1607             :     // makes no sense
    1608           0 : }
    1609             : 
    1610           0 : bool ScUndoRemoveAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
    1611             : {
    1612           0 :     return false;
    1613             : }
    1614             : 
    1615           8 : ScUndoUpdateAreaLink::ScUndoUpdateAreaLink( ScDocShell* pShell,
    1616             :                             const OUString& rOldD, const OUString& rOldF, const OUString& rOldO,
    1617             :                             const OUString& rOldA, const ScRange& rOldR, sal_uLong nOldRD,
    1618             :                             const OUString& rNewD, const OUString& rNewF, const OUString& rNewO,
    1619             :                             const OUString& rNewA, const ScRange& rNewR, sal_uLong nNewRD,
    1620             :                             ScDocument* pUndo, ScDocument* pRedo, bool bDoInsert )
    1621             :     :   ScSimpleUndo( pShell ),
    1622             :         aOldDoc     ( rOldD ),
    1623             :         aOldFlt     ( rOldF ),
    1624             :         aOldOpt     ( rOldO ),
    1625             :         aOldArea    ( rOldA ),
    1626             :         aOldRange   ( rOldR ),
    1627             :         aNewDoc     ( rNewD ),
    1628             :         aNewFlt     ( rNewF ),
    1629             :         aNewOpt     ( rNewO ),
    1630             :         aNewArea    ( rNewA ),
    1631             :         aNewRange   ( rNewR ),
    1632             :         pUndoDoc    ( pUndo ),
    1633             :         pRedoDoc    ( pRedo ),
    1634             :         nOldRefresh ( nOldRD ),
    1635             :         nNewRefresh ( nNewRD ),
    1636           8 :         bWithInsert ( bDoInsert )
    1637             : {
    1638             :     OSL_ENSURE( aOldRange.aStart == aNewRange.aStart, "AreaLink moved ?" );
    1639           8 : }
    1640             : 
    1641          24 : ScUndoUpdateAreaLink::~ScUndoUpdateAreaLink()
    1642             : {
    1643           8 :     delete pUndoDoc;
    1644           8 :     delete pRedoDoc;
    1645          16 : }
    1646             : 
    1647          20 : OUString ScUndoUpdateAreaLink::GetComment() const
    1648             : {
    1649          20 :     return ScGlobal::GetRscString( STR_UNDO_UPDATELINK );   //! own text ??
    1650             : }
    1651             : 
    1652           0 : void ScUndoUpdateAreaLink::DoChange( const bool bUndo ) const
    1653             : {
    1654           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1655             : 
    1656           0 :     SCCOL nEndX = std::max( aOldRange.aEnd.Col(), aNewRange.aEnd.Col() );
    1657           0 :     SCROW nEndY = std::max( aOldRange.aEnd.Row(), aNewRange.aEnd.Row() );
    1658           0 :     SCTAB nEndZ = std::max( aOldRange.aEnd.Tab(), aNewRange.aEnd.Tab() );    //?
    1659             : 
    1660           0 :     if ( bUndo )
    1661             :     {
    1662           0 :         if ( bWithInsert )
    1663             :         {
    1664           0 :             rDoc.FitBlock( aNewRange, aOldRange );
    1665           0 :             rDoc.DeleteAreaTab( aOldRange, IDF_ALL & ~IDF_NOTE );
    1666           0 :             pUndoDoc->UndoToDocument( aOldRange, IDF_ALL & ~IDF_NOTE, false, &rDoc );
    1667             :         }
    1668             :         else
    1669             :         {
    1670           0 :             ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
    1671           0 :             rDoc.DeleteAreaTab( aCopyRange, IDF_ALL & ~IDF_NOTE );
    1672           0 :             pUndoDoc->CopyToDocument( aCopyRange, IDF_ALL & ~IDF_NOTE, false, &rDoc );
    1673             :         }
    1674             :     }
    1675             :     else
    1676             :     {
    1677           0 :         if ( bWithInsert )
    1678             :         {
    1679           0 :             rDoc.FitBlock( aOldRange, aNewRange );
    1680           0 :             rDoc.DeleteAreaTab( aNewRange, IDF_ALL & ~IDF_NOTE );
    1681           0 :             pRedoDoc->CopyToDocument( aNewRange, IDF_ALL & ~IDF_NOTE, false, &rDoc );
    1682             :         }
    1683             :         else
    1684             :         {
    1685           0 :             ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
    1686           0 :             rDoc.DeleteAreaTab( aCopyRange, IDF_ALL & ~IDF_NOTE );
    1687           0 :             pRedoDoc->CopyToDocument( aCopyRange, IDF_ALL & ~IDF_NOTE, false, &rDoc );
    1688             :         }
    1689             :     }
    1690             : 
    1691           0 :     ScRange aWorkRange( aNewRange.aStart, ScAddress( nEndX, nEndY, nEndZ ) );
    1692           0 :     rDoc.ExtendMerge( aWorkRange, true );
    1693             : 
    1694             :     //  Paint
    1695             : 
    1696           0 :     if ( aNewRange.aEnd.Col() != aOldRange.aEnd.Col() )
    1697           0 :         aWorkRange.aEnd.SetCol(MAXCOL);
    1698           0 :     if ( aNewRange.aEnd.Row() != aOldRange.aEnd.Row() )
    1699           0 :         aWorkRange.aEnd.SetRow(MAXROW);
    1700             : 
    1701           0 :     if ( !pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), aWorkRange.aStart.Tab() ) )
    1702           0 :         pDocShell->PostPaint( aWorkRange, PAINT_GRID );
    1703             : 
    1704           0 :     pDocShell->PostDataChanged();
    1705           0 :     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
    1706           0 :     if (pViewShell)
    1707           0 :         pViewShell->CellContentChanged();
    1708           0 : }
    1709             : 
    1710           0 : void ScUndoUpdateAreaLink::Undo()
    1711             : {
    1712           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1713           0 :     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
    1714             :     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aNewDoc, aNewFlt, aNewOpt,
    1715           0 :                                             aNewArea, aNewRange );
    1716           0 :     if (pLink)
    1717             :     {
    1718           0 :         pLink->SetSource( aOldDoc, aOldFlt, aOldOpt, aOldArea );        // old data in Link
    1719           0 :         pLink->SetDestArea( aOldRange );
    1720           0 :         pLink->SetRefreshDelay( nOldRefresh );
    1721             :     }
    1722             : 
    1723           0 :     DoChange(true);
    1724           0 : }
    1725             : 
    1726           0 : void ScUndoUpdateAreaLink::Redo()
    1727             : {
    1728           0 :     ScDocument& rDoc = pDocShell->GetDocument();
    1729           0 :     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
    1730             :     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aOldDoc, aOldFlt, aOldOpt,
    1731           0 :                                             aOldArea, aOldRange );
    1732           0 :     if (pLink)
    1733             :     {
    1734           0 :         pLink->SetSource( aNewDoc, aNewFlt, aNewOpt, aNewArea );        // neue Werte im Link
    1735           0 :         pLink->SetDestArea( aNewRange );
    1736           0 :         pLink->SetRefreshDelay( nNewRefresh );
    1737             :     }
    1738             : 
    1739           0 :     DoChange(false);
    1740           0 : }
    1741             : 
    1742           0 : void ScUndoUpdateAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
    1743             : {
    1744             :     // makes no sense
    1745           0 : }
    1746             : 
    1747          12 : bool ScUndoUpdateAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
    1748             : {
    1749          12 :     return false;
    1750         228 : }
    1751             : 
    1752             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10