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 : rtl::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 : sal_Bool ScUndoDoOutline::CanRepeat(SfxRepeatTarget& /* rTarget */) const
156 : {
157 0 : return false; // is not possible
158 : }
159 :
160 : /** Make or delete outline groups */
161 0 : 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 0 : bMake( bNewMake )
171 : {
172 0 : }
173 :
174 0 : ScUndoMakeOutline::~ScUndoMakeOutline()
175 : {
176 0 : delete pUndoTable;
177 0 : }
178 :
179 0 : rtl::OUString ScUndoMakeOutline::GetComment() const
180 : { // "Grouping" "Undo grouping"
181 : return bMake ?
182 : ScGlobal::GetRscString( STR_UNDO_MAKEOUTLINE ) :
183 0 : 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 : sal_Bool ScUndoMakeOutline::CanRepeat(SfxRepeatTarget& rTarget) const
239 : {
240 0 : return (rTarget.ISA(ScTabViewTarget));
241 : }
242 :
243 0 : 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 0 : nLevel( nNewLevel )
255 : {
256 0 : }
257 :
258 0 : ScUndoOutlineLevel::~ScUndoOutlineLevel()
259 : {
260 0 : delete pUndoDoc;
261 0 : delete pUndoTable;
262 0 : }
263 :
264 0 : rtl::OUString ScUndoOutlineLevel::GetComment() const
265 : { // "Select outline level"
266 0 : 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 : sal_Bool ScUndoOutlineLevel::CanRepeat(SfxRepeatTarget& rTarget) const
325 : {
326 0 : return (rTarget.ISA(ScTabViewTarget));
327 : }
328 :
329 : /** show/hide outline over block marks */
330 0 : 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 0 : bShow( bNewShow )
340 : {
341 0 : }
342 :
343 0 : ScUndoOutlineBlock::~ScUndoOutlineBlock()
344 : {
345 0 : delete pUndoDoc;
346 0 : delete pUndoTable;
347 0 : }
348 :
349 0 : rtl::OUString ScUndoOutlineBlock::GetComment() const
350 : { // "Show outline" "Hide outline"
351 : return bShow ?
352 : ScGlobal::GetRscString( STR_UNDO_DOOUTLINEBLK ) :
353 0 : 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 : sal_Bool ScUndoOutlineBlock::CanRepeat(SfxRepeatTarget& rTarget) const
428 : {
429 0 : return (rTarget.ISA(ScTabViewTarget));
430 : }
431 :
432 0 : 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 0 : pUndoTable( pNewUndoTab )
441 : {
442 0 : }
443 :
444 0 : ScUndoRemoveAllOutlines::~ScUndoRemoveAllOutlines()
445 : {
446 0 : delete pUndoDoc;
447 0 : delete pUndoTable;
448 0 : }
449 :
450 0 : rtl::OUString ScUndoRemoveAllOutlines::GetComment() const
451 : { // "Remove outlines"
452 0 : 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 : sal_Bool ScUndoRemoveAllOutlines::CanRepeat(SfxRepeatTarget& rTarget) const
513 : {
514 0 : return (rTarget.ISA(ScTabViewTarget));
515 : }
516 :
517 0 : 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 0 : pUndoTable( pNewUndoTab )
526 : {
527 0 : }
528 :
529 0 : ScUndoAutoOutline::~ScUndoAutoOutline()
530 : {
531 0 : delete pUndoDoc;
532 0 : delete pUndoTable;
533 0 : }
534 :
535 0 : rtl::OUString ScUndoAutoOutline::GetComment() const
536 : {
537 0 : 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 : sal_Bool ScUndoAutoOutline::CanRepeat(SfxRepeatTarget& rTarget) const
616 : {
617 0 : return (rTarget.ISA(ScTabViewTarget));
618 : }
619 :
620 0 : 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 0 : pUndoDB( pNewUndoDB )
633 : {
634 0 : }
635 :
636 0 : ScUndoSubTotals::~ScUndoSubTotals()
637 : {
638 0 : delete pUndoDoc;
639 0 : delete pUndoTable;
640 0 : delete pUndoRange;
641 0 : delete pUndoDB;
642 0 : }
643 :
644 0 : rtl::OUString ScUndoSubTotals::GetComment() const
645 : { // "Subtotals"
646 0 : 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 : sal_Bool ScUndoSubTotals::CanRepeat(SfxRepeatTarget& /* rTarget */) const
739 : {
740 0 : return false; // is not possible due to column numbers
741 : }
742 :
743 0 : 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 0 : bDestArea( false )
754 : {
755 0 : if ( pDest )
756 : {
757 0 : bDestArea = sal_True;
758 0 : aDestRange = *pDest;
759 : }
760 0 : }
761 :
762 0 : ScUndoSort::~ScUndoSort()
763 : {
764 0 : delete pUndoDoc;
765 0 : delete pUndoDB;
766 0 : }
767 :
768 0 : rtl::OUString ScUndoSort::GetComment() const
769 : {
770 0 : 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 : sal_Bool ScUndoSort::CanRepeat(SfxRepeatTarget& /* rTarget */) const
855 : {
856 0 : return false; // does not work due to column numbers
857 : }
858 :
859 0 : 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 0 : bDoSize( bSize )
872 : {
873 0 : if ( pOld )
874 : {
875 0 : bDestArea = sal_True;
876 0 : aOldDest = *pOld;
877 : }
878 0 : if ( pAdvSrc )
879 : {
880 0 : bIsAdvanced = sal_True;
881 0 : aAdvSource = *pAdvSrc;
882 : }
883 :
884 0 : pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
885 0 : }
886 :
887 0 : ScUndoQuery::~ScUndoQuery()
888 : {
889 0 : delete pUndoDoc;
890 0 : delete pUndoDB;
891 0 : DeleteSdrUndoAction( pDrawUndo );
892 0 : }
893 :
894 0 : rtl::OUString ScUndoQuery::GetComment() const
895 : { // "Filter";
896 0 : 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 : sal_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 ::rtl::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 : rtl::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 : sal_Bool ScUndoAutoFilter::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1104 : {
1105 0 : return false;
1106 : }
1107 :
1108 : // change database sections (dialog)
1109 0 : ScUndoDBData::ScUndoDBData( ScDocShell* pNewDocShell,
1110 : ScDBCollection* pNewUndoColl, ScDBCollection* pNewRedoColl ) :
1111 : ScSimpleUndo( pNewDocShell ),
1112 : pUndoColl( pNewUndoColl ),
1113 0 : pRedoColl( pNewRedoColl )
1114 : {
1115 0 : }
1116 :
1117 0 : ScUndoDBData::~ScUndoDBData()
1118 : {
1119 0 : delete pUndoColl;
1120 0 : delete pRedoColl;
1121 0 : }
1122 :
1123 0 : rtl::OUString ScUndoDBData::GetComment() const
1124 : { // "Change database range";
1125 0 : 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 0 : sal_Bool ScUndoDBData::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1169 : {
1170 0 : return false; // is not possible
1171 : }
1172 :
1173 0 : 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 0 : bRedoFilled( false )
1189 : {
1190 : // redo doc doesn't contain imported data (but everything else)
1191 0 : }
1192 :
1193 0 : ScUndoImportData::~ScUndoImportData()
1194 : {
1195 0 : delete pUndoDoc;
1196 0 : delete pRedoDoc;
1197 0 : delete pUndoDBData;
1198 0 : delete pRedoDBData;
1199 0 : }
1200 :
1201 0 : rtl::OUString ScUndoImportData::GetComment() const
1202 : {
1203 0 : 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 0 : pDoc->DoColResize( nTab, nCopyCol, nCopyCol, 0 );
1240 : }
1241 0 : pDoc->SetAutoCalc( bOldAutoCalc );
1242 0 : bRedoFilled = sal_True;
1243 : }
1244 : }
1245 : sal_Bool bMoveCells = pUndoDBData && pRedoDBData &&
1246 0 : pRedoDBData->IsDoSize(); // the same in old and new
1247 0 : if (bMoveCells)
1248 : {
1249 : // Undo: first delete the new data, then FitBlock backwards
1250 :
1251 0 : ScRange aOld, aNew;
1252 0 : pUndoDBData->GetArea( aOld );
1253 0 : pRedoDBData->GetArea( aNew );
1254 :
1255 0 : pDoc->DeleteAreaTab( aNew.aStart.Col(), aNew.aStart.Row(),
1256 0 : aNew.aEnd.Col(), aNew.aEnd.Row(), nTab, IDF_ALL & ~IDF_NOTE );
1257 :
1258 0 : aOld.aEnd.SetCol( aOld.aEnd.Col() + nFormulaCols ); // FitBlock also for formulas
1259 0 : aNew.aEnd.SetCol( aNew.aEnd.Col() + nFormulaCols );
1260 0 : pDoc->FitBlock( aNew, aOld, false ); // backwards
1261 : }
1262 : else
1263 : pDoc->DeleteAreaTab( aImportParam.nCol1,aImportParam.nRow1,
1264 0 : nEndCol,nEndRow, nTab, IDF_ALL & ~IDF_NOTE );
1265 :
1266 : pUndoDoc->CopyToDocument( aImportParam.nCol1,aImportParam.nRow1,nTab,
1267 : nEndCol+nFormulaCols,nEndRow,nTab,
1268 0 : IDF_ALL & ~IDF_NOTE, false, pDoc );
1269 :
1270 0 : if (pCurrentData)
1271 : {
1272 0 : *pCurrentData = *pUndoDBData;
1273 :
1274 0 : pUndoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1275 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, nCol1, nRow1, nTable, nCol2, nRow2, nTable );
1276 : }
1277 :
1278 0 : SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1279 0 : if ( nVisTab != nTab )
1280 0 : pViewShell->SetTabNo( nTab );
1281 :
1282 0 : if (bMoveCells)
1283 0 : pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
1284 : else
1285 : pDocShell->PostPaint( aImportParam.nCol1,aImportParam.nRow1,nTab,
1286 0 : nEndCol,nEndRow,nTab, PAINT_GRID );
1287 0 : pDocShell->PostDataChanged();
1288 :
1289 0 : EndUndo();
1290 0 : }
1291 :
1292 0 : void ScUndoImportData::Redo()
1293 : {
1294 0 : BeginRedo();
1295 :
1296 0 : ScDocument* pDoc = pDocShell->GetDocument();
1297 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1298 :
1299 : ScUndoUtil::MarkSimpleBlock( pDocShell, aImportParam.nCol1,aImportParam.nRow1,nTab,
1300 0 : nEndCol,nEndRow,nTab );
1301 :
1302 : SCTAB nTable;
1303 : SCCOL nCol1, nCol2;
1304 : SCROW nRow1, nRow2;
1305 0 : ScDBData* pCurrentData = NULL;
1306 0 : if (pUndoDBData && pRedoDBData)
1307 : {
1308 0 : pUndoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1309 : pCurrentData = ScUndoUtil::GetOldDBData( pUndoDBData, pDoc, nTab,
1310 0 : nCol1, nRow1, nCol2, nRow2 );
1311 : }
1312 : sal_Bool bMoveCells = pUndoDBData && pRedoDBData &&
1313 0 : pRedoDBData->IsDoSize(); // // the same in old and new
1314 0 : if (bMoveCells)
1315 : {
1316 : // Redo: FitBlock, then delete data (needed for CopyToDocument)
1317 :
1318 0 : ScRange aOld, aNew;
1319 0 : pUndoDBData->GetArea( aOld );
1320 0 : pRedoDBData->GetArea( aNew );
1321 :
1322 0 : aOld.aEnd.SetCol( aOld.aEnd.Col() + nFormulaCols ); // FitBlock also for formulas
1323 0 : aNew.aEnd.SetCol( aNew.aEnd.Col() + nFormulaCols );
1324 0 : pDoc->FitBlock( aOld, aNew );
1325 :
1326 0 : pDoc->DeleteAreaTab( aNew.aStart.Col(), aNew.aStart.Row(),
1327 0 : aNew.aEnd.Col(), aNew.aEnd.Row(), nTab, IDF_ALL & ~IDF_NOTE );
1328 :
1329 0 : pRedoDoc->CopyToDocument( aNew, IDF_ALL & ~IDF_NOTE, false, pDoc ); // including formulas
1330 : }
1331 : else
1332 : {
1333 : pDoc->DeleteAreaTab( aImportParam.nCol1,aImportParam.nRow1,
1334 0 : nEndCol,nEndRow, nTab, IDF_ALL & ~IDF_NOTE );
1335 : pRedoDoc->CopyToDocument( aImportParam.nCol1,aImportParam.nRow1,nTab,
1336 0 : nEndCol,nEndRow,nTab, IDF_ALL & ~IDF_NOTE, false, pDoc );
1337 : }
1338 :
1339 0 : if (pCurrentData)
1340 : {
1341 0 : *pCurrentData = *pRedoDBData;
1342 :
1343 0 : pRedoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1344 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, nCol1, nRow1, nTable, nCol2, nRow2, nTable );
1345 : }
1346 :
1347 0 : SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1348 0 : if ( nVisTab != nTab )
1349 0 : pViewShell->SetTabNo( nTab );
1350 :
1351 0 : if (bMoveCells)
1352 0 : pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
1353 : else
1354 : pDocShell->PostPaint( aImportParam.nCol1,aImportParam.nRow1,nTab,
1355 0 : nEndCol,nEndRow,nTab, PAINT_GRID );
1356 0 : pDocShell->PostDataChanged();
1357 :
1358 0 : EndRedo();
1359 0 : }
1360 :
1361 0 : void ScUndoImportData::Repeat(SfxRepeatTarget& rTarget)
1362 : {
1363 0 : if (rTarget.ISA(ScTabViewTarget))
1364 : {
1365 0 : ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
1366 :
1367 : SCTAB nDummy;
1368 0 : ScImportParam aNewParam(aImportParam);
1369 0 : ScDBData* pDBData = rViewShell.GetDBData();
1370 0 : pDBData->GetArea( nDummy, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
1371 :
1372 0 : rViewShell.ImportData( aNewParam );
1373 : }
1374 0 : }
1375 :
1376 0 : sal_Bool ScUndoImportData::CanRepeat(SfxRepeatTarget& rTarget) const
1377 : {
1378 : // Repeat only for import using a database range, then pUndoDBData is set
1379 :
1380 0 : if (pUndoDBData)
1381 0 : return (rTarget.ISA(ScTabViewTarget));
1382 : else
1383 0 : return false; // Address book
1384 : }
1385 :
1386 :
1387 0 : ScUndoRepeatDB::ScUndoRepeatDB( ScDocShell* pNewDocShell, SCTAB nNewTab,
1388 : SCCOL nStartX, SCROW nStartY, SCCOL nEndX, SCROW nEndY,
1389 : SCROW nResultEndRow, SCCOL nCurX, SCROW nCurY,
1390 : ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
1391 : ScRangeName* pNewUndoRange, ScDBCollection* pNewUndoDB,
1392 : const ScRange* pOldQ, const ScRange* pNewQ ) :
1393 : ScSimpleUndo( pNewDocShell ),
1394 : aBlockStart( nStartX,nStartY,nNewTab ),
1395 : aBlockEnd( nEndX,nEndY,nNewTab ),
1396 : nNewEndRow( nResultEndRow ),
1397 : aCursorPos( nCurX,nCurY,nNewTab ),
1398 : pUndoDoc( pNewUndoDoc ),
1399 : pUndoTable( pNewUndoTab ),
1400 : pUndoRange( pNewUndoRange ),
1401 : pUndoDB( pNewUndoDB ),
1402 0 : bQuerySize( false )
1403 : {
1404 0 : if ( pOldQ && pNewQ )
1405 : {
1406 0 : aOldQuery = *pOldQ;
1407 0 : aNewQuery = *pNewQ;
1408 0 : bQuerySize = sal_True;;
1409 : }
1410 0 : }
1411 :
1412 0 : ScUndoRepeatDB::~ScUndoRepeatDB()
1413 : {
1414 0 : delete pUndoDoc;
1415 0 : delete pUndoTable;
1416 0 : delete pUndoRange;
1417 0 : delete pUndoDB;
1418 0 : }
1419 :
1420 0 : rtl::OUString ScUndoRepeatDB::GetComment() const
1421 : {
1422 0 : return ScGlobal::GetRscString( STR_UNDO_REPEATDB );
1423 : }
1424 :
1425 0 : void ScUndoRepeatDB::Undo()
1426 : {
1427 0 : BeginUndo();
1428 :
1429 0 : ScDocument* pDoc = pDocShell->GetDocument();
1430 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1431 0 : SCTAB nTab = aBlockStart.Tab();
1432 :
1433 0 : if (bQuerySize)
1434 : {
1435 0 : pDoc->FitBlock( aNewQuery, aOldQuery, false );
1436 :
1437 0 : if ( aNewQuery.aEnd.Col() == aOldQuery.aEnd.Col() )
1438 : {
1439 0 : SCCOL nFormulaCols = 0;
1440 0 : SCCOL nCol = aOldQuery.aEnd.Col() + 1;
1441 0 : SCROW nRow = aOldQuery.aStart.Row() + 1; // test the header
1442 0 : while ( nCol <= MAXCOL &&
1443 0 : pDoc->GetCellType(ScAddress( nCol, nRow, nTab )) == CELLTYPE_FORMULA )
1444 0 : ++nCol, ++nFormulaCols;
1445 :
1446 0 : if ( nFormulaCols > 0 )
1447 : {
1448 0 : ScRange aOldForm = aOldQuery;
1449 0 : aOldForm.aStart.SetCol( aOldQuery.aEnd.Col() + 1 );
1450 0 : aOldForm.aEnd.SetCol( aOldQuery.aEnd.Col() + nFormulaCols );
1451 0 : ScRange aNewForm = aOldForm;
1452 0 : aNewForm.aEnd.SetRow( aNewQuery.aEnd.Row() );
1453 0 : pDoc->FitBlock( aNewForm, aOldForm, false );
1454 : }
1455 : }
1456 : }
1457 :
1458 : // TODO Data from Filter in other range are still missing!
1459 :
1460 0 : if (nNewEndRow > aBlockEnd.Row())
1461 : {
1462 0 : pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, aBlockEnd.Row()+1, static_cast<SCSIZE>(nNewEndRow-aBlockEnd.Row()) );
1463 : }
1464 0 : else if (nNewEndRow < aBlockEnd.Row())
1465 : {
1466 0 : pDoc->InsertRow( 0,nTab, MAXCOL,nTab, nNewEndRow+1, static_cast<SCSIZE>(nNewEndRow-aBlockEnd.Row()) );
1467 : }
1468 :
1469 : // Original Outline table
1470 0 : pDoc->SetOutlineTable( nTab, pUndoTable );
1471 :
1472 : // Original column/row status
1473 0 : if (pUndoDoc && pUndoTable)
1474 : {
1475 : SCCOLROW nStartCol;
1476 : SCCOLROW nStartRow;
1477 : SCCOLROW nEndCol;
1478 : SCCOLROW nEndRow;
1479 0 : pUndoTable->GetColArray()->GetRange( nStartCol, nEndCol );
1480 0 : pUndoTable->GetRowArray()->GetRange( nStartRow, nEndRow );
1481 :
1482 : pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
1483 : static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, false,
1484 0 : pDoc );
1485 0 : pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, false, pDoc );
1486 :
1487 0 : pViewShell->UpdateScrollBars();
1488 : }
1489 :
1490 : // Original data and references
1491 : ScUndoUtil::MarkSimpleBlock( pDocShell, 0, aBlockStart.Row(), nTab,
1492 0 : MAXCOL, aBlockEnd.Row(), nTab );
1493 : pDoc->DeleteAreaTab( 0, aBlockStart.Row(),
1494 0 : MAXCOL, aBlockEnd.Row(), nTab, IDF_ALL );
1495 :
1496 : pUndoDoc->CopyToDocument( 0, aBlockStart.Row(), nTab, MAXCOL, aBlockEnd.Row(), nTab,
1497 0 : IDF_NONE, false, pDoc ); // Flags
1498 : pUndoDoc->UndoToDocument( 0, aBlockStart.Row(), nTab, MAXCOL, aBlockEnd.Row(), nTab,
1499 0 : IDF_ALL, false, pDoc );
1500 :
1501 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart.Col(),aBlockStart.Row(),nTab,
1502 0 : aBlockEnd.Col(),aBlockEnd.Row(),nTab );
1503 :
1504 0 : if (pUndoRange)
1505 0 : pDoc->SetRangeName( new ScRangeName( *pUndoRange ) );
1506 0 : if (pUndoDB)
1507 0 : pDoc->SetDBCollection( new ScDBCollection( *pUndoDB ), sal_True );
1508 :
1509 0 : SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1510 0 : if ( nVisTab != nTab )
1511 0 : pViewShell->SetTabNo( nTab );
1512 :
1513 0 : pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
1514 0 : pDocShell->PostDataChanged();
1515 :
1516 0 : EndUndo();
1517 0 : }
1518 :
1519 0 : void ScUndoRepeatDB::Redo()
1520 : {
1521 0 : BeginRedo();
1522 :
1523 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1524 0 : SCTAB nTab = aBlockStart.Tab();
1525 :
1526 0 : SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1527 0 : if ( nVisTab != nTab )
1528 0 : pViewShell->SetTabNo( nTab );
1529 :
1530 0 : ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart.Col(),aBlockStart.Row(),nTab,
1531 0 : aBlockEnd.Col(),aBlockEnd.Row(),nTab );
1532 0 : pViewShell->SetCursor( aCursorPos.Col(), aCursorPos.Row() );
1533 :
1534 0 : pViewShell->RepeatDB( false );
1535 :
1536 0 : EndRedo();
1537 0 : }
1538 :
1539 0 : void ScUndoRepeatDB::Repeat(SfxRepeatTarget& rTarget)
1540 : {
1541 0 : if (rTarget.ISA(ScTabViewTarget))
1542 0 : ((ScTabViewTarget&)rTarget).GetViewShell()->RepeatDB( sal_True );
1543 0 : }
1544 :
1545 0 : sal_Bool ScUndoRepeatDB::CanRepeat(SfxRepeatTarget& rTarget) const
1546 : {
1547 0 : return (rTarget.ISA(ScTabViewTarget));
1548 : }
1549 :
1550 0 : ScUndoDataPilot::ScUndoDataPilot( ScDocShell* pNewDocShell,
1551 : ScDocument* pOldDoc, ScDocument* pNewDoc,
1552 : const ScDPObject* pOldObj, const ScDPObject* pNewObj, sal_Bool bMove ) :
1553 : ScSimpleUndo( pNewDocShell ),
1554 : pOldUndoDoc( pOldDoc ),
1555 : pNewUndoDoc( pNewDoc ),
1556 : pOldDPObject( NULL ),
1557 : pNewDPObject( NULL ),
1558 0 : bAllowMove( bMove )
1559 : {
1560 0 : if (pOldObj)
1561 0 : pOldDPObject = new ScDPObject( *pOldObj );
1562 0 : if (pNewObj)
1563 0 : pNewDPObject = new ScDPObject( *pNewObj );
1564 0 : }
1565 :
1566 0 : ScUndoDataPilot::~ScUndoDataPilot()
1567 : {
1568 0 : delete pOldDPObject;
1569 0 : delete pNewDPObject;
1570 0 : delete pOldUndoDoc;
1571 0 : delete pNewUndoDoc;
1572 0 : }
1573 :
1574 0 : rtl::OUString ScUndoDataPilot::GetComment() const
1575 : {
1576 : sal_uInt16 nIndex;
1577 0 : if ( pOldUndoDoc && pNewUndoDoc )
1578 0 : nIndex = STR_UNDO_PIVOT_MODIFY;
1579 0 : else if ( pNewUndoDoc )
1580 0 : nIndex = STR_UNDO_PIVOT_NEW;
1581 : else
1582 0 : nIndex = STR_UNDO_PIVOT_DELETE;
1583 :
1584 0 : return ScGlobal::GetRscString( nIndex );
1585 : }
1586 :
1587 0 : void ScUndoDataPilot::Undo()
1588 : {
1589 0 : BeginUndo();
1590 :
1591 0 : ScDocument* pDoc = pDocShell->GetDocument();
1592 :
1593 0 : ScRange aOldRange;
1594 0 : ScRange aNewRange;
1595 :
1596 0 : if ( pNewDPObject && pNewUndoDoc )
1597 : {
1598 0 : aNewRange = pNewDPObject->GetOutRange();
1599 0 : pDoc->DeleteAreaTab( aNewRange, IDF_ALL );
1600 0 : pNewUndoDoc->CopyToDocument( aNewRange, IDF_ALL, false, pDoc );
1601 : }
1602 0 : if ( pOldDPObject && pOldUndoDoc )
1603 : {
1604 0 : aOldRange = pOldDPObject->GetOutRange();
1605 0 : pDoc->DeleteAreaTab( aOldRange, IDF_ALL );
1606 0 : pOldUndoDoc->CopyToDocument( aOldRange, IDF_ALL, false, pDoc );
1607 : }
1608 :
1609 : // update objects in collection
1610 :
1611 0 : if ( pNewDPObject )
1612 : {
1613 : // find updated object
1614 : //! find by name!
1615 :
1616 : ScDPObject* pDocObj = pDoc->GetDPAtCursor(
1617 0 : aNewRange.aStart.Col(), aNewRange.aStart.Row(), aNewRange.aStart.Tab() );
1618 : OSL_ENSURE(pDocObj, "DPObject not found");
1619 0 : if (pDocObj)
1620 : {
1621 0 : if ( pOldDPObject )
1622 : {
1623 : // restore old settings
1624 0 : pOldDPObject->WriteSourceDataTo( *pDocObj );
1625 0 : ScDPSaveData* pData = pOldDPObject->GetSaveData();
1626 0 : if (pData)
1627 0 : pDocObj->SetSaveData(*pData);
1628 0 : pDocObj->SetOutRange( pOldDPObject->GetOutRange() );
1629 0 : pOldDPObject->WriteTempDataTo( *pDocObj );
1630 : }
1631 : else
1632 : {
1633 : // delete inserted object
1634 0 : pDoc->GetDPCollection()->FreeTable(pDocObj);
1635 : }
1636 : }
1637 : }
1638 0 : else if ( pOldDPObject )
1639 : {
1640 : // re-insert deleted object
1641 :
1642 0 : ScDPObject* pDestObj = new ScDPObject( *pOldDPObject );
1643 0 : pDestObj->SetAlive(sal_True);
1644 0 : if ( !pDoc->GetDPCollection()->InsertNewTable(pDestObj) )
1645 : {
1646 : OSL_FAIL("cannot insert DPObject");
1647 0 : DELETEZ( pDestObj );
1648 : }
1649 : }
1650 :
1651 0 : if (pNewUndoDoc)
1652 0 : pDocShell->PostPaint( aNewRange, PAINT_GRID, SC_PF_LINES );
1653 0 : if (pOldUndoDoc)
1654 0 : pDocShell->PostPaint( aOldRange, PAINT_GRID, SC_PF_LINES );
1655 0 : pDocShell->PostDataChanged();
1656 :
1657 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1658 : if (pViewShell)
1659 : {
1660 : //! set current sheet
1661 : }
1662 :
1663 0 : if (pNewDPObject)
1664 : {
1665 : // notify API objects
1666 0 : pDoc->BroadcastUno( ScDataPilotModifiedHint( pNewDPObject->GetName() ) );
1667 : }
1668 :
1669 0 : EndUndo();
1670 0 : }
1671 :
1672 0 : void ScUndoDataPilot::Redo()
1673 : {
1674 0 : BeginRedo();
1675 :
1676 : //! copy output data instead of repeating the change,
1677 : //! in case external data have changed!
1678 :
1679 0 : ScDocument* pDoc = pDocShell->GetDocument();
1680 :
1681 0 : ScDPObject* pSourceObj = NULL;
1682 0 : if ( pOldDPObject )
1683 : {
1684 : // find object to modify
1685 : //! find by name!
1686 :
1687 0 : ScRange aOldRange = pOldDPObject->GetOutRange();
1688 : pSourceObj = pDoc->GetDPAtCursor(
1689 0 : aOldRange.aStart.Col(), aOldRange.aStart.Row(), aOldRange.aStart.Tab() );
1690 : OSL_ENSURE(pSourceObj, "DPObject not found");
1691 : }
1692 :
1693 0 : ScDBDocFunc aFunc( *pDocShell );
1694 0 : aFunc.DataPilotUpdate( pSourceObj, pNewDPObject, false, false, bAllowMove ); // no new undo action
1695 :
1696 0 : EndRedo();
1697 0 : }
1698 :
1699 0 : void ScUndoDataPilot::Repeat(SfxRepeatTarget& /* rTarget */)
1700 : {
1701 : //! allow deletion
1702 0 : }
1703 :
1704 0 : sal_Bool ScUndoDataPilot::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1705 : {
1706 : //! allow deletion
1707 0 : return false;
1708 : }
1709 :
1710 0 : ScUndoConsolidate::ScUndoConsolidate( ScDocShell* pNewDocShell, const ScArea& rArea,
1711 : const ScConsolidateParam& rPar, ScDocument* pNewUndoDoc,
1712 : sal_Bool bReference, SCROW nInsCount, ScOutlineTable* pTab,
1713 : ScDBData* pData ) :
1714 : ScSimpleUndo( pNewDocShell ),
1715 : aDestArea( rArea ),
1716 : pUndoDoc( pNewUndoDoc ),
1717 : aParam( rPar ),
1718 : bInsRef( bReference ),
1719 : nInsertCount( nInsCount ),
1720 : pUndoTab( pTab ),
1721 0 : pUndoData( pData )
1722 : {
1723 0 : }
1724 :
1725 0 : ScUndoConsolidate::~ScUndoConsolidate()
1726 : {
1727 0 : delete pUndoDoc;
1728 0 : delete pUndoTab;
1729 0 : delete pUndoData;
1730 0 : }
1731 :
1732 0 : rtl::OUString ScUndoConsolidate::GetComment() const
1733 : {
1734 0 : return ScGlobal::GetRscString( STR_UNDO_CONSOLIDATE );
1735 : }
1736 :
1737 0 : void ScUndoConsolidate::Undo()
1738 : {
1739 0 : BeginUndo();
1740 :
1741 0 : ScDocument* pDoc = pDocShell->GetDocument();
1742 0 : SCTAB nTab = aDestArea.nTab;
1743 :
1744 0 : ScRange aOldRange;
1745 0 : if (pUndoData)
1746 0 : pUndoData->GetArea(aOldRange);
1747 :
1748 0 : if (bInsRef)
1749 : {
1750 0 : pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, aDestArea.nRowStart, nInsertCount );
1751 0 : pDoc->SetOutlineTable( nTab, pUndoTab );
1752 :
1753 : // Row status
1754 0 : pUndoDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, false, pDoc );
1755 :
1756 : // Data and references
1757 0 : pDoc->DeleteAreaTab( 0,aDestArea.nRowStart, MAXCOL,aDestArea.nRowEnd, nTab, IDF_ALL );
1758 : pUndoDoc->UndoToDocument( 0, aDestArea.nRowStart, nTab,
1759 : MAXCOL, aDestArea.nRowEnd, nTab,
1760 0 : IDF_ALL, false, pDoc );
1761 :
1762 : // Original range
1763 0 : if (pUndoData)
1764 : {
1765 0 : pDoc->DeleteAreaTab(aOldRange, IDF_ALL);
1766 0 : pUndoDoc->CopyToDocument(aOldRange, IDF_ALL, false, pDoc);
1767 : }
1768 :
1769 : pDocShell->PostPaint( 0,aDestArea.nRowStart,nTab, MAXCOL,MAXROW,nTab,
1770 0 : PAINT_GRID | PAINT_LEFT | PAINT_SIZE );
1771 : }
1772 : else
1773 : {
1774 : pDoc->DeleteAreaTab( aDestArea.nColStart,aDestArea.nRowStart,
1775 0 : aDestArea.nColEnd,aDestArea.nRowEnd, nTab, IDF_ALL );
1776 : pUndoDoc->CopyToDocument( aDestArea.nColStart, aDestArea.nRowStart, nTab,
1777 : aDestArea.nColEnd, aDestArea.nRowEnd, nTab,
1778 0 : IDF_ALL, false, pDoc );
1779 :
1780 : // Original range
1781 0 : if (pUndoData)
1782 : {
1783 0 : pDoc->DeleteAreaTab(aOldRange, IDF_ALL);
1784 0 : pUndoDoc->CopyToDocument(aOldRange, IDF_ALL, false, pDoc);
1785 : }
1786 :
1787 0 : SCCOL nEndX = aDestArea.nColEnd;
1788 0 : SCROW nEndY = aDestArea.nRowEnd;
1789 0 : if ( pUndoData )
1790 : {
1791 0 : if ( aOldRange.aEnd.Col() > nEndX )
1792 0 : nEndX = aOldRange.aEnd.Col();
1793 0 : if ( aOldRange.aEnd.Row() > nEndY )
1794 0 : nEndY = aOldRange.aEnd.Row();
1795 : }
1796 : pDocShell->PostPaint( aDestArea.nColStart, aDestArea.nRowStart, nTab,
1797 0 : nEndX, nEndY, nTab, PAINT_GRID );
1798 : }
1799 :
1800 : // Adjust Database range again
1801 0 : if (pUndoData)
1802 : {
1803 0 : ScDBCollection* pColl = pDoc->GetDBCollection();
1804 0 : if (pColl)
1805 : {
1806 0 : ScDBData* pDocData = pColl->getNamedDBs().findByUpperName(pUndoData->GetUpperName());
1807 0 : if (pDocData)
1808 0 : *pDocData = *pUndoData;
1809 : }
1810 : }
1811 :
1812 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1813 0 : if (pViewShell)
1814 : {
1815 0 : SCTAB nViewTab = pViewShell->GetViewData()->GetTabNo();
1816 0 : if ( nViewTab != nTab )
1817 0 : pViewShell->SetTabNo( nTab );
1818 : }
1819 :
1820 0 : EndUndo();
1821 0 : }
1822 :
1823 0 : void ScUndoConsolidate::Redo()
1824 : {
1825 0 : BeginRedo();
1826 :
1827 0 : pDocShell->DoConsolidate( aParam, false );
1828 :
1829 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1830 0 : if (pViewShell)
1831 : {
1832 0 : SCTAB nViewTab = pViewShell->GetViewData()->GetTabNo();
1833 0 : if ( nViewTab != aParam.nTab )
1834 0 : pViewShell->SetTabNo( aParam.nTab );
1835 : }
1836 :
1837 0 : EndRedo();
1838 0 : }
1839 :
1840 0 : void ScUndoConsolidate::Repeat(SfxRepeatTarget& /* rTarget */)
1841 : {
1842 0 : }
1843 :
1844 0 : sal_Bool ScUndoConsolidate::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1845 : {
1846 0 : return false;
1847 : }
1848 :
1849 : // Change source data of Chart
1850 0 : void ScUndoChartData::Init()
1851 : {
1852 0 : ScDocument* pDoc = pDocShell->GetDocument();
1853 0 : aOldRangeListRef = new ScRangeList;
1854 0 : pDoc->GetOldChartParameters( aChartName, *aOldRangeListRef, bOldColHeaders, bOldRowHeaders );
1855 0 : }
1856 :
1857 0 : ScUndoChartData::ScUndoChartData( ScDocShell* pNewDocShell, const String& rName,
1858 : const ScRange& rNew, bool bColHdr, bool bRowHdr,
1859 : bool bAdd ) :
1860 : ScSimpleUndo( pNewDocShell ),
1861 : aChartName( rName ),
1862 : bNewColHeaders( bColHdr ),
1863 : bNewRowHeaders( bRowHdr ),
1864 0 : bAddRange( bAdd )
1865 : {
1866 0 : aNewRangeListRef = new ScRangeList;
1867 0 : aNewRangeListRef->Append( rNew );
1868 :
1869 0 : Init();
1870 0 : }
1871 :
1872 0 : ScUndoChartData::ScUndoChartData( ScDocShell* pNewDocShell, const String& rName,
1873 : const ScRangeListRef& rNew, bool bColHdr, bool bRowHdr,
1874 : bool bAdd ) :
1875 : ScSimpleUndo( pNewDocShell ),
1876 : aChartName( rName ),
1877 : aNewRangeListRef( rNew ),
1878 : bNewColHeaders( bColHdr ),
1879 : bNewRowHeaders( bRowHdr ),
1880 0 : bAddRange( bAdd )
1881 : {
1882 0 : Init();
1883 0 : }
1884 :
1885 0 : ScUndoChartData::~ScUndoChartData()
1886 : {
1887 0 : }
1888 :
1889 0 : rtl::OUString ScUndoChartData::GetComment() const
1890 : {
1891 0 : return ScGlobal::GetRscString( STR_UNDO_CHARTDATA );
1892 : }
1893 :
1894 0 : void ScUndoChartData::Undo()
1895 : {
1896 0 : BeginUndo();
1897 :
1898 : pDocShell->GetDocument()->UpdateChartArea( aChartName, aOldRangeListRef,
1899 0 : bOldColHeaders, bOldRowHeaders, false );
1900 :
1901 0 : EndUndo();
1902 0 : }
1903 :
1904 0 : void ScUndoChartData::Redo()
1905 : {
1906 0 : BeginRedo();
1907 :
1908 : pDocShell->GetDocument()->UpdateChartArea( aChartName, aNewRangeListRef,
1909 0 : bNewColHeaders, bNewRowHeaders, bAddRange );
1910 :
1911 0 : EndRedo();
1912 0 : }
1913 :
1914 0 : void ScUndoChartData::Repeat(SfxRepeatTarget& /* rTarget */)
1915 : {
1916 0 : }
1917 :
1918 0 : sal_Bool ScUndoChartData::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1919 : {
1920 0 : return false;
1921 : }
1922 :
1923 0 : ScUndoDataForm::ScUndoDataForm( ScDocShell* pNewDocShell,
1924 : SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
1925 : SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
1926 : const ScMarkData& rMark,
1927 : ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc,
1928 : sal_uInt16 nNewFlags,
1929 : ScRefUndoData* pRefData,
1930 : void* /*pFill1*/, void* /*pFill2*/, void* /*pFill3*/,
1931 : sal_Bool bRedoIsFilled ) :
1932 : ScBlockUndo( pNewDocShell, ScRange( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ), SC_UNDO_SIMPLE ),
1933 0 : mpMarkData(new ScMarkData(rMark)),
1934 : pUndoDoc( pNewUndoDoc ),
1935 : pRedoDoc( pNewRedoDoc ),
1936 : nFlags( nNewFlags ),
1937 : pRefUndoData( pRefData ),
1938 : pRefRedoData( NULL ),
1939 0 : bRedoFilled( bRedoIsFilled )
1940 : {
1941 : // pFill1,pFill2,pFill3 are there so the ctor calls for simple paste (without cutting)
1942 : // don't have to be changed and branched for 641.
1943 : // They can be removed later.
1944 :
1945 0 : if (!mpMarkData->IsMarked()) // no cell marked:
1946 0 : mpMarkData->SetMarkArea(aBlockRange); // mark paste block
1947 :
1948 0 : if ( pRefUndoData )
1949 0 : pRefUndoData->DeleteUnchanged( pDocShell->GetDocument() );
1950 :
1951 0 : SetChangeTrack();
1952 0 : }
1953 :
1954 0 : ScUndoDataForm::~ScUndoDataForm()
1955 : {
1956 0 : delete pUndoDoc;
1957 0 : delete pRedoDoc;
1958 0 : delete pRefUndoData;
1959 0 : delete pRefRedoData;
1960 0 : }
1961 :
1962 0 : rtl::OUString ScUndoDataForm::GetComment() const
1963 : {
1964 0 : return ScGlobal::GetRscString( STR_UNDO_PASTE );
1965 : }
1966 :
1967 0 : void ScUndoDataForm::SetChangeTrack()
1968 : {
1969 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
1970 0 : if ( pChangeTrack && (nFlags & IDF_CONTENTS) )
1971 : pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc,
1972 0 : nStartChangeAction, nEndChangeAction, SC_CACM_PASTE );
1973 : else
1974 0 : nStartChangeAction = nEndChangeAction = 0;
1975 0 : }
1976 :
1977 0 : void ScUndoDataForm::Undo()
1978 : {
1979 0 : BeginUndo();
1980 0 : DoChange( true );
1981 0 : ShowTable( aBlockRange );
1982 0 : EndUndo();
1983 0 : SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1984 0 : }
1985 :
1986 0 : void ScUndoDataForm::Redo()
1987 : {
1988 0 : BeginRedo();
1989 0 : ScDocument* pDoc = pDocShell->GetDocument();
1990 0 : EnableDrawAdjust( pDoc, false ); //! include in ScBlockUndo?
1991 0 : DoChange( false );
1992 0 : EnableDrawAdjust( pDoc, true ); //! include in ScBlockUndo?
1993 0 : EndRedo();
1994 0 : SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1995 0 : }
1996 :
1997 0 : void ScUndoDataForm::Repeat(SfxRepeatTarget& /*rTarget*/)
1998 : {
1999 0 : }
2000 :
2001 0 : sal_Bool ScUndoDataForm::CanRepeat(SfxRepeatTarget& rTarget) const
2002 : {
2003 0 : return (rTarget.ISA(ScTabViewTarget));
2004 : }
2005 :
2006 0 : void ScUndoDataForm::DoChange( const sal_Bool bUndo )
2007 : {
2008 0 : ScDocument* pDoc = pDocShell->GetDocument();
2009 :
2010 : // RefUndoData for redo is created before first undo
2011 : // (with DeleteUnchanged after the DoUndo call)
2012 0 : sal_Bool bCreateRedoData = ( bUndo && pRefUndoData && !pRefRedoData );
2013 0 : if ( bCreateRedoData )
2014 0 : pRefRedoData = new ScRefUndoData( pDoc );
2015 :
2016 0 : ScRefUndoData* pWorkRefData = bUndo ? pRefUndoData : pRefRedoData;
2017 :
2018 : // Always back-up either all or none of the content for Undo
2019 0 : sal_uInt16 nUndoFlags = IDF_NONE;
2020 0 : if (nFlags & IDF_CONTENTS)
2021 0 : nUndoFlags |= IDF_CONTENTS;
2022 0 : if (nFlags & IDF_ATTRIB)
2023 0 : nUndoFlags |= IDF_ATTRIB;
2024 :
2025 0 : sal_Bool bPaintAll = false;
2026 :
2027 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2028 :
2029 0 : SCTAB nTabCount = pDoc->GetTableCount();
2030 0 : if ( bUndo && !bRedoFilled )
2031 : {
2032 0 : if (!pRedoDoc)
2033 : {
2034 0 : sal_Bool bColInfo = ( aBlockRange.aStart.Row()==0 && aBlockRange.aEnd.Row()==MAXROW );
2035 0 : sal_Bool bRowInfo = ( aBlockRange.aStart.Col()==0 && aBlockRange.aEnd.Col()==MAXCOL );
2036 :
2037 0 : pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
2038 0 : pRedoDoc->InitUndoSelected( pDoc, *mpMarkData, bColInfo, bRowInfo );
2039 : }
2040 : // read "redo" data from the document in the first undo
2041 : // all sheets - CopyToDocument skips those that don't exist in pRedoDoc
2042 0 : ScRange aCopyRange = aBlockRange;
2043 0 : aCopyRange.aStart.SetTab(0);
2044 0 : aCopyRange.aEnd.SetTab(nTabCount-1);
2045 0 : pDoc->CopyToDocument( aCopyRange, 1, false, pRedoDoc );
2046 0 : bRedoFilled = true;
2047 : }
2048 :
2049 0 : sal_uInt16 nExtFlags = 0;
2050 0 : pDocShell->UpdatePaintExt( nExtFlags, aBlockRange );
2051 :
2052 0 : for ( sal_uInt16 i=0; i <= ( aBlockRange.aEnd.Col() - aBlockRange.aStart.Col() ); i++ )
2053 : {
2054 0 : String aOldString;
2055 0 : pUndoDoc->GetString( aBlockRange.aStart.Col()+i , aBlockRange.aStart.Row() , aBlockRange.aStart.Tab() , aOldString );
2056 0 : pDoc->SetString( aBlockRange.aStart.Col()+i , aBlockRange.aStart.Row() , aBlockRange.aStart.Tab() , aOldString );
2057 0 : }
2058 :
2059 0 : if (pWorkRefData)
2060 : {
2061 0 : pWorkRefData->DoUndo( pDoc, true ); // TRUE = bSetChartRangeLists for SetChartListenerCollection
2062 0 : if ( pDoc->RefreshAutoFilter( 0,0, MAXCOL,MAXROW, aBlockRange.aStart.Tab() ) )
2063 0 : bPaintAll = true;
2064 : }
2065 :
2066 0 : if ( bCreateRedoData && pRefRedoData )
2067 0 : pRefRedoData->DeleteUnchanged( pDoc );
2068 :
2069 0 : if ( bUndo )
2070 : {
2071 0 : ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
2072 0 : if ( pChangeTrack )
2073 0 : pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
2074 : }
2075 : else
2076 0 : SetChangeTrack();
2077 :
2078 0 : ScRange aDrawRange( aBlockRange );
2079 0 : pDoc->ExtendMerge( aDrawRange, true ); // only needed for single sheet (text/rtf etc.)
2080 0 : sal_uInt16 nPaint = PAINT_GRID;
2081 0 : if (bPaintAll)
2082 : {
2083 0 : aDrawRange.aStart.SetCol(0);
2084 0 : aDrawRange.aStart.SetRow(0);
2085 0 : aDrawRange.aEnd.SetCol(MAXCOL);
2086 0 : aDrawRange.aEnd.SetRow(MAXROW);
2087 0 : nPaint |= PAINT_TOP | PAINT_LEFT;
2088 0 : /*A*/ if (pViewShell)
2089 0 : pViewShell->AdjustBlockHeight(false);
2090 : }
2091 : else
2092 : {
2093 0 : if ( aBlockRange.aStart.Row() == 0 && aBlockRange.aEnd.Row() == MAXROW ) // whole column
2094 : {
2095 0 : nPaint |= PAINT_TOP;
2096 0 : aDrawRange.aEnd.SetCol(MAXCOL);
2097 : }
2098 0 : if ( aBlockRange.aStart.Col() == 0 && aBlockRange.aEnd.Col() == MAXCOL ) // whole row
2099 : {
2100 0 : nPaint |= PAINT_LEFT;
2101 0 : aDrawRange.aEnd.SetRow(MAXROW);
2102 : }
2103 0 : /*A*/ if ((pViewShell) && pViewShell->AdjustBlockHeight(false))
2104 : {
2105 0 : aDrawRange.aStart.SetCol(0);
2106 0 : aDrawRange.aStart.SetRow(0);
2107 0 : aDrawRange.aEnd.SetCol(MAXCOL);
2108 0 : aDrawRange.aEnd.SetRow(MAXROW);
2109 0 : nPaint |= PAINT_LEFT;
2110 : }
2111 0 : pDocShell->UpdatePaintExt( nExtFlags, aDrawRange );
2112 : }
2113 :
2114 0 : if ( !bUndo ) // draw redo after updating row heights
2115 0 : RedoSdrUndoAction( pDrawUndo ); //! include in ScBlockUndo?
2116 :
2117 0 : pDocShell->PostPaint( aDrawRange, nPaint, nExtFlags );
2118 :
2119 0 : pDocShell->PostDataChanged();
2120 0 : if (pViewShell)
2121 0 : pViewShell->CellContentChanged();
2122 15 : }
2123 :
2124 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
