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 <sfx2/app.hxx>
21 :
22 : #include "undodat.hxx"
23 : #include "undoutil.hxx"
24 : #include "undoolk.hxx"
25 : #include "document.hxx"
26 : #include "docsh.hxx"
27 : #include "tabvwsh.hxx"
28 : #include "olinetab.hxx"
29 : #include "dbdata.hxx"
30 : #include "rangenam.hxx"
31 : #include "pivot.hxx"
32 : #include "globstr.hrc"
33 : #include "global.hxx"
34 : #include "globalnames.hxx"
35 : #include "target.hxx"
36 : #include "chartarr.hxx"
37 : #include "dbdocfun.hxx"
38 : #include "olinefun.hxx"
39 : #include "dpobject.hxx"
40 : #include "attrib.hxx"
41 : #include "hints.hxx"
42 : #include "sc.hrc"
43 : #include "chgtrack.hxx"
44 : #include "refundo.hxx"
45 : #include "markdata.hxx"
46 :
47 0 : TYPEINIT1(ScUndoDoOutline, ScSimpleUndo);
48 0 : TYPEINIT1(ScUndoMakeOutline, ScSimpleUndo);
49 0 : TYPEINIT1(ScUndoOutlineLevel, ScSimpleUndo);
50 0 : TYPEINIT1(ScUndoOutlineBlock, ScSimpleUndo);
51 0 : TYPEINIT1(ScUndoRemoveAllOutlines, ScSimpleUndo);
52 0 : TYPEINIT1(ScUndoAutoOutline, ScSimpleUndo);
53 0 : TYPEINIT1(ScUndoSubTotals, ScDBFuncUndo);
54 0 : TYPEINIT1(ScUndoQuery, ScDBFuncUndo);
55 0 : TYPEINIT1(ScUndoAutoFilter, ScDBFuncUndo);
56 0 : TYPEINIT1(ScUndoDBData, ScSimpleUndo);
57 0 : TYPEINIT1(ScUndoImportData, ScSimpleUndo);
58 0 : TYPEINIT1(ScUndoRepeatDB, ScSimpleUndo);
59 0 : TYPEINIT1(ScUndoDataPilot, ScSimpleUndo);
60 0 : TYPEINIT1(ScUndoConsolidate, ScSimpleUndo);
61 0 : TYPEINIT1(ScUndoChartData, ScSimpleUndo);
62 0 : TYPEINIT1(ScUndoDataForm, SfxUndoAction);
63 :
64 : // Show or hide outline groups
65 :
66 0 : ScUndoDoOutline::ScUndoDoOutline( ScDocShell* pNewDocShell,
67 : SCCOLROW nNewStart, SCCOLROW nNewEnd, SCTAB nNewTab,
68 : ScDocument* pNewUndoDoc, bool bNewColumns,
69 : sal_uInt16 nNewLevel, sal_uInt16 nNewEntry, bool bNewShow ) :
70 : ScSimpleUndo( pNewDocShell ),
71 : nStart( nNewStart ),
72 : nEnd( nNewEnd ),
73 : nTab( nNewTab ),
74 : pUndoDoc( pNewUndoDoc ),
75 : bColumns( bNewColumns ),
76 : nLevel( nNewLevel ),
77 : nEntry( nNewEntry ),
78 0 : bShow( bNewShow )
79 : {
80 0 : }
81 :
82 0 : ScUndoDoOutline::~ScUndoDoOutline()
83 : {
84 0 : delete pUndoDoc;
85 0 : }
86 :
87 0 : OUString ScUndoDoOutline::GetComment() const
88 : { // Show outline" "Hide outline"
89 : return bShow ?
90 : ScGlobal::GetRscString( STR_UNDO_DOOUTLINE ) :
91 0 : ScGlobal::GetRscString( STR_UNDO_REDOOUTLINE );
92 : }
93 :
94 0 : void ScUndoDoOutline::Undo()
95 : {
96 0 : BeginUndo();
97 :
98 0 : ScDocument& rDoc = pDocShell->GetDocument();
99 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
100 :
101 : // sheet has to be switched over (#46952#)!
102 :
103 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
104 0 : if ( nVisTab != nTab )
105 0 : pViewShell->SetTabNo( nTab );
106 :
107 : // perform the inverse function
108 :
109 0 : if (bShow)
110 0 : pViewShell->HideOutline( bColumns, nLevel, nEntry, false, false );
111 : else
112 0 : pViewShell->ShowOutline( bColumns, nLevel, nEntry, false, false );
113 :
114 : // Original column/row status
115 0 : if (bColumns)
116 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
117 0 : static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, false, &rDoc);
118 : else
119 0 : pUndoDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, false, &rDoc );
120 :
121 0 : pViewShell->UpdateScrollBars();
122 :
123 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP);
124 :
125 0 : EndUndo();
126 0 : }
127 :
128 0 : void ScUndoDoOutline::Redo()
129 : {
130 0 : BeginRedo();
131 :
132 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
133 :
134 : // sheet has to be switched over (#46952#)!
135 :
136 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
137 0 : if ( nVisTab != nTab )
138 0 : pViewShell->SetTabNo( nTab );
139 :
140 0 : if (bShow)
141 0 : pViewShell->ShowOutline( bColumns, nLevel, nEntry, false );
142 : else
143 0 : pViewShell->HideOutline( bColumns, nLevel, nEntry, false );
144 :
145 0 : EndRedo();
146 0 : }
147 :
148 0 : void ScUndoDoOutline::Repeat(SfxRepeatTarget& /* rTarget */)
149 : {
150 0 : }
151 :
152 0 : bool ScUndoDoOutline::CanRepeat(SfxRepeatTarget& /* rTarget */) const
153 : {
154 0 : return false; // is not possible
155 : }
156 :
157 : /** Make or delete outline groups */
158 24 : ScUndoMakeOutline::ScUndoMakeOutline( ScDocShell* pNewDocShell,
159 : SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
160 : SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
161 : ScOutlineTable* pNewUndoTab, bool bNewColumns, bool bNewMake ) :
162 : ScSimpleUndo( pNewDocShell ),
163 : aBlockStart( nStartX, nStartY, nStartZ ),
164 : aBlockEnd( nEndX, nEndY, nEndZ ),
165 : pUndoTable( pNewUndoTab ),
166 : bColumns( bNewColumns ),
167 24 : bMake( bNewMake )
168 : {
169 24 : }
170 :
171 72 : ScUndoMakeOutline::~ScUndoMakeOutline()
172 : {
173 24 : delete pUndoTable;
174 48 : }
175 :
176 24 : OUString ScUndoMakeOutline::GetComment() const
177 : { // "Grouping" "Undo grouping"
178 : return bMake ?
179 : ScGlobal::GetRscString( STR_UNDO_MAKEOUTLINE ) :
180 24 : ScGlobal::GetRscString( STR_UNDO_REMAKEOUTLINE );
181 : }
182 :
183 0 : void ScUndoMakeOutline::Undo()
184 : {
185 0 : BeginUndo();
186 :
187 0 : ScDocument& rDoc = pDocShell->GetDocument();
188 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
189 0 : SCTAB nTab = aBlockStart.Tab();
190 :
191 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart, aBlockEnd );
192 :
193 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
194 :
195 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
196 0 : if ( nVisTab != nTab )
197 0 : pViewShell->SetTabNo( nTab );
198 :
199 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
200 :
201 0 : EndUndo();
202 0 : }
203 :
204 0 : void ScUndoMakeOutline::Redo()
205 : {
206 0 : BeginRedo();
207 :
208 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
209 :
210 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart, aBlockEnd );
211 :
212 0 : if (bMake)
213 0 : pViewShell->MakeOutline( bColumns, false );
214 : else
215 0 : pViewShell->RemoveOutline( bColumns, false );
216 :
217 0 : pDocShell->PostPaint(0,0,aBlockStart.Tab(),MAXCOL,MAXROW,aBlockEnd.Tab(),PAINT_GRID);
218 :
219 0 : EndRedo();
220 0 : }
221 :
222 0 : void ScUndoMakeOutline::Repeat(SfxRepeatTarget& rTarget)
223 : {
224 0 : if (rTarget.ISA(ScTabViewTarget))
225 : {
226 0 : ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
227 :
228 0 : if (bMake)
229 0 : rViewShell.MakeOutline( bColumns, true );
230 : else
231 0 : rViewShell.RemoveOutline( bColumns, true );
232 : }
233 0 : }
234 :
235 0 : bool ScUndoMakeOutline::CanRepeat(SfxRepeatTarget& rTarget) const
236 : {
237 0 : return rTarget.ISA(ScTabViewTarget);
238 : }
239 :
240 2 : ScUndoOutlineLevel::ScUndoOutlineLevel( ScDocShell* pNewDocShell,
241 : SCCOLROW nNewStart, SCCOLROW nNewEnd, SCTAB nNewTab,
242 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
243 : bool bNewColumns, sal_uInt16 nNewLevel ) :
244 : ScSimpleUndo( pNewDocShell ),
245 : nStart( nNewStart ),
246 : nEnd( nNewEnd ),
247 : nTab( nNewTab ),
248 : pUndoDoc( pNewUndoDoc ),
249 : pUndoTable( pNewUndoTab ),
250 : bColumns( bNewColumns ),
251 2 : nLevel( nNewLevel )
252 : {
253 2 : }
254 :
255 6 : ScUndoOutlineLevel::~ScUndoOutlineLevel()
256 : {
257 2 : delete pUndoDoc;
258 2 : delete pUndoTable;
259 4 : }
260 :
261 2 : OUString ScUndoOutlineLevel::GetComment() const
262 : { // "Select outline level"
263 2 : return ScGlobal::GetRscString( STR_UNDO_OUTLINELEVEL );
264 : }
265 :
266 0 : void ScUndoOutlineLevel::Undo()
267 : {
268 0 : BeginUndo();
269 :
270 0 : ScDocument& rDoc = pDocShell->GetDocument();
271 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
272 :
273 : // Original Outline table
274 :
275 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
276 :
277 : // Original column/row status
278 :
279 0 : if (bColumns)
280 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
281 0 : static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, false, &rDoc);
282 : else
283 0 : pUndoDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, false, &rDoc );
284 :
285 0 : rDoc.UpdatePageBreaks( nTab );
286 :
287 0 : pViewShell->UpdateScrollBars();
288 :
289 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
290 0 : if ( nVisTab != nTab )
291 0 : pViewShell->SetTabNo( nTab );
292 :
293 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP);
294 :
295 0 : EndUndo();
296 0 : }
297 :
298 0 : void ScUndoOutlineLevel::Redo()
299 : {
300 0 : BeginRedo();
301 :
302 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
303 :
304 : // sheet has to be switched on or off before this (#46952#) !!!
305 :
306 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
307 0 : if ( nVisTab != nTab )
308 0 : pViewShell->SetTabNo( nTab );
309 :
310 0 : pViewShell->SelectLevel( bColumns, nLevel, false );
311 :
312 0 : EndRedo();
313 0 : }
314 :
315 0 : void ScUndoOutlineLevel::Repeat(SfxRepeatTarget& rTarget)
316 : {
317 0 : if (rTarget.ISA(ScTabViewTarget))
318 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->SelectLevel( bColumns, nLevel, true );
319 0 : }
320 :
321 0 : bool ScUndoOutlineLevel::CanRepeat(SfxRepeatTarget& rTarget) const
322 : {
323 0 : return rTarget.ISA(ScTabViewTarget);
324 : }
325 :
326 : /** show/hide outline over block marks */
327 42 : ScUndoOutlineBlock::ScUndoOutlineBlock( ScDocShell* pNewDocShell,
328 : SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
329 : SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
330 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab, bool bNewShow ) :
331 : ScSimpleUndo( pNewDocShell ),
332 : aBlockStart( nStartX, nStartY, nStartZ ),
333 : aBlockEnd( nEndX, nEndY, nEndZ ),
334 : pUndoDoc( pNewUndoDoc ),
335 : pUndoTable( pNewUndoTab ),
336 42 : bShow( bNewShow )
337 : {
338 42 : }
339 :
340 126 : ScUndoOutlineBlock::~ScUndoOutlineBlock()
341 : {
342 42 : delete pUndoDoc;
343 42 : delete pUndoTable;
344 84 : }
345 :
346 42 : OUString ScUndoOutlineBlock::GetComment() const
347 : { // "Show outline" "Hide outline"
348 : return bShow ?
349 : ScGlobal::GetRscString( STR_UNDO_DOOUTLINEBLK ) :
350 42 : ScGlobal::GetRscString( STR_UNDO_REDOOUTLINEBLK );
351 : }
352 :
353 0 : void ScUndoOutlineBlock::Undo()
354 : {
355 0 : BeginUndo();
356 :
357 0 : ScDocument& rDoc = pDocShell->GetDocument();
358 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
359 0 : SCTAB nTab = aBlockStart.Tab();
360 :
361 : // Original Outline table
362 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
363 :
364 : // Original column/row status
365 0 : SCCOLROW nStartCol = aBlockStart.Col();
366 0 : SCCOLROW nEndCol = aBlockEnd.Col();
367 0 : SCCOLROW nStartRow = aBlockStart.Row();
368 0 : SCCOLROW nEndRow = aBlockEnd.Row();
369 :
370 0 : if (!bShow)
371 : { // Size of the hidden blocks
372 : size_t nLevel;
373 0 : pUndoTable->GetColArray().FindTouchedLevel( nStartCol, nEndCol, nLevel );
374 0 : pUndoTable->GetColArray().ExtendBlock( nLevel, nStartCol, nEndCol );
375 0 : pUndoTable->GetRowArray().FindTouchedLevel( nStartRow, nEndRow, nLevel );
376 0 : pUndoTable->GetRowArray().ExtendBlock( nLevel, nStartRow, nEndRow );
377 : }
378 :
379 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
380 0 : static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, false, &rDoc );
381 0 : pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, false, &rDoc );
382 :
383 0 : rDoc.UpdatePageBreaks( nTab );
384 :
385 0 : pViewShell->UpdateScrollBars();
386 :
387 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
388 0 : if ( nVisTab != nTab )
389 0 : pViewShell->SetTabNo( nTab );
390 :
391 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP);
392 :
393 0 : EndUndo();
394 0 : }
395 :
396 0 : void ScUndoOutlineBlock::Redo()
397 : {
398 0 : BeginRedo();
399 :
400 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
401 :
402 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart, aBlockEnd );
403 0 : if (bShow)
404 0 : pViewShell->ShowMarkedOutlines( false );
405 : else
406 0 : pViewShell->HideMarkedOutlines( false );
407 :
408 0 : EndRedo();
409 0 : }
410 :
411 0 : void ScUndoOutlineBlock::Repeat(SfxRepeatTarget& rTarget)
412 : {
413 0 : if (rTarget.ISA(ScTabViewTarget))
414 : {
415 0 : ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
416 :
417 0 : if (bShow)
418 0 : rViewShell.ShowMarkedOutlines( true );
419 : else
420 0 : rViewShell.HideMarkedOutlines( true );
421 : }
422 0 : }
423 :
424 0 : bool ScUndoOutlineBlock::CanRepeat(SfxRepeatTarget& rTarget) const
425 : {
426 0 : return rTarget.ISA(ScTabViewTarget);
427 : }
428 :
429 8 : ScUndoRemoveAllOutlines::ScUndoRemoveAllOutlines( ScDocShell* pNewDocShell,
430 : SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
431 : SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
432 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab ) :
433 : ScSimpleUndo( pNewDocShell ),
434 : aBlockStart( nStartX, nStartY, nStartZ ),
435 : aBlockEnd( nEndX, nEndY, nEndZ ),
436 : pUndoDoc( pNewUndoDoc ),
437 8 : pUndoTable( pNewUndoTab )
438 : {
439 8 : }
440 :
441 24 : ScUndoRemoveAllOutlines::~ScUndoRemoveAllOutlines()
442 : {
443 8 : delete pUndoDoc;
444 8 : delete pUndoTable;
445 16 : }
446 :
447 8 : OUString ScUndoRemoveAllOutlines::GetComment() const
448 : { // "Remove outlines"
449 8 : return ScGlobal::GetRscString( STR_UNDO_REMOVEALLOTLNS );
450 : }
451 :
452 0 : void ScUndoRemoveAllOutlines::Undo()
453 : {
454 0 : BeginUndo();
455 :
456 0 : ScDocument& rDoc = pDocShell->GetDocument();
457 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
458 0 : SCTAB nTab = aBlockStart.Tab();
459 :
460 : // Original Outline table
461 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
462 :
463 : // Original column/row status
464 0 : SCCOL nStartCol = aBlockStart.Col();
465 0 : SCCOL nEndCol = aBlockEnd.Col();
466 0 : SCROW nStartRow = aBlockStart.Row();
467 0 : SCROW nEndRow = aBlockEnd.Row();
468 :
469 0 : pUndoDoc->CopyToDocument( nStartCol, 0, nTab, nEndCol, MAXROW, nTab, IDF_NONE, false, &rDoc );
470 0 : pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, false, &rDoc );
471 :
472 0 : rDoc.UpdatePageBreaks( nTab );
473 :
474 0 : pViewShell->UpdateScrollBars();
475 :
476 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
477 0 : if ( nVisTab != nTab )
478 0 : pViewShell->SetTabNo( nTab );
479 :
480 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
481 :
482 0 : EndUndo();
483 0 : }
484 :
485 0 : void ScUndoRemoveAllOutlines::Redo()
486 : {
487 0 : BeginRedo();
488 :
489 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
490 :
491 : // sheet has to be switched over (#46952#)!
492 :
493 0 : SCTAB nTab = aBlockStart.Tab();
494 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
495 0 : if ( nVisTab != nTab )
496 0 : pViewShell->SetTabNo( nTab );
497 :
498 0 : pViewShell->RemoveAllOutlines( false );
499 :
500 0 : EndRedo();
501 0 : }
502 :
503 0 : void ScUndoRemoveAllOutlines::Repeat(SfxRepeatTarget& rTarget)
504 : {
505 0 : if (rTarget.ISA(ScTabViewTarget))
506 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->RemoveAllOutlines( true );
507 0 : }
508 :
509 0 : bool ScUndoRemoveAllOutlines::CanRepeat(SfxRepeatTarget& rTarget) const
510 : {
511 0 : return rTarget.ISA(ScTabViewTarget);
512 : }
513 :
514 2 : ScUndoAutoOutline::ScUndoAutoOutline( ScDocShell* pNewDocShell,
515 : SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
516 : SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
517 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab ) :
518 : ScSimpleUndo( pNewDocShell ),
519 : aBlockStart( nStartX, nStartY, nStartZ ),
520 : aBlockEnd( nEndX, nEndY, nEndZ ),
521 : pUndoDoc( pNewUndoDoc ),
522 2 : pUndoTable( pNewUndoTab )
523 : {
524 2 : }
525 :
526 6 : ScUndoAutoOutline::~ScUndoAutoOutline()
527 : {
528 2 : delete pUndoDoc;
529 2 : delete pUndoTable;
530 4 : }
531 :
532 2 : OUString ScUndoAutoOutline::GetComment() const
533 : {
534 2 : return ScGlobal::GetRscString( STR_UNDO_AUTOOUTLINE );
535 : }
536 :
537 0 : void ScUndoAutoOutline::Undo()
538 : {
539 0 : BeginUndo();
540 :
541 0 : ScDocument& rDoc = pDocShell->GetDocument();
542 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
543 0 : SCTAB nTab = aBlockStart.Tab();
544 :
545 : // Original outline table
546 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
547 :
548 : // Original column/row status
549 0 : if (pUndoDoc && pUndoTable)
550 : {
551 : SCCOLROW nStartCol;
552 : SCCOLROW nStartRow;
553 : SCCOLROW nEndCol;
554 : SCCOLROW nEndRow;
555 0 : pUndoTable->GetColArray().GetRange( nStartCol, nEndCol );
556 0 : pUndoTable->GetRowArray().GetRange( nStartRow, nEndRow );
557 :
558 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
559 : static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, false,
560 0 : &rDoc);
561 0 : pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, false, &rDoc );
562 :
563 0 : pViewShell->UpdateScrollBars();
564 : }
565 :
566 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
567 0 : if ( nVisTab != nTab )
568 0 : pViewShell->SetTabNo( nTab );
569 :
570 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
571 :
572 0 : EndUndo();
573 0 : }
574 :
575 0 : void ScUndoAutoOutline::Redo()
576 : {
577 0 : BeginRedo();
578 :
579 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
580 :
581 0 : SCTAB nTab = aBlockStart.Tab();
582 0 : if (pViewShell)
583 : {
584 : // sheet has to be switched on or off before this (#46952#) !!!
585 :
586 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
587 0 : if ( nVisTab != nTab )
588 0 : pViewShell->SetTabNo( nTab );
589 : }
590 :
591 0 : ScRange aRange( aBlockStart.Col(), aBlockStart.Row(), nTab,
592 0 : aBlockEnd.Col(), aBlockEnd.Row(), nTab );
593 0 : ScOutlineDocFunc aFunc( *pDocShell );
594 0 : aFunc.AutoOutline( aRange, false );
595 :
596 : // Select in View
597 : // If it was called with a multi selection,
598 : // then this is now the enclosing range...
599 :
600 0 : if (pViewShell)
601 0 : pViewShell->MarkRange( aRange );
602 :
603 0 : EndRedo();
604 0 : }
605 :
606 0 : void ScUndoAutoOutline::Repeat(SfxRepeatTarget& rTarget)
607 : {
608 0 : if (rTarget.ISA(ScTabViewTarget))
609 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->AutoOutline( true );
610 0 : }
611 :
612 0 : bool ScUndoAutoOutline::CanRepeat(SfxRepeatTarget& rTarget) const
613 : {
614 0 : return rTarget.ISA(ScTabViewTarget);
615 : }
616 :
617 4 : ScUndoSubTotals::ScUndoSubTotals( ScDocShell* pNewDocShell, SCTAB nNewTab,
618 : const ScSubTotalParam& rNewParam, SCROW nNewEndY,
619 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
620 : ScRangeName* pNewUndoRange, ScDBCollection* pNewUndoDB ) :
621 : ScDBFuncUndo( pNewDocShell, ScRange( rNewParam.nCol1, rNewParam.nRow1, nNewTab,
622 : rNewParam.nCol2, rNewParam.nRow2, nNewTab ) ),
623 : nTab( nNewTab ),
624 : aParam( rNewParam ),
625 : nNewEndRow( nNewEndY ),
626 : pUndoDoc( pNewUndoDoc ),
627 : pUndoTable( pNewUndoTab ),
628 : pUndoRange( pNewUndoRange ),
629 4 : pUndoDB( pNewUndoDB )
630 : {
631 4 : }
632 :
633 12 : ScUndoSubTotals::~ScUndoSubTotals()
634 : {
635 4 : delete pUndoDoc;
636 4 : delete pUndoTable;
637 4 : delete pUndoRange;
638 4 : delete pUndoDB;
639 8 : }
640 :
641 6 : OUString ScUndoSubTotals::GetComment() const
642 : { // "Subtotals"
643 6 : return ScGlobal::GetRscString( STR_UNDO_SUBTOTALS );
644 : }
645 :
646 0 : void ScUndoSubTotals::Undo()
647 : {
648 0 : BeginUndo();
649 :
650 0 : ScDocument& rDoc = pDocShell->GetDocument();
651 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
652 :
653 0 : if (nNewEndRow > aParam.nRow2)
654 : {
655 0 : rDoc.DeleteRow( 0,nTab, MAXCOL,nTab, aParam.nRow2+1, static_cast<SCSIZE>(nNewEndRow-aParam.nRow2) );
656 : }
657 0 : else if (nNewEndRow < aParam.nRow2)
658 : {
659 0 : rDoc.InsertRow( 0,nTab, MAXCOL,nTab, nNewEndRow+1, static_cast<SCSIZE>(aParam.nRow2-nNewEndRow) );
660 : }
661 :
662 : // Original Outline table
663 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
664 :
665 : // Original column/row status
666 0 : if (pUndoTable)
667 : {
668 : SCCOLROW nStartCol;
669 : SCCOLROW nStartRow;
670 : SCCOLROW nEndCol;
671 : SCCOLROW nEndRow;
672 0 : pUndoTable->GetColArray().GetRange( nStartCol, nEndCol );
673 0 : pUndoTable->GetRowArray().GetRange( nStartRow, nEndRow );
674 :
675 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
676 : static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, false,
677 0 : &rDoc);
678 0 : pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, false, &rDoc );
679 :
680 0 : pViewShell->UpdateScrollBars();
681 : }
682 :
683 : // Original data and references
684 :
685 : ScUndoUtil::MarkSimpleBlock( pDocShell, 0, aParam.nRow1+1, nTab,
686 0 : MAXCOL, aParam.nRow2, nTab );
687 :
688 0 : rDoc.DeleteAreaTab( 0,aParam.nRow1+1, MAXCOL,aParam.nRow2, nTab, IDF_ALL );
689 :
690 : pUndoDoc->CopyToDocument( 0, aParam.nRow1+1, nTab, MAXCOL, aParam.nRow2, nTab,
691 0 : IDF_NONE, false, &rDoc ); // Flags
692 : pUndoDoc->UndoToDocument( 0, aParam.nRow1+1, nTab, MAXCOL, aParam.nRow2, nTab,
693 0 : IDF_ALL, false, &rDoc );
694 :
695 : ScUndoUtil::MarkSimpleBlock( pDocShell, aParam.nCol1,aParam.nRow1,nTab,
696 0 : aParam.nCol2,aParam.nRow2,nTab );
697 :
698 0 : if (pUndoRange)
699 0 : rDoc.SetRangeName( new ScRangeName( *pUndoRange ) );
700 0 : if (pUndoDB)
701 0 : rDoc.SetDBCollection( new ScDBCollection( *pUndoDB ), true );
702 :
703 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
704 0 : if ( nVisTab != nTab )
705 0 : pViewShell->SetTabNo( nTab );
706 :
707 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
708 0 : pDocShell->PostDataChanged();
709 :
710 0 : EndUndo();
711 0 : }
712 :
713 0 : void ScUndoSubTotals::Redo()
714 : {
715 0 : BeginRedo();
716 :
717 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
718 :
719 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
720 0 : if ( nVisTab != nTab )
721 0 : pViewShell->SetTabNo( nTab );
722 :
723 : ScUndoUtil::MarkSimpleBlock( pDocShell, aParam.nCol1,aParam.nRow1,nTab,
724 0 : aParam.nCol2,aParam.nRow2,nTab );
725 0 : pViewShell->DoSubTotals( aParam, false );
726 :
727 0 : EndRedo();
728 0 : }
729 :
730 0 : void ScUndoSubTotals::Repeat(SfxRepeatTarget& /* rTarget */)
731 : {
732 0 : }
733 :
734 2 : bool ScUndoSubTotals::CanRepeat(SfxRepeatTarget& /* rTarget */) const
735 : {
736 2 : return false; // is not possible due to column numbers
737 : }
738 :
739 8 : ScUndoQuery::ScUndoQuery( ScDocShell* pNewDocShell, SCTAB nNewTab, const ScQueryParam& rParam,
740 : ScDocument* pNewUndoDoc, ScDBCollection* pNewUndoDB,
741 : const ScRange* pOld, bool bSize, const ScRange* pAdvSrc ) :
742 : ScDBFuncUndo( pNewDocShell, ScRange( rParam.nCol1, rParam.nRow1, nNewTab,
743 : rParam.nCol2, rParam.nRow2, nNewTab ) ),
744 : pDrawUndo( NULL ),
745 : nTab( nNewTab ),
746 : aQueryParam( rParam ),
747 : pUndoDoc( pNewUndoDoc ),
748 : pUndoDB( pNewUndoDB ),
749 : bIsAdvanced( false ),
750 : bDestArea( false ),
751 8 : bDoSize( bSize )
752 : {
753 8 : if ( pOld )
754 : {
755 0 : bDestArea = true;
756 0 : aOldDest = *pOld;
757 : }
758 8 : if ( pAdvSrc )
759 : {
760 0 : bIsAdvanced = true;
761 0 : aAdvSource = *pAdvSrc;
762 : }
763 :
764 8 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
765 8 : }
766 :
767 24 : ScUndoQuery::~ScUndoQuery()
768 : {
769 8 : delete pUndoDoc;
770 8 : delete pUndoDB;
771 8 : DeleteSdrUndoAction( pDrawUndo );
772 16 : }
773 :
774 8 : OUString ScUndoQuery::GetComment() const
775 : { // "Filter";
776 8 : return ScGlobal::GetRscString( STR_UNDO_QUERY );
777 : }
778 :
779 0 : void ScUndoQuery::Undo()
780 : {
781 0 : BeginUndo();
782 :
783 0 : ScDocument& rDoc = pDocShell->GetDocument();
784 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
785 :
786 0 : bool bCopy = !aQueryParam.bInplace;
787 0 : SCCOL nDestEndCol = 0;
788 0 : SCROW nDestEndRow = 0;
789 0 : if (bCopy)
790 : {
791 0 : nDestEndCol = aQueryParam.nDestCol + ( aQueryParam.nCol2-aQueryParam.nCol1 );
792 0 : nDestEndRow = aQueryParam.nDestRow + ( aQueryParam.nRow2-aQueryParam.nRow1 );
793 :
794 : ScDBData* pData = rDoc.GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,
795 0 : aQueryParam.nDestTab, true );
796 0 : if (pData)
797 : {
798 0 : ScRange aNewDest;
799 0 : pData->GetArea( aNewDest );
800 0 : nDestEndCol = aNewDest.aEnd.Col();
801 0 : nDestEndRow = aNewDest.aEnd.Row();
802 : }
803 :
804 0 : if ( bDoSize && bDestArea )
805 : {
806 : // aDestRange is the old range
807 : rDoc.FitBlock( ScRange(
808 : aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
809 : nDestEndCol, nDestEndRow, aQueryParam.nDestTab ),
810 0 : aOldDest );
811 : }
812 :
813 : ScUndoUtil::MarkSimpleBlock( pDocShell,
814 : aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
815 0 : nDestEndCol, nDestEndRow, aQueryParam.nDestTab );
816 : rDoc.DeleteAreaTab( aQueryParam.nDestCol, aQueryParam.nDestRow,
817 0 : nDestEndCol, nDestEndRow, aQueryParam.nDestTab, IDF_ALL );
818 :
819 0 : pViewShell->DoneBlockMode();
820 :
821 : pUndoDoc->CopyToDocument( aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
822 : nDestEndCol, nDestEndRow, aQueryParam.nDestTab,
823 0 : IDF_ALL, false, &rDoc );
824 : // Attributes are always copied (#49287#)
825 :
826 : // rest of the old range
827 0 : if ( bDestArea && !bDoSize )
828 : {
829 0 : rDoc.DeleteAreaTab( aOldDest, IDF_ALL );
830 0 : pUndoDoc->CopyToDocument( aOldDest, IDF_ALL, false, &rDoc );
831 : }
832 : }
833 : else
834 : pUndoDoc->CopyToDocument( 0, aQueryParam.nRow1, nTab, MAXCOL, aQueryParam.nRow2, nTab,
835 0 : IDF_NONE, false, &rDoc );
836 :
837 0 : if (pUndoDB)
838 0 : rDoc.SetDBCollection( new ScDBCollection( *pUndoDB ), true );
839 :
840 0 : if (!bCopy)
841 : {
842 0 : rDoc.InvalidatePageBreaks(nTab);
843 0 : rDoc.UpdatePageBreaks( nTab );
844 : }
845 :
846 : ScRange aDirtyRange( 0 , aQueryParam.nRow1, nTab,
847 0 : MAXCOL, aQueryParam.nRow2, nTab );
848 0 : rDoc.SetDirty( aDirtyRange );
849 :
850 0 : DoSdrUndoAction( pDrawUndo, &rDoc );
851 :
852 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
853 0 : if ( nVisTab != nTab )
854 0 : pViewShell->SetTabNo( nTab );
855 :
856 : // Paint
857 :
858 0 : if (bCopy)
859 : {
860 0 : SCCOL nEndX = nDestEndCol;
861 0 : SCROW nEndY = nDestEndRow;
862 0 : if (bDestArea)
863 : {
864 0 : if ( aOldDest.aEnd.Col() > nEndX )
865 0 : nEndX = aOldDest.aEnd.Col();
866 0 : if ( aOldDest.aEnd.Row() > nEndY )
867 0 : nEndY = aOldDest.aEnd.Row();
868 : }
869 0 : if (bDoSize)
870 0 : nEndY = MAXROW;
871 : pDocShell->PostPaint( aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
872 0 : nEndX, nEndY, aQueryParam.nDestTab, PAINT_GRID );
873 : }
874 : else
875 : pDocShell->PostPaint( 0, aQueryParam.nRow1, nTab, MAXCOL, MAXROW, nTab,
876 0 : PAINT_GRID | PAINT_LEFT );
877 0 : pDocShell->PostDataChanged();
878 :
879 0 : EndUndo();
880 0 : }
881 :
882 0 : void ScUndoQuery::Redo()
883 : {
884 0 : BeginRedo();
885 :
886 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
887 :
888 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
889 0 : if ( nVisTab != nTab )
890 0 : pViewShell->SetTabNo( nTab );
891 :
892 0 : if ( bIsAdvanced )
893 0 : pViewShell->Query( aQueryParam, &aAdvSource, false );
894 : else
895 0 : pViewShell->Query( aQueryParam, NULL, false );
896 :
897 0 : EndRedo();
898 0 : }
899 :
900 0 : void ScUndoQuery::Repeat(SfxRepeatTarget& /* rTarget */)
901 : {
902 0 : }
903 :
904 0 : bool ScUndoQuery::CanRepeat(SfxRepeatTarget& /* rTarget */) const
905 : {
906 0 : return false; // does not work due to column numbers
907 : }
908 :
909 : // Show or hide AutoFilter buttons (doesn't include filter settings)
910 :
911 0 : ScUndoAutoFilter::ScUndoAutoFilter( ScDocShell* pNewDocShell, const ScRange& rRange,
912 : const OUString& rName, bool bSet ) :
913 : ScDBFuncUndo( pNewDocShell, rRange ),
914 : aDBName( rName ),
915 0 : bFilterSet( bSet )
916 : {
917 0 : }
918 :
919 0 : ScUndoAutoFilter::~ScUndoAutoFilter()
920 : {
921 0 : }
922 :
923 0 : OUString ScUndoAutoFilter::GetComment() const
924 : {
925 0 : return ScGlobal::GetRscString( STR_UNDO_QUERY ); // same as ScUndoQuery
926 : }
927 :
928 0 : void ScUndoAutoFilter::DoChange( bool bUndo )
929 : {
930 0 : bool bNewFilter = bUndo ? !bFilterSet : bFilterSet;
931 :
932 0 : ScDocument& rDoc = pDocShell->GetDocument();
933 0 : ScDBData* pDBData=NULL;
934 0 : if (aDBName.equalsAscii(STR_DB_LOCAL_NONAME))
935 : {
936 0 : SCTAB nTab = aOriginalRange.aStart.Tab();
937 0 : pDBData = rDoc.GetAnonymousDBData(nTab);
938 : }
939 : else
940 : {
941 0 : ScDBCollection* pColl = rDoc.GetDBCollection();
942 0 : pDBData = pColl->getNamedDBs().findByUpperName(ScGlobal::pCharClass->uppercase(aDBName));
943 : }
944 :
945 0 : if ( pDBData )
946 : {
947 0 : pDBData->SetAutoFilter( bNewFilter );
948 :
949 : SCCOL nRangeX1;
950 : SCROW nRangeY1;
951 : SCCOL nRangeX2;
952 : SCROW nRangeY2;
953 : SCTAB nRangeTab;
954 0 : pDBData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
955 :
956 0 : if ( bNewFilter )
957 0 : rDoc.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
958 : else
959 0 : rDoc.RemoveFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
960 :
961 0 : pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
962 : }
963 0 : }
964 :
965 0 : void ScUndoAutoFilter::Undo()
966 : {
967 0 : BeginUndo();
968 0 : DoChange( true );
969 0 : EndUndo();
970 0 : }
971 :
972 0 : void ScUndoAutoFilter::Redo()
973 : {
974 0 : BeginRedo();
975 0 : DoChange( false );
976 0 : EndRedo();
977 0 : }
978 :
979 0 : void ScUndoAutoFilter::Repeat(SfxRepeatTarget& /* rTarget */)
980 : {
981 0 : }
982 :
983 0 : bool ScUndoAutoFilter::CanRepeat(SfxRepeatTarget& /* rTarget */) const
984 : {
985 0 : return false;
986 : }
987 :
988 : // change database sections (dialog)
989 96 : ScUndoDBData::ScUndoDBData( ScDocShell* pNewDocShell,
990 : ScDBCollection* pNewUndoColl, ScDBCollection* pNewRedoColl ) :
991 : ScSimpleUndo( pNewDocShell ),
992 : pUndoColl( pNewUndoColl ),
993 96 : pRedoColl( pNewRedoColl )
994 : {
995 96 : }
996 :
997 288 : ScUndoDBData::~ScUndoDBData()
998 : {
999 96 : delete pUndoColl;
1000 96 : delete pRedoColl;
1001 192 : }
1002 :
1003 108 : OUString ScUndoDBData::GetComment() const
1004 : { // "Change database range";
1005 108 : return ScGlobal::GetRscString( STR_UNDO_DBDATA );
1006 : }
1007 :
1008 2 : void ScUndoDBData::Undo()
1009 : {
1010 2 : BeginUndo();
1011 :
1012 2 : ScDocument& rDoc = pDocShell->GetDocument();
1013 :
1014 2 : bool bOldAutoCalc = rDoc.GetAutoCalc();
1015 2 : rDoc.SetAutoCalc( false ); // Avoid unnecessary calculations
1016 2 : rDoc.PreprocessDBDataUpdate();
1017 2 : rDoc.SetDBCollection( new ScDBCollection(*pUndoColl), true );
1018 2 : rDoc.CompileHybridFormula();
1019 2 : rDoc.SetAutoCalc( bOldAutoCalc );
1020 :
1021 2 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
1022 :
1023 2 : EndUndo();
1024 2 : }
1025 :
1026 2 : void ScUndoDBData::Redo()
1027 : {
1028 2 : BeginRedo();
1029 :
1030 2 : ScDocument& rDoc = pDocShell->GetDocument();
1031 :
1032 2 : bool bOldAutoCalc = rDoc.GetAutoCalc();
1033 2 : rDoc.SetAutoCalc( false ); // Avoid unnecessary calculations
1034 2 : rDoc.PreprocessDBDataUpdate();
1035 2 : rDoc.SetDBCollection( new ScDBCollection(*pRedoColl), true );
1036 2 : rDoc.CompileHybridFormula();
1037 2 : rDoc.SetAutoCalc( bOldAutoCalc );
1038 :
1039 2 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
1040 :
1041 2 : EndRedo();
1042 2 : }
1043 :
1044 0 : void ScUndoDBData::Repeat(SfxRepeatTarget& /* rTarget */)
1045 : {
1046 0 : }
1047 :
1048 8 : bool ScUndoDBData::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1049 : {
1050 8 : return false; // is not possible
1051 : }
1052 :
1053 8 : ScUndoImportData::ScUndoImportData( ScDocShell* pNewDocShell, SCTAB nNewTab,
1054 : const ScImportParam& rParam, SCCOL nNewEndX, SCROW nNewEndY,
1055 : SCCOL nNewFormula,
1056 : ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc,
1057 : ScDBData* pNewUndoData, ScDBData* pNewRedoData ) :
1058 : ScSimpleUndo( pNewDocShell ),
1059 : nTab( nNewTab ),
1060 : aImportParam( rParam ),
1061 : nEndCol( nNewEndX ),
1062 : nEndRow( nNewEndY ),
1063 : pUndoDoc( pNewUndoDoc ),
1064 : pRedoDoc( pNewRedoDoc ),
1065 : pUndoDBData( pNewUndoData ),
1066 : pRedoDBData( pNewRedoData ),
1067 : nFormulaCols( nNewFormula ),
1068 8 : bRedoFilled( false )
1069 : {
1070 : // redo doc doesn't contain imported data (but everything else)
1071 8 : }
1072 :
1073 24 : ScUndoImportData::~ScUndoImportData()
1074 : {
1075 8 : delete pUndoDoc;
1076 8 : delete pRedoDoc;
1077 8 : delete pUndoDBData;
1078 8 : delete pRedoDBData;
1079 16 : }
1080 :
1081 16 : OUString ScUndoImportData::GetComment() const
1082 : {
1083 16 : return ScGlobal::GetRscString( STR_UNDO_IMPORTDATA );
1084 : }
1085 :
1086 0 : void ScUndoImportData::Undo()
1087 : {
1088 0 : BeginUndo();
1089 :
1090 0 : ScDocument& rDoc = pDocShell->GetDocument();
1091 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1092 :
1093 : ScUndoUtil::MarkSimpleBlock( pDocShell, aImportParam.nCol1,aImportParam.nRow1,nTab,
1094 0 : nEndCol,nEndRow,nTab );
1095 :
1096 : SCTAB nTable;
1097 : SCCOL nCol1, nCol2;
1098 : SCROW nRow1, nRow2;
1099 0 : ScDBData* pCurrentData = NULL;
1100 0 : if (pUndoDBData && pRedoDBData)
1101 : {
1102 0 : pRedoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1103 : pCurrentData = ScUndoUtil::GetOldDBData( pRedoDBData, &rDoc, nTab,
1104 0 : nCol1, nRow1, nCol2, nRow2 );
1105 :
1106 0 : if ( !bRedoFilled )
1107 : {
1108 : // read redo data from document at first undo
1109 : // imported data is deleted later anyway,
1110 : // so now delete each column after copying to save memory (#41216#)
1111 :
1112 0 : bool bOldAutoCalc = rDoc.GetAutoCalc();
1113 0 : rDoc.SetAutoCalc( false ); // outside of the loop
1114 0 : for (SCCOL nCopyCol = nCol1; nCopyCol <= nCol2; nCopyCol++)
1115 : {
1116 : rDoc.CopyToDocument( nCopyCol,nRow1,nTab, nCopyCol,nRow2,nTab,
1117 0 : IDF_CONTENTS & ~IDF_NOTE, false, pRedoDoc );
1118 0 : rDoc.DeleteAreaTab( nCopyCol,nRow1, nCopyCol,nRow2, nTab, IDF_CONTENTS & ~IDF_NOTE );
1119 : }
1120 0 : rDoc.SetAutoCalc( bOldAutoCalc );
1121 0 : bRedoFilled = true;
1122 : }
1123 : }
1124 0 : bool bMoveCells = pUndoDBData && pRedoDBData &&
1125 0 : pRedoDBData->IsDoSize(); // the same in old and new
1126 0 : if (bMoveCells)
1127 : {
1128 : // Undo: first delete the new data, then FitBlock backwards
1129 :
1130 0 : ScRange aOld, aNew;
1131 0 : pUndoDBData->GetArea( aOld );
1132 0 : pRedoDBData->GetArea( aNew );
1133 :
1134 0 : rDoc.DeleteAreaTab( aNew.aStart.Col(), aNew.aStart.Row(),
1135 0 : aNew.aEnd.Col(), aNew.aEnd.Row(), nTab, IDF_ALL & ~IDF_NOTE );
1136 :
1137 0 : aOld.aEnd.SetCol( aOld.aEnd.Col() + nFormulaCols ); // FitBlock also for formulas
1138 0 : aNew.aEnd.SetCol( aNew.aEnd.Col() + nFormulaCols );
1139 0 : rDoc.FitBlock( aNew, aOld, false ); // backwards
1140 : }
1141 : else
1142 : rDoc.DeleteAreaTab( aImportParam.nCol1,aImportParam.nRow1,
1143 0 : nEndCol,nEndRow, nTab, IDF_ALL & ~IDF_NOTE );
1144 :
1145 : pUndoDoc->CopyToDocument( aImportParam.nCol1,aImportParam.nRow1,nTab,
1146 : nEndCol+nFormulaCols,nEndRow,nTab,
1147 0 : IDF_ALL & ~IDF_NOTE, false, &rDoc );
1148 :
1149 0 : if (pCurrentData)
1150 : {
1151 0 : *pCurrentData = *pUndoDBData;
1152 :
1153 0 : pUndoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1154 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, nCol1, nRow1, nTable, nCol2, nRow2, nTable );
1155 : }
1156 :
1157 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
1158 0 : if ( nVisTab != nTab )
1159 0 : pViewShell->SetTabNo( nTab );
1160 :
1161 0 : if (bMoveCells)
1162 0 : pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
1163 : else
1164 : pDocShell->PostPaint( aImportParam.nCol1,aImportParam.nRow1,nTab,
1165 0 : nEndCol,nEndRow,nTab, PAINT_GRID );
1166 0 : pDocShell->PostDataChanged();
1167 :
1168 0 : EndUndo();
1169 0 : }
1170 :
1171 0 : void ScUndoImportData::Redo()
1172 : {
1173 0 : BeginRedo();
1174 :
1175 0 : ScDocument& rDoc = pDocShell->GetDocument();
1176 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1177 :
1178 : ScUndoUtil::MarkSimpleBlock( pDocShell, aImportParam.nCol1,aImportParam.nRow1,nTab,
1179 0 : nEndCol,nEndRow,nTab );
1180 :
1181 : SCTAB nTable;
1182 : SCCOL nCol1, nCol2;
1183 : SCROW nRow1, nRow2;
1184 0 : ScDBData* pCurrentData = NULL;
1185 0 : if (pUndoDBData && pRedoDBData)
1186 : {
1187 0 : pUndoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1188 : pCurrentData = ScUndoUtil::GetOldDBData( pUndoDBData, &rDoc, nTab,
1189 0 : nCol1, nRow1, nCol2, nRow2 );
1190 : }
1191 0 : bool bMoveCells = pUndoDBData && pRedoDBData &&
1192 0 : pRedoDBData->IsDoSize(); // // the same in old and new
1193 0 : if (bMoveCells)
1194 : {
1195 : // Redo: FitBlock, then delete data (needed for CopyToDocument)
1196 :
1197 0 : ScRange aOld, aNew;
1198 0 : pUndoDBData->GetArea( aOld );
1199 0 : pRedoDBData->GetArea( aNew );
1200 :
1201 0 : aOld.aEnd.SetCol( aOld.aEnd.Col() + nFormulaCols ); // FitBlock also for formulas
1202 0 : aNew.aEnd.SetCol( aNew.aEnd.Col() + nFormulaCols );
1203 0 : rDoc.FitBlock( aOld, aNew );
1204 :
1205 0 : rDoc.DeleteAreaTab( aNew.aStart.Col(), aNew.aStart.Row(),
1206 0 : aNew.aEnd.Col(), aNew.aEnd.Row(), nTab, IDF_ALL & ~IDF_NOTE );
1207 :
1208 0 : pRedoDoc->CopyToDocument( aNew, IDF_ALL & ~IDF_NOTE, false, &rDoc ); // including formulas
1209 : }
1210 : else
1211 : {
1212 : rDoc.DeleteAreaTab( aImportParam.nCol1,aImportParam.nRow1,
1213 0 : nEndCol,nEndRow, nTab, IDF_ALL & ~IDF_NOTE );
1214 : pRedoDoc->CopyToDocument( aImportParam.nCol1,aImportParam.nRow1,nTab,
1215 0 : nEndCol,nEndRow,nTab, IDF_ALL & ~IDF_NOTE, false, &rDoc );
1216 : }
1217 :
1218 0 : if (pCurrentData)
1219 : {
1220 0 : *pCurrentData = *pRedoDBData;
1221 :
1222 0 : pRedoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1223 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, nCol1, nRow1, nTable, nCol2, nRow2, nTable );
1224 : }
1225 :
1226 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
1227 0 : if ( nVisTab != nTab )
1228 0 : pViewShell->SetTabNo( nTab );
1229 :
1230 0 : if (bMoveCells)
1231 0 : pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
1232 : else
1233 : pDocShell->PostPaint( aImportParam.nCol1,aImportParam.nRow1,nTab,
1234 0 : nEndCol,nEndRow,nTab, PAINT_GRID );
1235 0 : pDocShell->PostDataChanged();
1236 :
1237 0 : EndRedo();
1238 0 : }
1239 :
1240 0 : void ScUndoImportData::Repeat(SfxRepeatTarget& rTarget)
1241 : {
1242 0 : if (rTarget.ISA(ScTabViewTarget))
1243 : {
1244 0 : ScTabViewShell& rViewShell = *static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
1245 :
1246 : SCTAB nDummy;
1247 0 : ScImportParam aNewParam(aImportParam);
1248 0 : ScDBData* pDBData = rViewShell.GetDBData();
1249 0 : pDBData->GetArea( nDummy, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
1250 :
1251 0 : rViewShell.ImportData( aNewParam );
1252 : }
1253 0 : }
1254 :
1255 4 : bool ScUndoImportData::CanRepeat(SfxRepeatTarget& rTarget) const
1256 : {
1257 : // Repeat only for import using a database range, then pUndoDBData is set
1258 :
1259 4 : if (pUndoDBData)
1260 4 : return rTarget.ISA(ScTabViewTarget);
1261 : else
1262 0 : return false; // Address book
1263 : }
1264 :
1265 20 : ScUndoRepeatDB::ScUndoRepeatDB( ScDocShell* pNewDocShell, SCTAB nNewTab,
1266 : SCCOL nStartX, SCROW nStartY, SCCOL nEndX, SCROW nEndY,
1267 : SCROW nResultEndRow, SCCOL nCurX, SCROW nCurY,
1268 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
1269 : ScRangeName* pNewUndoRange, ScDBCollection* pNewUndoDB,
1270 : const ScRange* pOldQ, const ScRange* pNewQ ) :
1271 : ScSimpleUndo( pNewDocShell ),
1272 : aBlockStart( nStartX,nStartY,nNewTab ),
1273 : aBlockEnd( nEndX,nEndY,nNewTab ),
1274 : nNewEndRow( nResultEndRow ),
1275 : aCursorPos( nCurX,nCurY,nNewTab ),
1276 : pUndoDoc( pNewUndoDoc ),
1277 : pUndoTable( pNewUndoTab ),
1278 : pUndoRange( pNewUndoRange ),
1279 : pUndoDB( pNewUndoDB ),
1280 20 : bQuerySize( false )
1281 : {
1282 20 : if ( pOldQ && pNewQ )
1283 : {
1284 0 : aOldQuery = *pOldQ;
1285 0 : aNewQuery = *pNewQ;
1286 0 : bQuerySize = true;
1287 : }
1288 20 : }
1289 :
1290 60 : ScUndoRepeatDB::~ScUndoRepeatDB()
1291 : {
1292 20 : delete pUndoDoc;
1293 20 : delete pUndoTable;
1294 20 : delete pUndoRange;
1295 20 : delete pUndoDB;
1296 40 : }
1297 :
1298 20 : OUString ScUndoRepeatDB::GetComment() const
1299 : {
1300 20 : return ScGlobal::GetRscString( STR_UNDO_REPEATDB );
1301 : }
1302 :
1303 0 : void ScUndoRepeatDB::Undo()
1304 : {
1305 0 : BeginUndo();
1306 :
1307 0 : ScDocument& rDoc = pDocShell->GetDocument();
1308 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1309 0 : SCTAB nTab = aBlockStart.Tab();
1310 :
1311 0 : if (bQuerySize)
1312 : {
1313 0 : rDoc.FitBlock( aNewQuery, aOldQuery, false );
1314 :
1315 0 : if ( aNewQuery.aEnd.Col() == aOldQuery.aEnd.Col() )
1316 : {
1317 0 : SCCOL nFormulaCols = 0;
1318 0 : SCCOL nCol = aOldQuery.aEnd.Col() + 1;
1319 0 : SCROW nRow = aOldQuery.aStart.Row() + 1; // test the header
1320 0 : while ( nCol <= MAXCOL &&
1321 0 : rDoc.GetCellType(ScAddress( nCol, nRow, nTab )) == CELLTYPE_FORMULA )
1322 0 : ++nCol, ++nFormulaCols;
1323 :
1324 0 : if ( nFormulaCols > 0 )
1325 : {
1326 0 : ScRange aOldForm = aOldQuery;
1327 0 : aOldForm.aStart.SetCol( aOldQuery.aEnd.Col() + 1 );
1328 0 : aOldForm.aEnd.SetCol( aOldQuery.aEnd.Col() + nFormulaCols );
1329 0 : ScRange aNewForm = aOldForm;
1330 0 : aNewForm.aEnd.SetRow( aNewQuery.aEnd.Row() );
1331 0 : rDoc.FitBlock( aNewForm, aOldForm, false );
1332 : }
1333 : }
1334 : }
1335 :
1336 : // TODO Data from Filter in other range are still missing!
1337 :
1338 0 : if (nNewEndRow > aBlockEnd.Row())
1339 : {
1340 0 : rDoc.DeleteRow( 0,nTab, MAXCOL,nTab, aBlockEnd.Row()+1, static_cast<SCSIZE>(nNewEndRow-aBlockEnd.Row()) );
1341 : }
1342 0 : else if (nNewEndRow < aBlockEnd.Row())
1343 : {
1344 0 : rDoc.InsertRow( 0,nTab, MAXCOL,nTab, nNewEndRow+1, static_cast<SCSIZE>(nNewEndRow-aBlockEnd.Row()) );
1345 : }
1346 :
1347 : // Original Outline table
1348 0 : rDoc.SetOutlineTable( nTab, pUndoTable );
1349 :
1350 : // Original column/row status
1351 0 : if (pUndoTable)
1352 : {
1353 : SCCOLROW nStartCol;
1354 : SCCOLROW nStartRow;
1355 : SCCOLROW nEndCol;
1356 : SCCOLROW nEndRow;
1357 0 : pUndoTable->GetColArray().GetRange( nStartCol, nEndCol );
1358 0 : pUndoTable->GetRowArray().GetRange( nStartRow, nEndRow );
1359 :
1360 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
1361 : static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, false,
1362 0 : &rDoc );
1363 0 : pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, false, &rDoc );
1364 :
1365 0 : pViewShell->UpdateScrollBars();
1366 : }
1367 :
1368 : // Original data and references
1369 : ScUndoUtil::MarkSimpleBlock( pDocShell, 0, aBlockStart.Row(), nTab,
1370 0 : MAXCOL, aBlockEnd.Row(), nTab );
1371 : rDoc.DeleteAreaTab( 0, aBlockStart.Row(),
1372 0 : MAXCOL, aBlockEnd.Row(), nTab, IDF_ALL );
1373 :
1374 : pUndoDoc->CopyToDocument( 0, aBlockStart.Row(), nTab, MAXCOL, aBlockEnd.Row(), nTab,
1375 0 : IDF_NONE, false, &rDoc ); // Flags
1376 : pUndoDoc->UndoToDocument( 0, aBlockStart.Row(), nTab, MAXCOL, aBlockEnd.Row(), nTab,
1377 0 : IDF_ALL, false, &rDoc );
1378 :
1379 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart.Col(),aBlockStart.Row(),nTab,
1380 0 : aBlockEnd.Col(),aBlockEnd.Row(),nTab );
1381 :
1382 0 : if (pUndoRange)
1383 0 : rDoc.SetRangeName( new ScRangeName( *pUndoRange ) );
1384 0 : if (pUndoDB)
1385 0 : rDoc.SetDBCollection( new ScDBCollection( *pUndoDB ), true );
1386 :
1387 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
1388 0 : if ( nVisTab != nTab )
1389 0 : pViewShell->SetTabNo( nTab );
1390 :
1391 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
1392 0 : pDocShell->PostDataChanged();
1393 :
1394 0 : EndUndo();
1395 0 : }
1396 :
1397 0 : void ScUndoRepeatDB::Redo()
1398 : {
1399 0 : BeginRedo();
1400 :
1401 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1402 0 : SCTAB nTab = aBlockStart.Tab();
1403 :
1404 0 : SCTAB nVisTab = pViewShell->GetViewData().GetTabNo();
1405 0 : if ( nVisTab != nTab )
1406 0 : pViewShell->SetTabNo( nTab );
1407 :
1408 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart.Col(),aBlockStart.Row(),nTab,
1409 0 : aBlockEnd.Col(),aBlockEnd.Row(),nTab );
1410 0 : pViewShell->SetCursor( aCursorPos.Col(), aCursorPos.Row() );
1411 :
1412 0 : pViewShell->RepeatDB( false );
1413 :
1414 0 : EndRedo();
1415 0 : }
1416 :
1417 0 : void ScUndoRepeatDB::Repeat(SfxRepeatTarget& rTarget)
1418 : {
1419 0 : if (rTarget.ISA(ScTabViewTarget))
1420 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->RepeatDB( true );
1421 0 : }
1422 :
1423 0 : bool ScUndoRepeatDB::CanRepeat(SfxRepeatTarget& rTarget) const
1424 : {
1425 0 : return rTarget.ISA(ScTabViewTarget);
1426 : }
1427 :
1428 78 : ScUndoDataPilot::ScUndoDataPilot( ScDocShell* pNewDocShell,
1429 : ScDocument* pOldDoc, ScDocument* pNewDoc,
1430 : const ScDPObject* pOldObj, const ScDPObject* pNewObj, bool bMove ) :
1431 : ScSimpleUndo( pNewDocShell ),
1432 : pOldUndoDoc( pOldDoc ),
1433 : pNewUndoDoc( pNewDoc ),
1434 : pOldDPObject( NULL ),
1435 : pNewDPObject( NULL ),
1436 78 : bAllowMove( bMove )
1437 : {
1438 78 : if (pOldObj)
1439 44 : pOldDPObject = new ScDPObject( *pOldObj );
1440 78 : if (pNewObj)
1441 76 : pNewDPObject = new ScDPObject( *pNewObj );
1442 78 : }
1443 :
1444 234 : ScUndoDataPilot::~ScUndoDataPilot()
1445 : {
1446 78 : delete pOldDPObject;
1447 78 : delete pNewDPObject;
1448 78 : delete pOldUndoDoc;
1449 78 : delete pNewUndoDoc;
1450 156 : }
1451 :
1452 80 : OUString ScUndoDataPilot::GetComment() const
1453 : {
1454 : sal_uInt16 nIndex;
1455 80 : if ( pOldUndoDoc && pNewUndoDoc )
1456 42 : nIndex = STR_UNDO_PIVOT_MODIFY;
1457 38 : else if ( pNewUndoDoc )
1458 36 : nIndex = STR_UNDO_PIVOT_NEW;
1459 : else
1460 2 : nIndex = STR_UNDO_PIVOT_DELETE;
1461 :
1462 80 : return ScGlobal::GetRscString( nIndex );
1463 : }
1464 :
1465 0 : void ScUndoDataPilot::Undo()
1466 : {
1467 0 : BeginUndo();
1468 :
1469 0 : ScDocument& rDoc = pDocShell->GetDocument();
1470 :
1471 0 : ScRange aOldRange;
1472 0 : ScRange aNewRange;
1473 :
1474 0 : if ( pNewDPObject && pNewUndoDoc )
1475 : {
1476 0 : aNewRange = pNewDPObject->GetOutRange();
1477 0 : rDoc.DeleteAreaTab( aNewRange, IDF_ALL );
1478 0 : pNewUndoDoc->CopyToDocument( aNewRange, IDF_ALL, false, &rDoc );
1479 : }
1480 0 : if ( pOldDPObject && pOldUndoDoc )
1481 : {
1482 0 : aOldRange = pOldDPObject->GetOutRange();
1483 0 : rDoc.DeleteAreaTab( aOldRange, IDF_ALL );
1484 0 : pOldUndoDoc->CopyToDocument( aOldRange, IDF_ALL, false, &rDoc );
1485 : }
1486 :
1487 : // update objects in collection
1488 :
1489 0 : if ( pNewDPObject )
1490 : {
1491 : // find updated object
1492 : //! find by name!
1493 :
1494 : ScDPObject* pDocObj = rDoc.GetDPAtCursor(
1495 0 : aNewRange.aStart.Col(), aNewRange.aStart.Row(), aNewRange.aStart.Tab() );
1496 : OSL_ENSURE(pDocObj, "DPObject not found");
1497 0 : if (pDocObj)
1498 : {
1499 0 : if ( pOldDPObject )
1500 : {
1501 : // restore old settings
1502 0 : pOldDPObject->WriteSourceDataTo( *pDocObj );
1503 0 : ScDPSaveData* pData = pOldDPObject->GetSaveData();
1504 0 : if (pData)
1505 0 : pDocObj->SetSaveData(*pData);
1506 0 : pDocObj->SetOutRange( pOldDPObject->GetOutRange() );
1507 0 : pOldDPObject->WriteTempDataTo( *pDocObj );
1508 : }
1509 : else
1510 : {
1511 : // delete inserted object
1512 0 : rDoc.GetDPCollection()->FreeTable(pDocObj);
1513 : }
1514 : }
1515 : }
1516 0 : else if ( pOldDPObject )
1517 : {
1518 : // re-insert deleted object
1519 :
1520 0 : ScDPObject* pDestObj = new ScDPObject( *pOldDPObject );
1521 0 : if ( !rDoc.GetDPCollection()->InsertNewTable(pDestObj) )
1522 : {
1523 : OSL_FAIL("cannot insert DPObject");
1524 0 : DELETEZ( pDestObj );
1525 : }
1526 : }
1527 :
1528 0 : if (pNewUndoDoc)
1529 0 : pDocShell->PostPaint( aNewRange, PAINT_GRID, SC_PF_LINES );
1530 0 : if (pOldUndoDoc)
1531 0 : pDocShell->PostPaint( aOldRange, PAINT_GRID, SC_PF_LINES );
1532 0 : pDocShell->PostDataChanged();
1533 :
1534 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1535 : if (pViewShell)
1536 : {
1537 : //! set current sheet
1538 : }
1539 :
1540 0 : if (pNewDPObject)
1541 : {
1542 : // notify API objects
1543 0 : rDoc.BroadcastUno( ScDataPilotModifiedHint( pNewDPObject->GetName() ) );
1544 : }
1545 :
1546 0 : EndUndo();
1547 0 : }
1548 :
1549 0 : void ScUndoDataPilot::Redo()
1550 : {
1551 0 : BeginRedo();
1552 :
1553 : //! copy output data instead of repeating the change,
1554 : //! in case external data have changed!
1555 :
1556 0 : ScDocument& rDoc = pDocShell->GetDocument();
1557 :
1558 0 : ScDPObject* pSourceObj = NULL;
1559 0 : if ( pOldDPObject )
1560 : {
1561 : // find object to modify
1562 : //! find by name!
1563 :
1564 0 : ScRange aOldRange = pOldDPObject->GetOutRange();
1565 : pSourceObj = rDoc.GetDPAtCursor(
1566 0 : aOldRange.aStart.Col(), aOldRange.aStart.Row(), aOldRange.aStart.Tab() );
1567 : OSL_ENSURE(pSourceObj, "DPObject not found");
1568 : }
1569 :
1570 0 : ScDBDocFunc aFunc( *pDocShell );
1571 0 : aFunc.DataPilotUpdate( pSourceObj, pNewDPObject, false, false, bAllowMove ); // no new undo action
1572 :
1573 0 : EndRedo();
1574 0 : }
1575 :
1576 0 : void ScUndoDataPilot::Repeat(SfxRepeatTarget& /* rTarget */)
1577 : {
1578 : //! allow deletion
1579 0 : }
1580 :
1581 2 : bool ScUndoDataPilot::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1582 : {
1583 : //! allow deletion
1584 2 : return false;
1585 : }
1586 :
1587 0 : ScUndoConsolidate::ScUndoConsolidate( ScDocShell* pNewDocShell, const ScArea& rArea,
1588 : const ScConsolidateParam& rPar, ScDocument* pNewUndoDoc,
1589 : bool bReference, SCROW nInsCount, ScOutlineTable* pTab,
1590 : ScDBData* pData ) :
1591 : ScSimpleUndo( pNewDocShell ),
1592 : aDestArea( rArea ),
1593 : pUndoDoc( pNewUndoDoc ),
1594 : aParam( rPar ),
1595 : bInsRef( bReference ),
1596 : nInsertCount( nInsCount ),
1597 : pUndoTab( pTab ),
1598 0 : pUndoData( pData )
1599 : {
1600 0 : }
1601 :
1602 0 : ScUndoConsolidate::~ScUndoConsolidate()
1603 : {
1604 0 : delete pUndoDoc;
1605 0 : delete pUndoTab;
1606 0 : delete pUndoData;
1607 0 : }
1608 :
1609 0 : OUString ScUndoConsolidate::GetComment() const
1610 : {
1611 0 : return ScGlobal::GetRscString( STR_UNDO_CONSOLIDATE );
1612 : }
1613 :
1614 0 : void ScUndoConsolidate::Undo()
1615 : {
1616 0 : BeginUndo();
1617 :
1618 0 : ScDocument& rDoc = pDocShell->GetDocument();
1619 0 : SCTAB nTab = aDestArea.nTab;
1620 :
1621 0 : ScRange aOldRange;
1622 0 : if (pUndoData)
1623 0 : pUndoData->GetArea(aOldRange);
1624 :
1625 0 : if (bInsRef)
1626 : {
1627 0 : rDoc.DeleteRow( 0,nTab, MAXCOL,nTab, aDestArea.nRowStart, nInsertCount );
1628 0 : rDoc.SetOutlineTable( nTab, pUndoTab );
1629 :
1630 : // Row status
1631 0 : pUndoDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, false, &rDoc );
1632 :
1633 : // Data and references
1634 0 : rDoc.DeleteAreaTab( 0,aDestArea.nRowStart, MAXCOL,aDestArea.nRowEnd, nTab, IDF_ALL );
1635 : pUndoDoc->UndoToDocument( 0, aDestArea.nRowStart, nTab,
1636 : MAXCOL, aDestArea.nRowEnd, nTab,
1637 0 : IDF_ALL, false, &rDoc );
1638 :
1639 : // Original range
1640 0 : if (pUndoData)
1641 : {
1642 0 : rDoc.DeleteAreaTab(aOldRange, IDF_ALL);
1643 0 : pUndoDoc->CopyToDocument(aOldRange, IDF_ALL, false, &rDoc);
1644 : }
1645 :
1646 : pDocShell->PostPaint( 0,aDestArea.nRowStart,nTab, MAXCOL,MAXROW,nTab,
1647 0 : PAINT_GRID | PAINT_LEFT | PAINT_SIZE );
1648 : }
1649 : else
1650 : {
1651 : rDoc.DeleteAreaTab( aDestArea.nColStart,aDestArea.nRowStart,
1652 0 : aDestArea.nColEnd,aDestArea.nRowEnd, nTab, IDF_ALL );
1653 : pUndoDoc->CopyToDocument( aDestArea.nColStart, aDestArea.nRowStart, nTab,
1654 : aDestArea.nColEnd, aDestArea.nRowEnd, nTab,
1655 0 : IDF_ALL, false, &rDoc );
1656 :
1657 : // Original range
1658 0 : if (pUndoData)
1659 : {
1660 0 : rDoc.DeleteAreaTab(aOldRange, IDF_ALL);
1661 0 : pUndoDoc->CopyToDocument(aOldRange, IDF_ALL, false, &rDoc);
1662 : }
1663 :
1664 0 : SCCOL nEndX = aDestArea.nColEnd;
1665 0 : SCROW nEndY = aDestArea.nRowEnd;
1666 0 : if ( pUndoData )
1667 : {
1668 0 : if ( aOldRange.aEnd.Col() > nEndX )
1669 0 : nEndX = aOldRange.aEnd.Col();
1670 0 : if ( aOldRange.aEnd.Row() > nEndY )
1671 0 : nEndY = aOldRange.aEnd.Row();
1672 : }
1673 : pDocShell->PostPaint( aDestArea.nColStart, aDestArea.nRowStart, nTab,
1674 0 : nEndX, nEndY, nTab, PAINT_GRID );
1675 : }
1676 :
1677 : // Adjust Database range again
1678 0 : if (pUndoData)
1679 : {
1680 0 : ScDBCollection* pColl = rDoc.GetDBCollection();
1681 0 : if (pColl)
1682 : {
1683 0 : ScDBData* pDocData = pColl->getNamedDBs().findByUpperName(pUndoData->GetUpperName());
1684 0 : if (pDocData)
1685 0 : *pDocData = *pUndoData;
1686 : }
1687 : }
1688 :
1689 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1690 0 : if (pViewShell)
1691 : {
1692 0 : SCTAB nViewTab = pViewShell->GetViewData().GetTabNo();
1693 0 : if ( nViewTab != nTab )
1694 0 : pViewShell->SetTabNo( nTab );
1695 : }
1696 :
1697 0 : EndUndo();
1698 0 : }
1699 :
1700 0 : void ScUndoConsolidate::Redo()
1701 : {
1702 0 : BeginRedo();
1703 :
1704 0 : pDocShell->DoConsolidate( aParam, false );
1705 :
1706 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1707 0 : if (pViewShell)
1708 : {
1709 0 : SCTAB nViewTab = pViewShell->GetViewData().GetTabNo();
1710 0 : if ( nViewTab != aParam.nTab )
1711 0 : pViewShell->SetTabNo( aParam.nTab );
1712 : }
1713 :
1714 0 : EndRedo();
1715 0 : }
1716 :
1717 0 : void ScUndoConsolidate::Repeat(SfxRepeatTarget& /* rTarget */)
1718 : {
1719 0 : }
1720 :
1721 0 : bool ScUndoConsolidate::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1722 : {
1723 0 : return false;
1724 : }
1725 :
1726 : // Change source data of Chart
1727 12 : void ScUndoChartData::Init()
1728 : {
1729 12 : ScDocument& rDoc = pDocShell->GetDocument();
1730 12 : aOldRangeListRef = new ScRangeList;
1731 12 : rDoc.GetOldChartParameters( aChartName, *aOldRangeListRef, bOldColHeaders, bOldRowHeaders );
1732 12 : }
1733 :
1734 0 : ScUndoChartData::ScUndoChartData( ScDocShell* pNewDocShell, const OUString& rName,
1735 : const ScRange& rNew, bool bColHdr, bool bRowHdr,
1736 : bool bAdd ) :
1737 : ScSimpleUndo( pNewDocShell ),
1738 : aChartName( rName ),
1739 : bNewColHeaders( bColHdr ),
1740 : bNewRowHeaders( bRowHdr ),
1741 0 : bAddRange( bAdd )
1742 : {
1743 0 : aNewRangeListRef = new ScRangeList;
1744 0 : aNewRangeListRef->Append( rNew );
1745 :
1746 0 : Init();
1747 0 : }
1748 :
1749 12 : ScUndoChartData::ScUndoChartData( ScDocShell* pNewDocShell, const OUString& rName,
1750 : const ScRangeListRef& rNew, bool bColHdr, bool bRowHdr,
1751 : bool bAdd ) :
1752 : ScSimpleUndo( pNewDocShell ),
1753 : aChartName( rName ),
1754 : aNewRangeListRef( rNew ),
1755 : bNewColHeaders( bColHdr ),
1756 : bNewRowHeaders( bRowHdr ),
1757 12 : bAddRange( bAdd )
1758 : {
1759 12 : Init();
1760 12 : }
1761 :
1762 24 : ScUndoChartData::~ScUndoChartData()
1763 : {
1764 24 : }
1765 :
1766 16 : OUString ScUndoChartData::GetComment() const
1767 : {
1768 16 : return ScGlobal::GetRscString( STR_UNDO_CHARTDATA );
1769 : }
1770 :
1771 0 : void ScUndoChartData::Undo()
1772 : {
1773 0 : BeginUndo();
1774 :
1775 0 : pDocShell->GetDocument().UpdateChartArea( aChartName, aOldRangeListRef,
1776 0 : bOldColHeaders, bOldRowHeaders, false );
1777 :
1778 0 : EndUndo();
1779 0 : }
1780 :
1781 0 : void ScUndoChartData::Redo()
1782 : {
1783 0 : BeginRedo();
1784 :
1785 0 : pDocShell->GetDocument().UpdateChartArea( aChartName, aNewRangeListRef,
1786 0 : bNewColHeaders, bNewRowHeaders, bAddRange );
1787 :
1788 0 : EndRedo();
1789 0 : }
1790 :
1791 0 : void ScUndoChartData::Repeat(SfxRepeatTarget& /* rTarget */)
1792 : {
1793 0 : }
1794 :
1795 4 : bool ScUndoChartData::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1796 : {
1797 4 : return false;
1798 : }
1799 :
1800 0 : ScUndoDataForm::ScUndoDataForm( ScDocShell* pNewDocShell,
1801 : SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
1802 : SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
1803 : const ScMarkData& rMark,
1804 : ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc,
1805 : InsertDeleteFlags nNewFlags,
1806 : ScRefUndoData* pRefData,
1807 : void* /*pFill1*/, void* /*pFill2*/, void* /*pFill3*/,
1808 : bool bRedoIsFilled ) :
1809 : ScBlockUndo( pNewDocShell, ScRange( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ), SC_UNDO_SIMPLE ),
1810 0 : mpMarkData(new ScMarkData(rMark)),
1811 : pUndoDoc( pNewUndoDoc ),
1812 : pRedoDoc( pNewRedoDoc ),
1813 : nFlags( nNewFlags ),
1814 : pRefUndoData( pRefData ),
1815 : pRefRedoData( NULL ),
1816 0 : bRedoFilled( bRedoIsFilled )
1817 : {
1818 : // pFill1,pFill2,pFill3 are there so the ctor calls for simple paste (without cutting)
1819 : // don't have to be changed and branched for 641.
1820 : // They can be removed later.
1821 :
1822 0 : if (!mpMarkData->IsMarked()) // no cell marked:
1823 0 : mpMarkData->SetMarkArea(aBlockRange); // mark paste block
1824 :
1825 0 : if ( pRefUndoData )
1826 0 : pRefUndoData->DeleteUnchanged( &pDocShell->GetDocument() );
1827 :
1828 0 : SetChangeTrack();
1829 0 : }
1830 :
1831 0 : ScUndoDataForm::~ScUndoDataForm()
1832 : {
1833 0 : delete pUndoDoc;
1834 0 : delete pRedoDoc;
1835 0 : delete pRefUndoData;
1836 0 : delete pRefRedoData;
1837 0 : }
1838 :
1839 0 : OUString ScUndoDataForm::GetComment() const
1840 : {
1841 0 : return ScGlobal::GetRscString( STR_UNDO_PASTE );
1842 : }
1843 :
1844 0 : void ScUndoDataForm::SetChangeTrack()
1845 : {
1846 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
1847 0 : if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
1848 : pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
1849 0 : nStartChangeAction, nEndChangeAction, SC_CACM_PASTE );
1850 : else
1851 0 : nStartChangeAction = nEndChangeAction = 0;
1852 0 : }
1853 :
1854 0 : void ScUndoDataForm::Undo()
1855 : {
1856 0 : BeginUndo();
1857 0 : DoChange( true );
1858 0 : ShowTable( aBlockRange );
1859 0 : EndUndo();
1860 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1861 0 : }
1862 :
1863 0 : void ScUndoDataForm::Redo()
1864 : {
1865 0 : BeginRedo();
1866 0 : ScDocument& rDoc = pDocShell->GetDocument();
1867 0 : EnableDrawAdjust( &rDoc, false ); //! include in ScBlockUndo?
1868 0 : DoChange( false );
1869 0 : EnableDrawAdjust( &rDoc, true ); //! include in ScBlockUndo?
1870 0 : EndRedo();
1871 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1872 0 : }
1873 :
1874 0 : void ScUndoDataForm::Repeat(SfxRepeatTarget& /*rTarget*/)
1875 : {
1876 0 : }
1877 :
1878 0 : bool ScUndoDataForm::CanRepeat(SfxRepeatTarget& rTarget) const
1879 : {
1880 0 : return (rTarget.ISA(ScTabViewTarget));
1881 : }
1882 :
1883 0 : void ScUndoDataForm::DoChange( const bool bUndo )
1884 : {
1885 0 : ScDocument& rDoc = pDocShell->GetDocument();
1886 :
1887 : // RefUndoData for redo is created before first undo
1888 : // (with DeleteUnchanged after the DoUndo call)
1889 0 : bool bCreateRedoData = ( bUndo && pRefUndoData && !pRefRedoData );
1890 0 : if ( bCreateRedoData )
1891 0 : pRefRedoData = new ScRefUndoData( &rDoc );
1892 :
1893 0 : ScRefUndoData* pWorkRefData = bUndo ? pRefUndoData : pRefRedoData;
1894 :
1895 : // Always back-up either all or none of the content for Undo
1896 0 : InsertDeleteFlags nUndoFlags = IDF_NONE;
1897 0 : if (nFlags & IDF_CONTENTS)
1898 0 : nUndoFlags |= IDF_CONTENTS;
1899 0 : if (nFlags & IDF_ATTRIB)
1900 0 : nUndoFlags |= IDF_ATTRIB;
1901 :
1902 0 : bool bPaintAll = false;
1903 :
1904 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1905 :
1906 0 : SCTAB nTabCount = rDoc.GetTableCount();
1907 0 : if ( bUndo && !bRedoFilled )
1908 : {
1909 0 : if (!pRedoDoc)
1910 : {
1911 0 : bool bColInfo = ( aBlockRange.aStart.Row()==0 && aBlockRange.aEnd.Row()==MAXROW );
1912 0 : bool bRowInfo = ( aBlockRange.aStart.Col()==0 && aBlockRange.aEnd.Col()==MAXCOL );
1913 :
1914 0 : pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
1915 0 : pRedoDoc->InitUndoSelected( &rDoc, *mpMarkData, bColInfo, bRowInfo );
1916 : }
1917 : // read "redo" data from the document in the first undo
1918 : // all sheets - CopyToDocument skips those that don't exist in pRedoDoc
1919 0 : ScRange aCopyRange = aBlockRange;
1920 0 : aCopyRange.aStart.SetTab(0);
1921 0 : aCopyRange.aEnd.SetTab(nTabCount-1);
1922 0 : rDoc.CopyToDocument( aCopyRange, IDF_VALUE, false, pRedoDoc );
1923 0 : bRedoFilled = true;
1924 : }
1925 :
1926 0 : sal_uInt16 nExtFlags = 0;
1927 0 : pDocShell->UpdatePaintExt( nExtFlags, aBlockRange );
1928 :
1929 0 : for ( sal_uInt16 i=0; i <= ( aBlockRange.aEnd.Col() - aBlockRange.aStart.Col() ); i++ )
1930 : {
1931 : OUString aOldString = pUndoDoc->GetString(
1932 0 : aBlockRange.aStart.Col()+i, aBlockRange.aStart.Row(), aBlockRange.aStart.Tab());
1933 0 : rDoc.SetString( aBlockRange.aStart.Col()+i , aBlockRange.aStart.Row() , aBlockRange.aStart.Tab() , aOldString );
1934 0 : }
1935 :
1936 0 : if (pWorkRefData)
1937 : {
1938 0 : pWorkRefData->DoUndo( &rDoc, true ); // TRUE = bSetChartRangeLists for SetChartListenerCollection
1939 0 : if ( rDoc.RefreshAutoFilter( 0,0, MAXCOL,MAXROW, aBlockRange.aStart.Tab() ) )
1940 0 : bPaintAll = true;
1941 : }
1942 :
1943 0 : if ( bCreateRedoData && pRefRedoData )
1944 0 : pRefRedoData->DeleteUnchanged( &rDoc );
1945 :
1946 0 : if ( bUndo )
1947 : {
1948 0 : ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1949 0 : if ( pChangeTrack )
1950 0 : pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1951 : }
1952 : else
1953 0 : SetChangeTrack();
1954 :
1955 0 : ScRange aDrawRange( aBlockRange );
1956 0 : rDoc.ExtendMerge( aDrawRange, true ); // only needed for single sheet (text/rtf etc.)
1957 0 : sal_uInt16 nPaint = PAINT_GRID;
1958 0 : if (bPaintAll)
1959 : {
1960 0 : aDrawRange.aStart.SetCol(0);
1961 0 : aDrawRange.aStart.SetRow(0);
1962 0 : aDrawRange.aEnd.SetCol(MAXCOL);
1963 0 : aDrawRange.aEnd.SetRow(MAXROW);
1964 0 : nPaint |= PAINT_TOP | PAINT_LEFT;
1965 0 : /*A*/ if (pViewShell)
1966 0 : pViewShell->AdjustBlockHeight(false);
1967 : }
1968 : else
1969 : {
1970 0 : if ( aBlockRange.aStart.Row() == 0 && aBlockRange.aEnd.Row() == MAXROW ) // whole column
1971 : {
1972 0 : nPaint |= PAINT_TOP;
1973 0 : aDrawRange.aEnd.SetCol(MAXCOL);
1974 : }
1975 0 : if ( aBlockRange.aStart.Col() == 0 && aBlockRange.aEnd.Col() == MAXCOL ) // whole row
1976 : {
1977 0 : nPaint |= PAINT_LEFT;
1978 0 : aDrawRange.aEnd.SetRow(MAXROW);
1979 : }
1980 0 : /*A*/ if ((pViewShell) && pViewShell->AdjustBlockHeight(false))
1981 : {
1982 0 : aDrawRange.aStart.SetCol(0);
1983 0 : aDrawRange.aStart.SetRow(0);
1984 0 : aDrawRange.aEnd.SetCol(MAXCOL);
1985 0 : aDrawRange.aEnd.SetRow(MAXROW);
1986 0 : nPaint |= PAINT_LEFT;
1987 : }
1988 0 : pDocShell->UpdatePaintExt( nExtFlags, aDrawRange );
1989 : }
1990 :
1991 0 : if ( !bUndo ) // draw redo after updating row heights
1992 0 : RedoSdrUndoAction( pDrawUndo ); //! include in ScBlockUndo?
1993 :
1994 0 : pDocShell->PostPaint( aDrawRange, nPaint, nExtFlags );
1995 :
1996 0 : pDocShell->PostDataChanged();
1997 0 : if (pViewShell)
1998 0 : pViewShell->CellContentChanged();
1999 228 : }
2000 :
2001 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
