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 <vcl/virdev.hxx>
30 : :
31 : : #include "undobase.hxx"
32 : : #include "refundo.hxx"
33 : : #include "docsh.hxx"
34 : : #include "tabvwsh.hxx"
35 : : #include "undoolk.hxx"
36 : : #include "undodraw.hxx"
37 : : #include "dbdata.hxx"
38 : : #include "attrib.hxx"
39 : : #include "queryparam.hxx"
40 : : #include "subtotalparam.hxx"
41 : : #include "globstr.hrc"
42 : :
43 : : // STATIC DATA -----------------------------------------------------------
44 : :
45 [ # # ][ # # ]: 0 : TYPEINIT1(ScSimpleUndo, SfxUndoAction);
46 [ # # ][ # # ]: 0 : TYPEINIT1(ScBlockUndo, ScSimpleUndo);
47 [ # # ][ # # ]: 0 : TYPEINIT1(ScMultiBlockUndo, ScSimpleUndo);
48 [ # # ][ # # ]: 0 : TYPEINIT1(ScMoveUndo, ScSimpleUndo);
49 [ # # ][ # # ]: 0 : TYPEINIT1(ScDBFuncUndo, ScSimpleUndo);
50 [ # # ][ # # ]: 0 : TYPEINIT1(ScUndoWrapper, SfxUndoAction);
51 : :
52 : : // -----------------------------------------------------------------------
53 : :
54 : 3718 : ScSimpleUndo::ScSimpleUndo( ScDocShell* pDocSh ) :
55 : : pDocShell( pDocSh ),
56 : 3718 : pDetectiveUndo( NULL )
57 : : {
58 : 3718 : }
59 : :
60 : 3692 : ScSimpleUndo::~ScSimpleUndo()
61 : : {
62 [ + + ][ + - ]: 3692 : delete pDetectiveUndo;
63 [ - + ]: 3692 : }
64 : :
65 : 0 : bool ScSimpleUndo::SetViewMarkData( const ScMarkData& rMarkData )
66 : : {
67 [ # # ]: 0 : if ( IsPaintLocked() )
68 : 0 : return false;
69 : :
70 : 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
71 [ # # ]: 0 : if ( !pViewShell )
72 : 0 : return false;
73 : :
74 : 0 : pViewShell->SetMarkData( rMarkData );
75 : 0 : return true;
76 : : }
77 : :
78 : 2 : sal_Bool ScSimpleUndo::Merge( SfxUndoAction *pNextAction )
79 : : {
80 : : // Zu jeder Undo-Action kann eine SdrUndoGroup fuer das Aktualisieren
81 : : // der Detektiv-Pfeile gehoeren.
82 : : // DetectiveRefresh kommt immer hinterher, die SdrUndoGroup ist in
83 : : // eine ScUndoDraw Action verpackt.
84 : : // Nur beim automatischen Aktualisieren wird AddUndoAction mit
85 : : // bTryMerg=sal_True gerufen.
86 : :
87 [ + - ][ + - ]: 2 : if ( !pDetectiveUndo && pNextAction->ISA(ScUndoDraw) )
[ + - ]
88 : : {
89 : : // SdrUndoAction aus der ScUndoDraw Action uebernehmen,
90 : : // ScUndoDraw wird dann vom UndoManager geloescht
91 : :
92 : 2 : ScUndoDraw* pCalcUndo = (ScUndoDraw*)pNextAction;
93 : 2 : pDetectiveUndo = pCalcUndo->GetDrawUndo();
94 : 2 : pCalcUndo->ForgetDrawUndo();
95 : 2 : return sal_True;
96 : : }
97 : :
98 : 2 : return false;
99 : : }
100 : :
101 : 3 : void ScSimpleUndo::BeginUndo()
102 : : {
103 : 3 : pDocShell->SetInUndo( sal_True );
104 : :
105 : 3 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
106 [ - + ]: 3 : if (pViewShell)
107 : 0 : pViewShell->HideAllCursors(); // z.B. wegen zusammengefassten Zellen
108 : :
109 : : // detective updates happened last, must be undone first
110 [ - + ]: 3 : if (pDetectiveUndo)
111 : 0 : pDetectiveUndo->Undo();
112 : 3 : }
113 : :
114 : 3 : void ScSimpleUndo::EndUndo()
115 : : {
116 : 3 : pDocShell->SetDocumentModified();
117 : :
118 : 3 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
119 [ - + ]: 3 : if (pViewShell)
120 : : {
121 : 0 : pViewShell->UpdateAutoFillMark();
122 : 0 : pViewShell->UpdateInputHandler();
123 : 0 : pViewShell->ShowAllCursors();
124 : : }
125 : :
126 : 3 : pDocShell->SetInUndo( false );
127 : 3 : }
128 : :
129 : 3 : void ScSimpleUndo::BeginRedo()
130 : : {
131 : 3 : pDocShell->SetInUndo( sal_True ); //! eigenes Flag fuer Redo?
132 : :
133 : 3 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
134 [ - + ]: 3 : if (pViewShell)
135 : 0 : pViewShell->HideAllCursors(); // z.B. wegen zusammengefassten Zellen
136 : 3 : }
137 : :
138 : 3 : void ScSimpleUndo::EndRedo()
139 : : {
140 [ - + ]: 3 : if (pDetectiveUndo)
141 : 0 : pDetectiveUndo->Redo();
142 : :
143 : 3 : pDocShell->SetDocumentModified();
144 : :
145 : 3 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
146 [ - + ]: 3 : if (pViewShell)
147 : : {
148 : 0 : pViewShell->UpdateAutoFillMark();
149 : 0 : pViewShell->UpdateInputHandler();
150 : 0 : pViewShell->ShowAllCursors();
151 : : }
152 : :
153 : 3 : pDocShell->SetInUndo( false );
154 : 3 : }
155 : :
156 : 0 : void ScSimpleUndo::ShowTable( SCTAB nTab )
157 : : {
158 : 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
159 [ # # ]: 0 : if (pViewShell)
160 : 0 : pViewShell->SetTabNo( nTab );
161 : 0 : }
162 : :
163 : 3 : void ScSimpleUndo::ShowTable( const ScRange& rRange )
164 : : {
165 : 3 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
166 [ - + ]: 3 : if (pViewShell)
167 : : {
168 : 0 : SCTAB nStart = rRange.aStart.Tab();
169 : 0 : SCTAB nEnd = rRange.aEnd.Tab();
170 : 0 : SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
171 [ # # ][ # # ]: 0 : if ( nTab < nStart || nTab > nEnd ) // wenn nicht im Bereich:
172 : 0 : pViewShell->SetTabNo( nStart ); // auf erste des Bereiches
173 : : }
174 : 3 : }
175 : :
176 : :
177 : : // -----------------------------------------------------------------------
178 : :
179 : 41 : ScBlockUndo::ScBlockUndo( ScDocShell* pDocSh, const ScRange& rRange,
180 : : ScBlockUndoMode eBlockMode ) :
181 : : ScSimpleUndo( pDocSh ),
182 : : aBlockRange( rRange ),
183 : 41 : eMode( eBlockMode )
184 : : {
185 [ + - ]: 41 : pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
186 : 41 : }
187 : :
188 : 38 : ScBlockUndo::~ScBlockUndo()
189 : : {
190 [ + - ]: 38 : DeleteSdrUndoAction( pDrawUndo );
191 [ - + ]: 38 : }
192 : :
193 : 0 : void ScBlockUndo::BeginUndo()
194 : : {
195 : 0 : ScSimpleUndo::BeginUndo();
196 : 0 : EnableDrawAdjust( pDocShell->GetDocument(), false );
197 : 0 : }
198 : :
199 : 0 : void ScBlockUndo::EndUndo()
200 : : {
201 [ # # ]: 0 : if (eMode == SC_UNDO_AUTOHEIGHT)
202 : 0 : AdjustHeight();
203 : :
204 : 0 : EnableDrawAdjust( pDocShell->GetDocument(), sal_True );
205 : 0 : DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() );
206 : :
207 : 0 : ShowBlock();
208 : 0 : ScSimpleUndo::EndUndo();
209 : 0 : }
210 : :
211 : 0 : void ScBlockUndo::EndRedo()
212 : : {
213 [ # # ]: 0 : if (eMode == SC_UNDO_AUTOHEIGHT)
214 : 0 : AdjustHeight();
215 : :
216 : 0 : ShowBlock();
217 : 0 : ScSimpleUndo::EndRedo();
218 : 0 : }
219 : :
220 : 0 : sal_Bool ScBlockUndo::AdjustHeight()
221 : : {
222 : 0 : ScDocument* pDoc = pDocShell->GetDocument();
223 : :
224 [ # # ]: 0 : VirtualDevice aVirtDev;
225 [ # # ]: 0 : Fraction aZoomX( 1, 1 );
226 [ # # ]: 0 : Fraction aZoomY = aZoomX;
227 : : double nPPTX, nPPTY;
228 [ # # ]: 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
229 [ # # ]: 0 : if (pViewShell)
230 : : {
231 : 0 : ScViewData* pData = pViewShell->GetViewData();
232 : 0 : nPPTX = pData->GetPPTX();
233 : 0 : nPPTY = pData->GetPPTY();
234 [ # # ]: 0 : aZoomX = pData->GetZoomX();
235 [ # # ]: 0 : aZoomY = pData->GetZoomY();
236 : : }
237 : : else
238 : : {
239 : : // Zoom auf 100 lassen
240 : 0 : nPPTX = ScGlobal::nScreenPPTX;
241 : 0 : nPPTY = ScGlobal::nScreenPPTY;
242 : : }
243 : :
244 : : sal_Bool bRet = pDoc->SetOptimalHeight( aBlockRange.aStart.Row(), aBlockRange.aEnd.Row(),
245 : 0 : /*!*/ aBlockRange.aStart.Tab(), 0, &aVirtDev,
246 [ # # ]: 0 : nPPTX, nPPTY, aZoomX, aZoomY, false );
247 : :
248 [ # # ]: 0 : if (bRet)
249 : 0 : pDocShell->PostPaint( 0, aBlockRange.aStart.Row(), aBlockRange.aStart.Tab(),
250 : 0 : MAXCOL, MAXROW, aBlockRange.aEnd.Tab(),
251 [ # # ]: 0 : PAINT_GRID | PAINT_LEFT );
252 : :
253 [ # # ]: 0 : return bRet;
254 : : }
255 : :
256 : 0 : void ScBlockUndo::ShowBlock()
257 : : {
258 [ # # ]: 0 : if ( IsPaintLocked() )
259 : 0 : return;
260 : :
261 : 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
262 [ # # ]: 0 : if (pViewShell)
263 : : {
264 [ # # ]: 0 : ShowTable( aBlockRange ); // bei mehreren Tabs im Range ist jede davon gut
265 : 0 : pViewShell->MoveCursorAbs( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
266 [ # # ]: 0 : SC_FOLLOW_JUMP, false, false );
267 : 0 : SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
268 : 0 : ScRange aRange = aBlockRange;
269 : 0 : aRange.aStart.SetTab( nTab );
270 : 0 : aRange.aEnd.SetTab( nTab );
271 [ # # ]: 0 : pViewShell->MarkRange( aRange );
272 : :
273 : : // nicht per SetMarkArea an MarkData, wegen evtl. fehlendem Paint
274 : : }
275 : : }
276 : :
277 : 35 : ScMultiBlockUndo::ScMultiBlockUndo(
278 : : ScDocShell* pDocSh, const ScRangeList& rRanges, ScBlockUndoMode eBlockMode) :
279 : : ScSimpleUndo(pDocSh),
280 : : maBlockRanges(rRanges),
281 [ + - ]: 35 : meMode(eBlockMode)
282 : : {
283 [ + - ]: 35 : mpDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
284 : 35 : }
285 : :
286 [ + - ]: 32 : ScMultiBlockUndo::~ScMultiBlockUndo()
287 : : {
288 [ + - ]: 32 : DeleteSdrUndoAction( mpDrawUndo );
289 [ - + ]: 32 : }
290 : :
291 : 3 : void ScMultiBlockUndo::BeginUndo()
292 : : {
293 : 3 : ScSimpleUndo::BeginUndo();
294 : 3 : EnableDrawAdjust(pDocShell->GetDocument(), false);
295 : 3 : }
296 : :
297 : 3 : void ScMultiBlockUndo::EndUndo()
298 : : {
299 [ - + ]: 3 : if (meMode == SC_UNDO_AUTOHEIGHT)
300 : 0 : AdjustHeight();
301 : :
302 : 3 : EnableDrawAdjust(pDocShell->GetDocument(), true);
303 : 3 : DoSdrUndoAction(mpDrawUndo, pDocShell->GetDocument());
304 : :
305 : 3 : ShowBlock();
306 : 3 : ScSimpleUndo::EndUndo();
307 : 3 : }
308 : :
309 : 3 : void ScMultiBlockUndo::EndRedo()
310 : : {
311 [ - + ]: 3 : if (meMode == SC_UNDO_AUTOHEIGHT)
312 : 0 : AdjustHeight();
313 : :
314 : 3 : ShowBlock();
315 : 3 : ScSimpleUndo::EndRedo();
316 : 3 : }
317 : :
318 : 0 : void ScMultiBlockUndo::AdjustHeight()
319 : : {
320 : 0 : ScDocument* pDoc = pDocShell->GetDocument();
321 : :
322 [ # # ]: 0 : VirtualDevice aVirtDev;
323 [ # # ]: 0 : Fraction aZoomX( 1, 1 );
324 [ # # ]: 0 : Fraction aZoomY = aZoomX;
325 : : double nPPTX, nPPTY;
326 [ # # ]: 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
327 [ # # ]: 0 : if (pViewShell)
328 : : {
329 : 0 : ScViewData* pData = pViewShell->GetViewData();
330 : 0 : nPPTX = pData->GetPPTX();
331 : 0 : nPPTY = pData->GetPPTY();
332 [ # # ]: 0 : aZoomX = pData->GetZoomX();
333 [ # # ]: 0 : aZoomY = pData->GetZoomY();
334 : : }
335 : : else
336 : : {
337 : : // Zoom auf 100 lassen
338 : 0 : nPPTX = ScGlobal::nScreenPPTX;
339 : 0 : nPPTY = ScGlobal::nScreenPPTY;
340 : : }
341 : :
342 [ # # ][ # # ]: 0 : for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
343 : : {
344 [ # # ]: 0 : const ScRange& r = *maBlockRanges[i];
345 : : bool bRet = pDoc->SetOptimalHeight(
346 : 0 : r.aStart.Row(), r.aEnd.Row(), r.aStart.Tab(), 0, &aVirtDev,
347 [ # # ]: 0 : nPPTX, nPPTY, aZoomX, aZoomY, false);
348 : :
349 [ # # ]: 0 : if (bRet)
350 : : pDocShell->PostPaint(
351 : 0 : 0, r.aStart.Row(), r.aStart.Tab(), MAXCOL, MAXROW, r.aEnd.Tab(),
352 [ # # ]: 0 : PAINT_GRID | PAINT_LEFT);
353 [ # # ]: 0 : }
354 : 0 : }
355 : :
356 : 6 : void ScMultiBlockUndo::ShowBlock()
357 : : {
358 [ + - ]: 6 : if ( IsPaintLocked() )
359 : : return;
360 : :
361 [ + - ]: 6 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
362 [ - + ]: 6 : if (!pViewShell)
363 : : return;
364 : :
365 [ # # ][ # # ]: 0 : if (maBlockRanges.empty())
366 : : return;
367 : :
368 : : // Move to the sheet of the first range.
369 [ # # ]: 0 : ScRange aRange = *maBlockRanges.front();
370 [ # # ]: 0 : ShowTable(aRange);
371 : : pViewShell->MoveCursorAbs(
372 [ # # ]: 0 : aRange.aStart.Col(), aRange.aStart.Row(), SC_FOLLOW_JUMP, false, false);
373 : 0 : SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
374 : 0 : aRange.aStart.SetTab(nTab);
375 : 0 : aRange.aEnd.SetTab(nTab);
376 [ # # ]: 0 : pViewShell->MarkRange(aRange, false, false);
377 : :
378 [ # # ][ # # ]: 6 : for (size_t i = 1, n = maBlockRanges.size(); i < n; ++i)
379 : : {
380 [ # # ]: 0 : aRange = *maBlockRanges[i];
381 : 0 : aRange.aStart.SetTab(nTab);
382 : 0 : aRange.aEnd.SetTab(nTab);
383 [ # # ]: 0 : pViewShell->MarkRange(aRange, false, true);
384 : : }
385 : : }
386 : :
387 : : // -----------------------------------------------------------------------
388 : :
389 : 30 : ScMoveUndo::ScMoveUndo( ScDocShell* pDocSh, ScDocument* pRefDoc, ScRefUndoData* pRefData,
390 : : ScMoveUndoMode eRefMode ) :
391 : : ScSimpleUndo( pDocSh ),
392 : : pRefUndoDoc( pRefDoc ),
393 : : pRefUndoData( pRefData ),
394 : 30 : eMode( eRefMode )
395 : : {
396 : 30 : ScDocument* pDoc = pDocShell->GetDocument();
397 [ + - ]: 30 : if (pRefUndoData)
398 [ + - ]: 30 : pRefUndoData->DeleteUnchanged(pDoc);
399 [ + - ]: 30 : pDrawUndo = GetSdrUndoAction( pDoc );
400 : 30 : }
401 : :
402 : 27 : ScMoveUndo::~ScMoveUndo()
403 : : {
404 [ + - ][ + - ]: 27 : delete pRefUndoData;
405 [ + - ][ + - ]: 27 : delete pRefUndoDoc;
406 [ + - ]: 27 : DeleteSdrUndoAction( pDrawUndo );
407 [ - + ]: 27 : }
408 : :
409 : 0 : void ScMoveUndo::UndoRef()
410 : : {
411 : 0 : ScDocument* pDoc = pDocShell->GetDocument();
412 [ # # ]: 0 : ScRange aRange(0,0,0, MAXCOL,MAXROW,pRefUndoDoc->GetTableCount()-1);
413 [ # # ]: 0 : pRefUndoDoc->CopyToDocument( aRange, IDF_FORMULA, false, pDoc, NULL, false );
414 [ # # ]: 0 : if (pRefUndoData)
415 [ # # ]: 0 : pRefUndoData->DoUndo( pDoc, (eMode == SC_UNDO_REFFIRST) );
416 : : // HACK: ScDragDropUndo ist der einzige mit REFFIRST.
417 : : // Falls nicht, resultiert daraus evtl. ein zu haeufiges Anpassen
418 : : // der ChartRefs, nicht schoen, aber auch nicht schlecht..
419 : 0 : }
420 : :
421 : 0 : void ScMoveUndo::BeginUndo()
422 : : {
423 : 0 : ScSimpleUndo::BeginUndo();
424 : :
425 : 0 : EnableDrawAdjust( pDocShell->GetDocument(), false );
426 : :
427 [ # # ][ # # ]: 0 : if (pRefUndoDoc && eMode == SC_UNDO_REFFIRST)
428 : 0 : UndoRef();
429 : 0 : }
430 : :
431 : 0 : void ScMoveUndo::EndUndo()
432 : : {
433 : 0 : DoSdrUndoAction( pDrawUndo, pDocShell->GetDocument() ); // must also be called when pointer is null
434 : :
435 [ # # ][ # # ]: 0 : if (pRefUndoDoc && eMode == SC_UNDO_REFLAST)
436 : 0 : UndoRef();
437 : :
438 : 0 : EnableDrawAdjust( pDocShell->GetDocument(), sal_True );
439 : :
440 : 0 : ScSimpleUndo::EndUndo();
441 : 0 : }
442 : :
443 : : // -----------------------------------------------------------------------
444 : :
445 : 14 : ScDBFuncUndo::ScDBFuncUndo( ScDocShell* pDocSh, const ScRange& rOriginal, SdrUndoAction* pDrawUndo ) :
446 : : ScSimpleUndo( pDocSh ),
447 : : aOriginalRange( rOriginal ),
448 : 14 : mpDrawUndo( pDrawUndo )
449 : : {
450 [ + - ]: 14 : pAutoDBRange = pDocSh->GetOldAutoDBRange();
451 : 14 : }
452 : :
453 : 14 : ScDBFuncUndo::~ScDBFuncUndo()
454 : : {
455 [ + - ]: 14 : DeleteSdrUndoAction( mpDrawUndo );
456 [ + + ][ + - ]: 14 : delete pAutoDBRange;
457 [ - + ]: 14 : }
458 : :
459 : 8 : void ScDBFuncUndo::SetDrawUndoAction( SdrUndoAction* pDrawUndo )
460 : : {
461 : 8 : DeleteSdrUndoAction( mpDrawUndo );
462 : 8 : mpDrawUndo = pDrawUndo;
463 : 8 : }
464 : :
465 : 0 : void ScDBFuncUndo::BeginUndo()
466 : : {
467 : 0 : ScSimpleUndo::BeginUndo();
468 : 0 : DoSdrUndoAction( mpDrawUndo, pDocShell->GetDocument() );
469 : 0 : }
470 : :
471 : 0 : void ScDBFuncUndo::EndUndo()
472 : : {
473 : 0 : ScSimpleUndo::EndUndo();
474 : :
475 [ # # ]: 0 : if ( pAutoDBRange )
476 : : {
477 : 0 : ScDocument* pDoc = pDocShell->GetDocument();
478 : 0 : SCTAB nTab = pDoc->GetVisibleTab();
479 : 0 : ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
480 [ # # ]: 0 : if (pNoNameData )
481 : : {
482 : : SCCOL nRangeX1;
483 : : SCROW nRangeY1;
484 : : SCCOL nRangeX2;
485 : : SCROW nRangeY2;
486 : : SCTAB nRangeTab;
487 [ # # ]: 0 : pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
488 [ # # ]: 0 : pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
489 : :
490 [ # # ]: 0 : *pNoNameData = *pAutoDBRange;
491 : :
492 [ # # ]: 0 : if ( pAutoDBRange->HasAutoFilter() )
493 : : {
494 : : // restore AutoFilter buttons
495 [ # # ]: 0 : pAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
496 [ # # ]: 0 : pDoc->ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
497 [ # # ]: 0 : pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
498 : : }
499 : : }
500 : : }
501 : 0 : }
502 : :
503 : 0 : void ScDBFuncUndo::BeginRedo()
504 : : {
505 : 0 : RedoSdrUndoAction( mpDrawUndo );
506 [ # # ]: 0 : if ( pAutoDBRange )
507 : : {
508 : : // move the database range to this function's position again (see ScDocShell::GetDBData)
509 : :
510 : 0 : ScDocument* pDoc = pDocShell->GetDocument();
511 : 0 : ScDBData* pNoNameData = pDoc->GetAnonymousDBData(aOriginalRange.aStart.Tab());
512 [ # # ]: 0 : if ( pNoNameData )
513 : : {
514 : :
515 : : SCCOL nRangeX1;
516 : : SCROW nRangeY1;
517 : : SCCOL nRangeX2;
518 : : SCROW nRangeY2;
519 : : SCTAB nRangeTab;
520 [ # # ]: 0 : pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
521 [ # # ]: 0 : pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
522 : :
523 [ # # ][ # # ]: 0 : pNoNameData->SetSortParam( ScSortParam() );
[ # # ]
524 [ # # ][ # # ]: 0 : pNoNameData->SetQueryParam( ScQueryParam() );
[ # # ]
525 [ # # ][ # # ]: 0 : pNoNameData->SetSubTotalParam( ScSubTotalParam() );
526 : :
527 : 0 : pNoNameData->SetArea( aOriginalRange.aStart.Tab(),
528 : 0 : aOriginalRange.aStart.Col(), aOriginalRange.aStart.Row(),
529 [ # # ]: 0 : aOriginalRange.aEnd.Col(), aOriginalRange.aEnd.Row() );
530 : :
531 : 0 : pNoNameData->SetByRow( sal_True );
532 : 0 : pNoNameData->SetAutoFilter( false );
533 : : // header is always set with the operation in redo
534 : : }
535 : : }
536 : :
537 : 0 : ScSimpleUndo::BeginRedo();
538 : 0 : }
539 : :
540 : 0 : void ScDBFuncUndo::EndRedo()
541 : : {
542 : 0 : ScSimpleUndo::EndRedo();
543 : 0 : }
544 : :
545 : : // -----------------------------------------------------------------------
546 : :
547 : 0 : ScUndoWrapper::ScUndoWrapper( SfxUndoAction* pUndo ) :
548 : 0 : pWrappedUndo( pUndo )
549 : : {
550 : 0 : }
551 : :
552 : 0 : ScUndoWrapper::~ScUndoWrapper()
553 : : {
554 [ # # ][ # # ]: 0 : delete pWrappedUndo;
555 [ # # ]: 0 : }
556 : :
557 : 0 : void ScUndoWrapper::ForgetWrappedUndo()
558 : : {
559 : 0 : pWrappedUndo = NULL; // don't delete in dtor - pointer must be stored outside
560 : 0 : }
561 : :
562 : 0 : rtl::OUString ScUndoWrapper::GetComment() const
563 : : {
564 [ # # ]: 0 : if (pWrappedUndo)
565 : 0 : return pWrappedUndo->GetComment();
566 : 0 : return rtl::OUString();
567 : : }
568 : :
569 : 0 : String ScUndoWrapper::GetRepeatComment(SfxRepeatTarget& rTarget) const
570 : : {
571 [ # # ]: 0 : if (pWrappedUndo)
572 : 0 : return pWrappedUndo->GetRepeatComment(rTarget);
573 : : else
574 : 0 : return String();
575 : : }
576 : :
577 : 0 : sal_uInt16 ScUndoWrapper::GetId() const
578 : : {
579 [ # # ]: 0 : if (pWrappedUndo)
580 : 0 : return pWrappedUndo->GetId();
581 : : else
582 : 0 : return 0;
583 : : }
584 : :
585 : 0 : sal_Bool ScUndoWrapper::IsLinked()
586 : : {
587 [ # # ]: 0 : if (pWrappedUndo)
588 : 0 : return pWrappedUndo->IsLinked();
589 : : else
590 : 0 : return false;
591 : : }
592 : :
593 : 0 : void ScUndoWrapper::SetLinked( sal_Bool bIsLinked )
594 : : {
595 [ # # ]: 0 : if (pWrappedUndo)
596 : 0 : pWrappedUndo->SetLinked(bIsLinked);
597 : 0 : }
598 : :
599 : 0 : sal_Bool ScUndoWrapper::Merge( SfxUndoAction* pNextAction )
600 : : {
601 [ # # ]: 0 : if (pWrappedUndo)
602 : 0 : return pWrappedUndo->Merge(pNextAction);
603 : : else
604 : 0 : return false;
605 : : }
606 : :
607 : 0 : void ScUndoWrapper::Undo()
608 : : {
609 [ # # ]: 0 : if (pWrappedUndo)
610 : 0 : pWrappedUndo->Undo();
611 : 0 : }
612 : :
613 : 0 : void ScUndoWrapper::Redo()
614 : : {
615 [ # # ]: 0 : if (pWrappedUndo)
616 : 0 : pWrappedUndo->Redo();
617 : 0 : }
618 : :
619 : 0 : void ScUndoWrapper::Repeat(SfxRepeatTarget& rTarget)
620 : : {
621 [ # # ]: 0 : if (pWrappedUndo)
622 : 0 : pWrappedUndo->Repeat(rTarget);
623 : 0 : }
624 : :
625 : 0 : sal_Bool ScUndoWrapper::CanRepeat(SfxRepeatTarget& rTarget) const
626 : : {
627 [ # # ]: 0 : if (pWrappedUndo)
628 : 0 : return pWrappedUndo->CanRepeat(rTarget);
629 : : else
630 : 0 : return false;
631 : : }
632 : :
633 : :
634 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
