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