Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <vcl/virdev.hxx>
21 :
22 : #include "undobase.hxx"
23 : #include "refundo.hxx"
24 : #include "docsh.hxx"
25 : #include "tabvwsh.hxx"
26 : #include "undoolk.hxx"
27 : #include "undodraw.hxx"
28 : #include "dbdata.hxx"
29 : #include "attrib.hxx"
30 : #include "queryparam.hxx"
31 : #include "subtotalparam.hxx"
32 : #include "bcaslot.hxx"
33 : #include "globstr.hrc"
34 : #include <rowheightcontext.hxx>
35 : #include <column.hxx>
36 : #include <sortparam.hxx>
37 :
38 0 : TYPEINIT1(ScSimpleUndo, SfxUndoAction);
39 0 : TYPEINIT1(ScBlockUndo, ScSimpleUndo);
40 0 : TYPEINIT1(ScMultiBlockUndo, ScSimpleUndo);
41 0 : TYPEINIT1(ScMoveUndo, ScSimpleUndo);
42 0 : TYPEINIT1(ScDBFuncUndo, ScSimpleUndo);
43 0 : TYPEINIT1(ScUndoWrapper, SfxUndoAction);
44 :
45 7347 : ScSimpleUndo::ScSimpleUndo( ScDocShell* pDocSh ) :
46 : pDocShell( pDocSh ),
47 7347 : pDetectiveUndo( NULL )
48 : {
49 7347 : }
50 :
51 14690 : ScSimpleUndo::~ScSimpleUndo()
52 : {
53 7345 : delete pDetectiveUndo;
54 7345 : }
55 :
56 5 : bool ScSimpleUndo::SetViewMarkData( const ScMarkData& rMarkData )
57 : {
58 5 : if ( IsPaintLocked() )
59 0 : return false;
60 :
61 5 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
62 5 : if ( !pViewShell )
63 5 : return false;
64 :
65 0 : pViewShell->SetMarkData( rMarkData );
66 0 : return true;
67 : }
68 :
69 3 : bool ScSimpleUndo::Merge( SfxUndoAction *pNextAction )
70 : {
71 : // A SdrUndoGroup for updating detective arrows can belong
72 : // to each Undo-Action.
73 : // DetectiveRefresh is always called next,
74 : // the SdrUndoGroup is encapsulated in a ScUndoDraw action.
75 : // AddUndoAction is only called with bTryMerg=sal_True
76 : // for automatic update.
77 :
78 3 : if ( !pDetectiveUndo && pNextAction->ISA(ScUndoDraw) )
79 : {
80 : // Take SdrUndoAction from ScUndoDraw Action,
81 : // ScUndoDraw is later deleted by the UndoManager
82 :
83 3 : ScUndoDraw* pCalcUndo = static_cast<ScUndoDraw*>(pNextAction);
84 3 : pDetectiveUndo = pCalcUndo->GetDrawUndo();
85 3 : pCalcUndo->ForgetDrawUndo();
86 3 : return true;
87 : }
88 :
89 0 : return false;
90 : }
91 :
92 61 : void ScSimpleUndo::BeginUndo()
93 : {
94 61 : pDocShell->SetInUndo( true );
95 :
96 61 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
97 61 : if (pViewShell)
98 0 : pViewShell->HideAllCursors(); // for example due to merged cells
99 :
100 : // detective updates happened last, must be undone first
101 61 : if (pDetectiveUndo)
102 0 : pDetectiveUndo->Undo();
103 61 : }
104 :
105 61 : void ScSimpleUndo::EndUndo()
106 : {
107 61 : pDocShell->SetDocumentModified();
108 :
109 61 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
110 61 : if (pViewShell)
111 : {
112 0 : pViewShell->UpdateAutoFillMark();
113 0 : pViewShell->UpdateInputHandler();
114 0 : pViewShell->ShowAllCursors();
115 : }
116 :
117 61 : pDocShell->SetInUndo( false );
118 61 : }
119 :
120 24 : void ScSimpleUndo::BeginRedo()
121 : {
122 24 : pDocShell->SetInUndo( true ); //! own Flag for Redo?
123 :
124 24 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
125 24 : if (pViewShell)
126 0 : pViewShell->HideAllCursors(); // for example due to merged cells
127 24 : }
128 :
129 24 : void ScSimpleUndo::EndRedo()
130 : {
131 24 : if (pDetectiveUndo)
132 0 : pDetectiveUndo->Redo();
133 :
134 24 : pDocShell->SetDocumentModified();
135 :
136 24 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
137 24 : if (pViewShell)
138 : {
139 0 : pViewShell->UpdateAutoFillMark();
140 0 : pViewShell->UpdateInputHandler();
141 0 : pViewShell->ShowAllCursors();
142 : }
143 :
144 24 : pDocShell->SetInUndo( false );
145 24 : }
146 :
147 4 : void ScSimpleUndo::BroadcastChanges( const ScRange& rRange )
148 : {
149 4 : ScDocument& rDoc = pDocShell->GetDocument();
150 4 : rDoc.BroadcastCells(rRange, SC_HINT_DATACHANGED);
151 4 : }
152 :
153 : namespace {
154 :
155 3 : class SpanBroadcaster : public sc::ColumnSpanSet::ColumnAction
156 : {
157 : ScDocument& mrDoc;
158 : SCTAB mnCurTab;
159 : SCCOL mnCurCol;
160 :
161 : public:
162 3 : SpanBroadcaster( ScDocument& rDoc ) : mrDoc(rDoc), mnCurTab(-1), mnCurCol(-1) {}
163 :
164 3 : virtual void startColumn( ScColumn* pCol ) SAL_OVERRIDE
165 : {
166 3 : mnCurTab = pCol->GetTab();
167 3 : mnCurCol = pCol->GetCol();
168 3 : }
169 :
170 9 : virtual void execute( SCROW nRow1, SCROW nRow2, bool bVal ) SAL_OVERRIDE
171 : {
172 9 : if (!bVal)
173 15 : return;
174 :
175 3 : ScRange aRange(mnCurCol, nRow1, mnCurTab, mnCurCol, nRow2, mnCurTab);
176 3 : mrDoc.BroadcastCells(aRange, SC_HINT_DATACHANGED);
177 : };
178 : };
179 :
180 : }
181 :
182 3 : void ScSimpleUndo::BroadcastChanges( const DataSpansType& rSpans )
183 : {
184 3 : ScDocument& rDoc = pDocShell->GetDocument();
185 3 : SpanBroadcaster aBroadcaster(rDoc);
186 :
187 3 : DataSpansType::const_iterator it = rSpans.begin(), itEnd = rSpans.end();
188 6 : for (; it != itEnd; ++it)
189 : {
190 3 : const sc::ColumnSpanSet& rSet = *it->second;
191 3 : rSet.executeColumnAction(rDoc, aBroadcaster);
192 3 : }
193 3 : }
194 :
195 2 : void ScSimpleUndo::ShowTable( SCTAB nTab )
196 : {
197 2 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
198 2 : if (pViewShell)
199 0 : pViewShell->SetTabNo( nTab );
200 2 : }
201 :
202 10 : void ScSimpleUndo::ShowTable( const ScRange& rRange )
203 : {
204 10 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
205 10 : if (pViewShell)
206 : {
207 0 : SCTAB nStart = rRange.aStart.Tab();
208 0 : SCTAB nEnd = rRange.aEnd.Tab();
209 0 : SCTAB nTab = pViewShell->GetViewData().GetTabNo();
210 0 : if ( nTab < nStart || nTab > nEnd ) // if not in range:
211 0 : pViewShell->SetTabNo( nStart ); // at beginning of the range
212 : }
213 10 : }
214 :
215 41 : ScBlockUndo::ScBlockUndo( ScDocShell* pDocSh, const ScRange& rRange,
216 : ScBlockUndoMode eBlockMode ) :
217 : ScSimpleUndo( pDocSh ),
218 : aBlockRange( rRange ),
219 41 : eMode( eBlockMode )
220 : {
221 41 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
222 41 : }
223 :
224 82 : ScBlockUndo::~ScBlockUndo()
225 : {
226 41 : DeleteSdrUndoAction( pDrawUndo );
227 41 : }
228 :
229 4 : void ScBlockUndo::BeginUndo()
230 : {
231 4 : ScSimpleUndo::BeginUndo();
232 4 : EnableDrawAdjust( &pDocShell->GetDocument(), false );
233 4 : }
234 :
235 4 : void ScBlockUndo::EndUndo()
236 : {
237 4 : if (eMode == SC_UNDO_AUTOHEIGHT)
238 4 : AdjustHeight();
239 :
240 4 : EnableDrawAdjust( &pDocShell->GetDocument(), true );
241 4 : DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() );
242 :
243 4 : ShowBlock();
244 4 : ScSimpleUndo::EndUndo();
245 4 : }
246 :
247 3 : void ScBlockUndo::EndRedo()
248 : {
249 3 : if (eMode == SC_UNDO_AUTOHEIGHT)
250 3 : AdjustHeight();
251 :
252 3 : ShowBlock();
253 3 : ScSimpleUndo::EndRedo();
254 3 : }
255 :
256 7 : bool ScBlockUndo::AdjustHeight()
257 : {
258 7 : ScDocument& rDoc = pDocShell->GetDocument();
259 :
260 7 : ScopedVclPtrInstance< VirtualDevice > pVirtDev;
261 14 : Fraction aZoomX( 1, 1 );
262 14 : Fraction aZoomY = aZoomX;
263 : double nPPTX, nPPTY;
264 7 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
265 7 : if (pViewShell)
266 : {
267 0 : ScViewData& rData = pViewShell->GetViewData();
268 0 : nPPTX = rData.GetPPTX();
269 0 : nPPTY = rData.GetPPTY();
270 0 : aZoomX = rData.GetZoomX();
271 0 : aZoomY = rData.GetZoomY();
272 : }
273 : else
274 : {
275 : // Leave zoom at 100
276 7 : nPPTX = ScGlobal::nScreenPPTX;
277 7 : nPPTY = ScGlobal::nScreenPPTY;
278 : }
279 :
280 14 : sc::RowHeightContext aCxt(nPPTX, nPPTY, aZoomX, aZoomY, pVirtDev);
281 : bool bRet = rDoc.SetOptimalHeight(
282 7 : aCxt, aBlockRange.aStart.Row(), aBlockRange.aEnd.Row(), aBlockRange.aStart.Tab());
283 :
284 7 : if (bRet)
285 0 : pDocShell->PostPaint( 0, aBlockRange.aStart.Row(), aBlockRange.aStart.Tab(),
286 0 : MAXCOL, MAXROW, aBlockRange.aEnd.Tab(),
287 0 : PAINT_GRID | PAINT_LEFT );
288 :
289 14 : return bRet;
290 : }
291 :
292 7 : void ScBlockUndo::ShowBlock()
293 : {
294 7 : if ( IsPaintLocked() )
295 7 : return;
296 :
297 7 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
298 7 : if (pViewShell)
299 : {
300 0 : ShowTable( aBlockRange ); // with multiple sheets in range each of them is good
301 0 : pViewShell->MoveCursorAbs( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
302 0 : SC_FOLLOW_JUMP, false, false );
303 0 : SCTAB nTab = pViewShell->GetViewData().GetTabNo();
304 0 : ScRange aRange = aBlockRange;
305 0 : aRange.aStart.SetTab( nTab );
306 0 : aRange.aEnd.SetTab( nTab );
307 0 : pViewShell->MarkRange( aRange );
308 :
309 : // not through SetMarkArea to MarkData, due to possibly lacking paint
310 : }
311 : }
312 :
313 32 : ScMultiBlockUndo::ScMultiBlockUndo(
314 : ScDocShell* pDocSh, const ScRangeList& rRanges, ScBlockUndoMode eBlockMode) :
315 : ScSimpleUndo(pDocSh),
316 : maBlockRanges(rRanges),
317 32 : meMode(eBlockMode)
318 : {
319 32 : mpDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
320 32 : }
321 :
322 64 : ScMultiBlockUndo::~ScMultiBlockUndo()
323 : {
324 32 : DeleteSdrUndoAction( mpDrawUndo );
325 32 : }
326 :
327 5 : void ScMultiBlockUndo::BeginUndo()
328 : {
329 5 : ScSimpleUndo::BeginUndo();
330 5 : EnableDrawAdjust(&pDocShell->GetDocument(), false);
331 5 : }
332 :
333 5 : void ScMultiBlockUndo::EndUndo()
334 : {
335 5 : if (meMode == SC_UNDO_AUTOHEIGHT)
336 0 : AdjustHeight();
337 :
338 5 : EnableDrawAdjust(&pDocShell->GetDocument(), true);
339 5 : DoSdrUndoAction(mpDrawUndo, &pDocShell->GetDocument());
340 :
341 5 : ShowBlock();
342 5 : ScSimpleUndo::EndUndo();
343 5 : }
344 :
345 3 : void ScMultiBlockUndo::EndRedo()
346 : {
347 3 : if (meMode == SC_UNDO_AUTOHEIGHT)
348 0 : AdjustHeight();
349 :
350 3 : ShowBlock();
351 3 : ScSimpleUndo::EndRedo();
352 3 : }
353 :
354 0 : void ScMultiBlockUndo::AdjustHeight()
355 : {
356 0 : ScDocument& rDoc = pDocShell->GetDocument();
357 :
358 0 : ScopedVclPtrInstance< VirtualDevice > pVirtDev;
359 0 : Fraction aZoomX( 1, 1 );
360 0 : Fraction aZoomY = aZoomX;
361 : double nPPTX, nPPTY;
362 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
363 0 : if (pViewShell)
364 : {
365 0 : ScViewData& rData = pViewShell->GetViewData();
366 0 : nPPTX = rData.GetPPTX();
367 0 : nPPTY = rData.GetPPTY();
368 0 : aZoomX = rData.GetZoomX();
369 0 : aZoomY = rData.GetZoomY();
370 : }
371 : else
372 : {
373 : // Leave zoom at 100
374 0 : nPPTX = ScGlobal::nScreenPPTX;
375 0 : nPPTY = ScGlobal::nScreenPPTY;
376 : }
377 :
378 0 : sc::RowHeightContext aCxt(nPPTX, nPPTY, aZoomX, aZoomY, pVirtDev);
379 0 : for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
380 : {
381 0 : const ScRange& r = *maBlockRanges[i];
382 0 : bool bRet = rDoc.SetOptimalHeight(aCxt, r.aStart.Row(), r.aEnd.Row(), r.aStart.Tab());
383 :
384 0 : if (bRet)
385 : pDocShell->PostPaint(
386 0 : 0, r.aStart.Row(), r.aStart.Tab(), MAXCOL, MAXROW, r.aEnd.Tab(),
387 0 : PAINT_GRID | PAINT_LEFT);
388 0 : }
389 0 : }
390 :
391 8 : void ScMultiBlockUndo::ShowBlock()
392 : {
393 8 : if ( IsPaintLocked() )
394 8 : return;
395 :
396 8 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
397 8 : if (!pViewShell)
398 8 : return;
399 :
400 0 : if (maBlockRanges.empty())
401 0 : return;
402 :
403 : // Move to the sheet of the first range.
404 0 : ScRange aRange = *maBlockRanges.front();
405 0 : ShowTable(aRange);
406 : pViewShell->MoveCursorAbs(
407 0 : aRange.aStart.Col(), aRange.aStart.Row(), SC_FOLLOW_JUMP, false, false);
408 0 : SCTAB nTab = pViewShell->GetViewData().GetTabNo();
409 0 : aRange.aStart.SetTab(nTab);
410 0 : aRange.aEnd.SetTab(nTab);
411 0 : pViewShell->MarkRange(aRange, false, false);
412 :
413 0 : for (size_t i = 1, n = maBlockRanges.size(); i < n; ++i)
414 : {
415 0 : aRange = *maBlockRanges[i];
416 0 : aRange.aStart.SetTab(nTab);
417 0 : aRange.aEnd.SetTab(nTab);
418 0 : pViewShell->MarkRange(aRange, false, true);
419 : }
420 : }
421 :
422 72 : ScMoveUndo::ScMoveUndo( ScDocShell* pDocSh, ScDocument* pRefDoc, ScRefUndoData* pRefData,
423 : ScMoveUndoMode eRefMode ) :
424 : ScSimpleUndo( pDocSh ),
425 : pRefUndoDoc( pRefDoc ),
426 : pRefUndoData( pRefData ),
427 72 : eMode( eRefMode )
428 : {
429 72 : ScDocument& rDoc = pDocShell->GetDocument();
430 72 : if (pRefUndoData)
431 60 : pRefUndoData->DeleteUnchanged(&rDoc);
432 72 : pDrawUndo = GetSdrUndoAction( &rDoc );
433 72 : }
434 :
435 144 : ScMoveUndo::~ScMoveUndo()
436 : {
437 72 : delete pRefUndoData;
438 72 : delete pRefUndoDoc;
439 72 : DeleteSdrUndoAction( pDrawUndo );
440 72 : }
441 :
442 33 : void ScMoveUndo::UndoRef()
443 : {
444 33 : ScDocument& rDoc = pDocShell->GetDocument();
445 33 : ScRange aRange(0,0,0, MAXCOL,MAXROW,pRefUndoDoc->GetTableCount()-1);
446 33 : pRefUndoDoc->CopyToDocument( aRange, IDF_FORMULA, false, &rDoc, NULL, false );
447 33 : if (pRefUndoData)
448 26 : pRefUndoData->DoUndo( &rDoc, (eMode == SC_UNDO_REFFIRST) );
449 : // HACK: ScDragDropUndo is the only one with REFFIRST.
450 : // If not, results possibly in a too frequent adjustment
451 : // of ChartRefs. Not that pretty, but not too bad either..
452 33 : }
453 :
454 33 : void ScMoveUndo::BeginUndo()
455 : {
456 33 : ScSimpleUndo::BeginUndo();
457 :
458 33 : EnableDrawAdjust( &pDocShell->GetDocument(), false );
459 :
460 33 : if (pRefUndoDoc && eMode == SC_UNDO_REFFIRST)
461 7 : UndoRef();
462 33 : }
463 :
464 33 : void ScMoveUndo::EndUndo()
465 : {
466 33 : DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() ); // must also be called when pointer is null
467 :
468 33 : if (pRefUndoDoc && eMode == SC_UNDO_REFLAST)
469 26 : UndoRef();
470 :
471 33 : EnableDrawAdjust( &pDocShell->GetDocument(), true );
472 :
473 33 : ScSimpleUndo::EndUndo();
474 33 : }
475 :
476 6 : ScDBFuncUndo::ScDBFuncUndo( ScDocShell* pDocSh, const ScRange& rOriginal, SdrUndoAction* pDrawUndo ) :
477 : ScSimpleUndo( pDocSh ),
478 : aOriginalRange( rOriginal ),
479 6 : mpDrawUndo( pDrawUndo )
480 : {
481 6 : pAutoDBRange = pDocSh->GetOldAutoDBRange();
482 6 : }
483 :
484 12 : ScDBFuncUndo::~ScDBFuncUndo()
485 : {
486 6 : DeleteSdrUndoAction( mpDrawUndo );
487 6 : delete pAutoDBRange;
488 6 : }
489 :
490 0 : void ScDBFuncUndo::BeginUndo()
491 : {
492 0 : ScSimpleUndo::BeginUndo();
493 0 : DoSdrUndoAction( mpDrawUndo, &pDocShell->GetDocument() );
494 0 : }
495 :
496 0 : void ScDBFuncUndo::EndUndo()
497 : {
498 0 : ScSimpleUndo::EndUndo();
499 :
500 0 : if ( pAutoDBRange )
501 : {
502 0 : ScDocument& rDoc = pDocShell->GetDocument();
503 0 : SCTAB nTab = rDoc.GetVisibleTab();
504 0 : ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab);
505 0 : if (pNoNameData )
506 : {
507 : SCCOL nRangeX1;
508 : SCROW nRangeY1;
509 : SCCOL nRangeX2;
510 : SCROW nRangeY2;
511 : SCTAB nRangeTab;
512 0 : pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
513 0 : pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
514 :
515 0 : *pNoNameData = *pAutoDBRange;
516 :
517 0 : if ( pAutoDBRange->HasAutoFilter() )
518 : {
519 : // restore AutoFilter buttons
520 0 : pAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
521 0 : rDoc.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
522 0 : pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
523 : }
524 : }
525 : }
526 0 : }
527 :
528 0 : void ScDBFuncUndo::BeginRedo()
529 : {
530 0 : RedoSdrUndoAction( mpDrawUndo );
531 0 : if ( pAutoDBRange )
532 : {
533 : // move the database range to this function's position again (see ScDocShell::GetDBData)
534 :
535 0 : ScDocument& rDoc = pDocShell->GetDocument();
536 0 : ScDBData* pNoNameData = rDoc.GetAnonymousDBData(aOriginalRange.aStart.Tab());
537 0 : if ( pNoNameData )
538 : {
539 :
540 : SCCOL nRangeX1;
541 : SCROW nRangeY1;
542 : SCCOL nRangeX2;
543 : SCROW nRangeY2;
544 : SCTAB nRangeTab;
545 0 : pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
546 0 : pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
547 :
548 0 : pNoNameData->SetSortParam( ScSortParam() );
549 0 : pNoNameData->SetQueryParam( ScQueryParam() );
550 0 : pNoNameData->SetSubTotalParam( ScSubTotalParam() );
551 :
552 0 : pNoNameData->SetArea( aOriginalRange.aStart.Tab(),
553 0 : aOriginalRange.aStart.Col(), aOriginalRange.aStart.Row(),
554 0 : aOriginalRange.aEnd.Col(), aOriginalRange.aEnd.Row() );
555 :
556 0 : pNoNameData->SetByRow( true );
557 0 : pNoNameData->SetAutoFilter( false );
558 : // header is always set with the operation in redo
559 : }
560 : }
561 :
562 0 : ScSimpleUndo::BeginRedo();
563 0 : }
564 :
565 0 : void ScDBFuncUndo::EndRedo()
566 : {
567 0 : ScSimpleUndo::EndRedo();
568 0 : }
569 :
570 0 : ScUndoWrapper::ScUndoWrapper( SfxUndoAction* pUndo ) :
571 0 : pWrappedUndo( pUndo )
572 : {
573 0 : }
574 :
575 0 : ScUndoWrapper::~ScUndoWrapper()
576 : {
577 0 : delete pWrappedUndo;
578 0 : }
579 :
580 0 : void ScUndoWrapper::ForgetWrappedUndo()
581 : {
582 0 : pWrappedUndo = NULL; // don't delete in dtor - pointer must be stored outside
583 0 : }
584 :
585 0 : OUString ScUndoWrapper::GetComment() const
586 : {
587 0 : if (pWrappedUndo)
588 0 : return pWrappedUndo->GetComment();
589 0 : return OUString();
590 : }
591 :
592 0 : OUString ScUndoWrapper::GetRepeatComment(SfxRepeatTarget& rTarget) const
593 : {
594 0 : if (pWrappedUndo)
595 0 : return pWrappedUndo->GetRepeatComment(rTarget);
596 0 : return OUString();
597 : }
598 :
599 0 : sal_uInt16 ScUndoWrapper::GetId() const
600 : {
601 0 : if (pWrappedUndo)
602 0 : return pWrappedUndo->GetId();
603 : else
604 0 : return 0;
605 : }
606 :
607 0 : void ScUndoWrapper::SetLinkToSfxLinkUndoAction(SfxLinkUndoAction* pSfxLinkUndoAction)
608 : {
609 0 : if (pWrappedUndo)
610 0 : pWrappedUndo->SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
611 : else
612 0 : SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
613 0 : }
614 :
615 0 : bool ScUndoWrapper::Merge( SfxUndoAction* pNextAction )
616 : {
617 0 : if (pWrappedUndo)
618 0 : return pWrappedUndo->Merge(pNextAction);
619 : else
620 0 : return false;
621 : }
622 :
623 0 : void ScUndoWrapper::Undo()
624 : {
625 0 : if (pWrappedUndo)
626 0 : pWrappedUndo->Undo();
627 0 : }
628 :
629 0 : void ScUndoWrapper::Redo()
630 : {
631 0 : if (pWrappedUndo)
632 0 : pWrappedUndo->Redo();
633 0 : }
634 :
635 0 : void ScUndoWrapper::Repeat(SfxRepeatTarget& rTarget)
636 : {
637 0 : if (pWrappedUndo)
638 0 : pWrappedUndo->Repeat(rTarget);
639 0 : }
640 :
641 0 : bool ScUndoWrapper::CanRepeat(SfxRepeatTarget& rTarget) const
642 : {
643 0 : if (pWrappedUndo)
644 0 : return pWrappedUndo->CanRepeat(rTarget);
645 : else
646 0 : return false;
647 156 : }
648 :
649 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
