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