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 78 : 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 78 : bMulti ( bNewMulti ) // unnecessary
88 : {
89 78 : if (bObjects)
90 6 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
91 :
92 78 : if ( !(aMarkData.IsMarked() || aMarkData.IsMultiMarked()) ) // if no cell is selected:
93 0 : aMarkData.SetMarkArea( aRange ); // select cell under cursor
94 :
95 78 : SetChangeTrack();
96 78 : }
97 :
98 233 : ScUndoDeleteContents::~ScUndoDeleteContents()
99 : {
100 78 : delete pUndoDoc;
101 78 : DeleteSdrUndoAction( pDrawUndo );
102 155 : }
103 :
104 80 : OUString ScUndoDeleteContents::GetComment() const
105 : {
106 80 : return ScGlobal::GetRscString( STR_UNDO_DELETECONTENTS ); // "Delete"
107 : }
108 :
109 77 : void ScUndoDeleteContents::SetDataSpans( const boost::shared_ptr<DataSpansType>& pSpans )
110 : {
111 77 : mpDataSpans = pSpans;
112 77 : }
113 :
114 80 : void ScUndoDeleteContents::SetChangeTrack()
115 : {
116 80 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
117 80 : if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
118 : pChangeTrack->AppendContentRange( aRange, pUndoDoc,
119 0 : nStartChangeAction, nEndChangeAction );
120 : else
121 80 : nStartChangeAction = nEndChangeAction = 0;
122 80 : }
123 :
124 5 : void ScUndoDeleteContents::DoChange( const bool bUndo )
125 : {
126 5 : ScDocument& rDoc = pDocShell->GetDocument();
127 :
128 5 : SetViewMarkData( aMarkData );
129 :
130 5 : sal_uInt16 nExtFlags = 0;
131 :
132 5 : if (bUndo) // only Undo
133 : {
134 3 : InsertDeleteFlags nUndoFlags = IDF_NONE; // copy either all or none of the content
135 3 : if (nFlags & IDF_CONTENTS) // (Only the correct ones have been copied into UndoDoc)
136 3 : nUndoFlags |= IDF_CONTENTS;
137 3 : if (nFlags & IDF_ATTRIB)
138 1 : nUndoFlags |= IDF_ATTRIB;
139 3 : 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 3 : nUndoFlags |= IDF_NOCAPTIONS;
143 :
144 3 : ScRange aCopyRange = aRange;
145 3 : SCTAB nTabCount = rDoc.GetTableCount();
146 3 : aCopyRange.aStart.SetTab(0);
147 3 : aCopyRange.aEnd.SetTab(nTabCount-1);
148 :
149 3 : pUndoDoc->CopyToDocument( aCopyRange, nUndoFlags, bMulti, &rDoc, &aMarkData );
150 :
151 3 : DoSdrUndoAction( pDrawUndo, &rDoc );
152 :
153 3 : ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
154 3 : if ( pChangeTrack )
155 0 : pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
156 :
157 3 : pDocShell->UpdatePaintExt( nExtFlags, aRange ); // content after the change
158 : }
159 : else // only Redo
160 : {
161 2 : pDocShell->UpdatePaintExt( nExtFlags, aRange ); // content before the change
162 :
163 2 : aMarkData.MarkToMulti();
164 2 : RedoSdrUndoAction( pDrawUndo );
165 : // do not delete objects and note captions, they have been removed via drawing undo
166 2 : InsertDeleteFlags nRedoFlags = (nFlags & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
167 2 : rDoc.DeleteSelection( nRedoFlags, aMarkData );
168 2 : aMarkData.MarkToSimple();
169 :
170 2 : SetChangeTrack();
171 : }
172 :
173 5 : if (nFlags & IDF_CONTENTS)
174 : {
175 : // Broadcast only when the content changes. fdo#74687
176 5 : if (mpDataSpans)
177 3 : BroadcastChanges(*mpDataSpans);
178 : else
179 2 : BroadcastChanges(aRange);
180 : }
181 :
182 5 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
183 5 : if ( !( (pViewShell) && pViewShell->AdjustRowHeight(
184 5 : aRange.aStart.Row(), aRange.aEnd.Row() ) ) )
185 5 : /*A*/ pDocShell->PostPaint( aRange, PAINT_GRID | PAINT_EXTRAS, nExtFlags );
186 :
187 5 : if (pViewShell)
188 0 : pViewShell->CellContentChanged();
189 :
190 5 : ShowTable( aRange );
191 5 : }
192 :
193 3 : void ScUndoDeleteContents::Undo()
194 : {
195 3 : BeginUndo();
196 3 : DoChange( true );
197 3 : EndUndo();
198 :
199 3 : HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, aRange);
200 3 : }
201 :
202 2 : void ScUndoDeleteContents::Redo()
203 : {
204 2 : BeginRedo();
205 2 : DoChange( false );
206 2 : EndRedo();
207 :
208 2 : HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, aRange);
209 2 : }
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 470 : 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 470 : mpDataArray(new ScEditDataArray),
366 : pUndoDoc ( pNewUndoDoc ),
367 940 : bMulti ( bNewMulti )
368 : {
369 470 : ScDocumentPool* pPool = pDocShell->GetDocument().GetPool();
370 470 : pApplyPattern = const_cast<ScPatternAttr*>(static_cast<const ScPatternAttr*>( &pPool->Put( *pNewApply ) ));
371 470 : pLineOuter = pNewOuter ? const_cast<SvxBoxItem*>(static_cast<const SvxBoxItem*>( &pPool->Put( *pNewOuter ) )) : NULL;
372 470 : pLineInner = pNewInner ? const_cast<SvxBoxInfoItem*>(static_cast<const SvxBoxInfoItem*>( &pPool->Put( *pNewInner ) )) : NULL;
373 470 : }
374 :
375 1410 : ScUndoSelectionAttr::~ScUndoSelectionAttr()
376 : {
377 470 : ScDocumentPool* pPool = pDocShell->GetDocument().GetPool();
378 470 : pPool->Remove(*pApplyPattern);
379 470 : if (pLineOuter)
380 0 : pPool->Remove(*pLineOuter);
381 470 : if (pLineInner)
382 0 : pPool->Remove(*pLineInner);
383 :
384 470 : delete pUndoDoc;
385 940 : }
386 :
387 518 : OUString ScUndoSelectionAttr::GetComment() const
388 : {
389 : //"Attribute" "/Lines"
390 518 : 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 24 : bool ScUndoSelectionAttr::CanRepeat(SfxRepeatTarget& rTarget) const
491 : {
492 24 : return rTarget.ISA(ScTabViewTarget);
493 : }
494 :
495 16 : 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 16 : fMaxValue ( fNewMaxValue )
510 : {
511 16 : SetChangeTrack();
512 16 : }
513 :
514 48 : ScUndoAutoFill::~ScUndoAutoFill()
515 : {
516 16 : delete pUndoDoc;
517 32 : }
518 :
519 18 : OUString ScUndoAutoFill::GetComment() const
520 : {
521 18 : return ScGlobal::GetRscString( STR_UNDO_AUTOFILL ); //"Fill"
522 : }
523 :
524 17 : void ScUndoAutoFill::SetChangeTrack()
525 : {
526 17 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
527 17 : if ( pChangeTrack )
528 : pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
529 0 : nStartChangeAction, nEndChangeAction );
530 : else
531 17 : nStartChangeAction = nEndChangeAction = 0;
532 17 : }
533 :
534 1 : void ScUndoAutoFill::Undo()
535 : {
536 1 : BeginUndo();
537 :
538 1 : ScDocument& rDoc = pDocShell->GetDocument();
539 :
540 1 : SCTAB nTabCount = rDoc.GetTableCount();
541 1 : ScMarkData::iterator itr = aMarkData.begin(), itrEnd = aMarkData.end();
542 2 : for (; itr != itrEnd && *itr < nTabCount; ++itr)
543 : {
544 1 : ScRange aWorkRange = aBlockRange;
545 1 : aWorkRange.aStart.SetTab(*itr);
546 1 : aWorkRange.aEnd.SetTab(*itr);
547 :
548 1 : sal_uInt16 nExtFlags = 0;
549 1 : pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
550 1 : rDoc.DeleteAreaTab( aWorkRange, IDF_AUTOFILL );
551 1 : pUndoDoc->CopyToDocument( aWorkRange, IDF_AUTOFILL, false, &rDoc );
552 :
553 1 : rDoc.ExtendMerge( aWorkRange, true );
554 1 : pDocShell->PostPaint( aWorkRange, PAINT_GRID, nExtFlags );
555 : }
556 1 : pDocShell->PostDataChanged();
557 1 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
558 1 : if (pViewShell)
559 0 : pViewShell->CellContentChanged();
560 :
561 1 : ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
562 1 : if ( pChangeTrack )
563 0 : pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
564 :
565 1 : EndUndo();
566 1 : }
567 :
568 1 : void ScUndoAutoFill::Redo()
569 : {
570 1 : BeginRedo();
571 :
572 : //! Select sheet
573 :
574 1 : SCCOLROW nCount = 0;
575 1 : switch (eFillDir)
576 : {
577 : case FILL_TO_BOTTOM:
578 1 : nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();
579 1 : 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 1 : ScDocument& rDoc = pDocShell->GetDocument();
592 1 : 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 1 : if (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP)
601 1 : nProgCount = aSource.aEnd.Col() - aSource.aStart.Col() + 1;
602 : else
603 0 : nProgCount = aSource.aEnd.Row() - aSource.aStart.Row() + 1;
604 1 : nProgCount *= nCount;
605 : ScProgress aProgress( rDoc.GetDocumentShell(),
606 1 : ScGlobal::GetRscString(STR_FILL_SERIES_PROGRESS), nProgCount );
607 :
608 1 : rDoc.Fill( aSource.aStart.Col(), aSource.aStart.Row(),
609 1 : aSource.aEnd.Col(), aSource.aEnd.Row(), &aProgress,
610 : aMarkData, nCount,
611 : eFillDir, eFillCmd, eFillDateCmd,
612 3 : fStepValue, fMaxValue );
613 :
614 1 : SetChangeTrack();
615 :
616 1 : pDocShell->PostPaint( aBlockRange, PAINT_GRID );
617 1 : pDocShell->PostDataChanged();
618 1 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
619 1 : if (pViewShell)
620 0 : pViewShell->CellContentChanged();
621 :
622 1 : EndRedo();
623 1 : }
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 0 : bool ScUndoAutoFill::CanRepeat(SfxRepeatTarget& rTarget) const
639 : {
640 0 : return rTarget.ISA(ScTabViewTarget);
641 : }
642 :
643 4 : 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 4 : mpDrawUndo( pDrawUndo )
650 : {
651 4 : }
652 :
653 12 : ScUndoMerge::~ScUndoMerge()
654 : {
655 4 : delete mpUndoDoc;
656 4 : DeleteSdrUndoAction( mpDrawUndo );
657 8 : }
658 :
659 4 : OUString ScUndoMerge::GetComment() const
660 : {
661 4 : 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 : ScopedVclPtrInstance< VirtualDevice > pVirtDev;
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, pVirtDev);
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 : pVirtDev, 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 22 : 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 22 : pUndoDoc ( pNewUndoDoc )
926 : {
927 22 : pSearchItem = new SvxSearchItem( *pItem );
928 22 : SetChangeTrack();
929 22 : }
930 :
931 66 : ScUndoReplace::~ScUndoReplace()
932 : {
933 22 : delete pUndoDoc;
934 22 : delete pSearchItem;
935 44 : }
936 :
937 22 : void ScUndoReplace::SetChangeTrack()
938 : {
939 22 : ScDocument& rDoc = pDocShell->GetDocument();
940 22 : ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
941 22 : 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 22 : nStartChangeAction = nEndChangeAction = 0;
964 22 : }
965 :
966 22 : OUString ScUndoReplace::GetComment() const
967 : {
968 22 : 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() == SvxSearchCmd::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() == SvxSearchCmd::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() == SvxSearchCellType::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() == SvxSearchCmd::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 3 : 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 3 : meMode(eMode)
1113 : {
1114 3 : }
1115 :
1116 9 : ScUndoTabOp::~ScUndoTabOp()
1117 : {
1118 3 : delete pUndoDoc;
1119 6 : }
1120 :
1121 3 : OUString ScUndoTabOp::GetComment() const
1122 : {
1123 3 : 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 2 : ScUndoRefreshLink::ScUndoRefreshLink( ScDocShell* pNewDocShell,
1365 : ScDocument* pNewUndoDoc )
1366 : : ScSimpleUndo( pNewDocShell ),
1367 : pUndoDoc( pNewUndoDoc ),
1368 2 : pRedoDoc( NULL )
1369 : {
1370 2 : }
1371 :
1372 6 : ScUndoRefreshLink::~ScUndoRefreshLink()
1373 : {
1374 2 : delete pUndoDoc;
1375 2 : delete pRedoDoc;
1376 4 : }
1377 :
1378 6 : OUString ScUndoRefreshLink::GetComment() const
1379 : {
1380 6 : 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 4 : bool ScUndoRefreshLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1468 : {
1469 4 : 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 16 : 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 16 : nRefreshDelay ( nRefresh )
1502 : {
1503 16 : }
1504 :
1505 32 : ScUndoInsertAreaLink::~ScUndoInsertAreaLink()
1506 : {
1507 32 : }
1508 :
1509 16 : OUString ScUndoInsertAreaLink::GetComment() const
1510 : {
1511 16 : 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 4 : 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 4 : bWithInsert ( bDoInsert )
1637 : {
1638 : OSL_ENSURE( aOldRange.aStart == aNewRange.aStart, "AreaLink moved ?" );
1639 4 : }
1640 :
1641 12 : ScUndoUpdateAreaLink::~ScUndoUpdateAreaLink()
1642 : {
1643 4 : delete pUndoDoc;
1644 4 : delete pRedoDoc;
1645 8 : }
1646 :
1647 10 : OUString ScUndoUpdateAreaLink::GetComment() const
1648 : {
1649 10 : 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 6 : bool ScUndoUpdateAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1748 : {
1749 6 : return false;
1750 156 : }
1751 :
1752 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
