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