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