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 14516 : ScSimpleUndo::ScSimpleUndo( ScDocShell* pDocSh ) :
46 : pDocShell( pDocSh ),
47 14516 : pDetectiveUndo( NULL )
48 : {
49 14516 : }
50 :
51 29024 : ScSimpleUndo::~ScSimpleUndo()
52 : {
53 14512 : delete pDetectiveUndo;
54 14512 : }
55 :
56 10 : bool ScSimpleUndo::SetViewMarkData( const ScMarkData& rMarkData )
57 : {
58 10 : if ( IsPaintLocked() )
59 0 : return false;
60 :
61 10 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
62 10 : if ( !pViewShell )
63 10 : return false;
64 :
65 0 : pViewShell->SetMarkData( rMarkData );
66 0 : return true;
67 : }
68 :
69 6 : 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 6 : if ( !pDetectiveUndo && pNextAction->ISA(ScUndoDraw) )
79 : {
80 : // Take SdrUndoAction from ScUndoDraw Action,
81 : // ScUndoDraw is later deleted by the UndoManager
82 :
83 6 : ScUndoDraw* pCalcUndo = static_cast<ScUndoDraw*>(pNextAction);
84 6 : pDetectiveUndo = pCalcUndo->GetDrawUndo();
85 6 : pCalcUndo->ForgetDrawUndo();
86 6 : return true;
87 : }
88 :
89 0 : return false;
90 : }
91 :
92 108 : void ScSimpleUndo::BeginUndo()
93 : {
94 108 : pDocShell->SetInUndo( true );
95 :
96 108 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
97 108 : if (pViewShell)
98 0 : pViewShell->HideAllCursors(); // for example due to merged cells
99 :
100 : // detective updates happened last, must be undone first
101 108 : if (pDetectiveUndo)
102 0 : pDetectiveUndo->Undo();
103 108 : }
104 :
105 108 : void ScSimpleUndo::EndUndo()
106 : {
107 108 : pDocShell->SetDocumentModified();
108 :
109 108 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
110 108 : if (pViewShell)
111 : {
112 0 : pViewShell->UpdateAutoFillMark();
113 0 : pViewShell->UpdateInputHandler();
114 0 : pViewShell->ShowAllCursors();
115 : }
116 :
117 108 : pDocShell->SetInUndo( false );
118 108 : }
119 :
120 44 : void ScSimpleUndo::BeginRedo()
121 : {
122 44 : pDocShell->SetInUndo( true ); //! own Flag for Redo?
123 :
124 44 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
125 44 : if (pViewShell)
126 0 : pViewShell->HideAllCursors(); // for example due to merged cells
127 44 : }
128 :
129 44 : void ScSimpleUndo::EndRedo()
130 : {
131 44 : if (pDetectiveUndo)
132 0 : pDetectiveUndo->Redo();
133 :
134 44 : pDocShell->SetDocumentModified();
135 :
136 44 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
137 44 : if (pViewShell)
138 : {
139 0 : pViewShell->UpdateAutoFillMark();
140 0 : pViewShell->UpdateInputHandler();
141 0 : pViewShell->ShowAllCursors();
142 : }
143 :
144 44 : pDocShell->SetInUndo( false );
145 44 : }
146 :
147 8 : void ScSimpleUndo::BroadcastChanges( const ScRange& rRange )
148 : {
149 8 : ScDocument& rDoc = pDocShell->GetDocument();
150 8 : rDoc.BroadcastCells(rRange, SC_HINT_DATACHANGED);
151 8 : }
152 :
153 : namespace {
154 :
155 6 : class SpanBroadcaster : public sc::ColumnSpanSet::ColumnAction
156 : {
157 : ScDocument& mrDoc;
158 : SCTAB mnCurTab;
159 : SCCOL mnCurCol;
160 :
161 : public:
162 6 : SpanBroadcaster( ScDocument& rDoc ) : mrDoc(rDoc), mnCurTab(-1), mnCurCol(-1) {}
163 :
164 6 : virtual void startColumn( ScColumn* pCol ) SAL_OVERRIDE
165 : {
166 6 : mnCurTab = pCol->GetTab();
167 6 : mnCurCol = pCol->GetCol();
168 6 : }
169 :
170 18 : virtual void execute( SCROW nRow1, SCROW nRow2, bool bVal ) SAL_OVERRIDE
171 : {
172 18 : if (!bVal)
173 30 : return;
174 :
175 6 : ScRange aRange(mnCurCol, nRow1, mnCurTab, mnCurCol, nRow2, mnCurTab);
176 6 : mrDoc.BroadcastCells(aRange, SC_HINT_DATACHANGED);
177 : };
178 : };
179 :
180 : }
181 :
182 6 : void ScSimpleUndo::BroadcastChanges( const DataSpansType& rSpans )
183 : {
184 6 : ScDocument& rDoc = pDocShell->GetDocument();
185 6 : SpanBroadcaster aBroadcaster(rDoc);
186 :
187 6 : DataSpansType::const_iterator it = rSpans.begin(), itEnd = rSpans.end();
188 12 : for (; it != itEnd; ++it)
189 : {
190 6 : const sc::ColumnSpanSet& rSet = *it->second;
191 6 : rSet.executeColumnAction(rDoc, aBroadcaster);
192 6 : }
193 6 : }
194 :
195 4 : void ScSimpleUndo::ShowTable( SCTAB nTab )
196 : {
197 4 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
198 4 : if (pViewShell)
199 0 : pViewShell->SetTabNo( nTab );
200 4 : }
201 :
202 20 : void ScSimpleUndo::ShowTable( const ScRange& rRange )
203 : {
204 20 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
205 20 : 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 20 : }
214 :
215 82 : ScBlockUndo::ScBlockUndo( ScDocShell* pDocSh, const ScRange& rRange,
216 : ScBlockUndoMode eBlockMode ) :
217 : ScSimpleUndo( pDocSh ),
218 : aBlockRange( rRange ),
219 82 : eMode( eBlockMode )
220 : {
221 82 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
222 82 : }
223 :
224 164 : ScBlockUndo::~ScBlockUndo()
225 : {
226 82 : DeleteSdrUndoAction( pDrawUndo );
227 82 : }
228 :
229 8 : void ScBlockUndo::BeginUndo()
230 : {
231 8 : ScSimpleUndo::BeginUndo();
232 8 : EnableDrawAdjust( &pDocShell->GetDocument(), false );
233 8 : }
234 :
235 8 : void ScBlockUndo::EndUndo()
236 : {
237 8 : if (eMode == SC_UNDO_AUTOHEIGHT)
238 8 : AdjustHeight();
239 :
240 8 : EnableDrawAdjust( &pDocShell->GetDocument(), true );
241 8 : DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() );
242 :
243 8 : ShowBlock();
244 8 : ScSimpleUndo::EndUndo();
245 8 : }
246 :
247 6 : void ScBlockUndo::EndRedo()
248 : {
249 6 : if (eMode == SC_UNDO_AUTOHEIGHT)
250 6 : AdjustHeight();
251 :
252 6 : ShowBlock();
253 6 : ScSimpleUndo::EndRedo();
254 6 : }
255 :
256 14 : bool ScBlockUndo::AdjustHeight()
257 : {
258 14 : ScDocument& rDoc = pDocShell->GetDocument();
259 :
260 14 : VirtualDevice aVirtDev;
261 14 : Fraction aZoomX( 1, 1 );
262 14 : Fraction aZoomY = aZoomX;
263 : double nPPTX, nPPTY;
264 14 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
265 14 : 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 14 : nPPTX = ScGlobal::nScreenPPTX;
277 14 : nPPTY = ScGlobal::nScreenPPTY;
278 : }
279 :
280 28 : sc::RowHeightContext aCxt(nPPTX, nPPTY, aZoomX, aZoomY, &aVirtDev);
281 : bool bRet = rDoc.SetOptimalHeight(
282 14 : aCxt, aBlockRange.aStart.Row(), aBlockRange.aEnd.Row(), aBlockRange.aStart.Tab());
283 :
284 14 : 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 28 : return bRet;
290 : }
291 :
292 14 : void ScBlockUndo::ShowBlock()
293 : {
294 14 : if ( IsPaintLocked() )
295 14 : return;
296 :
297 14 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
298 14 : 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 62 : ScMultiBlockUndo::ScMultiBlockUndo(
314 : ScDocShell* pDocSh, const ScRangeList& rRanges, ScBlockUndoMode eBlockMode) :
315 : ScSimpleUndo(pDocSh),
316 : maBlockRanges(rRanges),
317 62 : meMode(eBlockMode)
318 : {
319 62 : mpDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
320 62 : }
321 :
322 124 : ScMultiBlockUndo::~ScMultiBlockUndo()
323 : {
324 62 : DeleteSdrUndoAction( mpDrawUndo );
325 62 : }
326 :
327 10 : void ScMultiBlockUndo::BeginUndo()
328 : {
329 10 : ScSimpleUndo::BeginUndo();
330 10 : EnableDrawAdjust(&pDocShell->GetDocument(), false);
331 10 : }
332 :
333 10 : void ScMultiBlockUndo::EndUndo()
334 : {
335 10 : if (meMode == SC_UNDO_AUTOHEIGHT)
336 0 : AdjustHeight();
337 :
338 10 : EnableDrawAdjust(&pDocShell->GetDocument(), true);
339 10 : DoSdrUndoAction(mpDrawUndo, &pDocShell->GetDocument());
340 :
341 10 : ShowBlock();
342 10 : ScSimpleUndo::EndUndo();
343 10 : }
344 :
345 6 : void ScMultiBlockUndo::EndRedo()
346 : {
347 6 : if (meMode == SC_UNDO_AUTOHEIGHT)
348 0 : AdjustHeight();
349 :
350 6 : ShowBlock();
351 6 : ScSimpleUndo::EndRedo();
352 6 : }
353 :
354 0 : void ScMultiBlockUndo::AdjustHeight()
355 : {
356 0 : ScDocument& rDoc = pDocShell->GetDocument();
357 :
358 0 : VirtualDevice aVirtDev;
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, &aVirtDev);
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 16 : void ScMultiBlockUndo::ShowBlock()
392 : {
393 16 : if ( IsPaintLocked() )
394 16 : return;
395 :
396 16 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
397 16 : if (!pViewShell)
398 16 : 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 134 : ScMoveUndo::ScMoveUndo( ScDocShell* pDocSh, ScDocument* pRefDoc, ScRefUndoData* pRefData,
423 : ScMoveUndoMode eRefMode ) :
424 : ScSimpleUndo( pDocSh ),
425 : pRefUndoDoc( pRefDoc ),
426 : pRefUndoData( pRefData ),
427 134 : eMode( eRefMode )
428 : {
429 134 : ScDocument& rDoc = pDocShell->GetDocument();
430 134 : if (pRefUndoData)
431 110 : pRefUndoData->DeleteUnchanged(&rDoc);
432 134 : pDrawUndo = GetSdrUndoAction( &rDoc );
433 134 : }
434 :
435 268 : ScMoveUndo::~ScMoveUndo()
436 : {
437 134 : delete pRefUndoData;
438 134 : delete pRefUndoDoc;
439 134 : DeleteSdrUndoAction( pDrawUndo );
440 134 : }
441 :
442 62 : void ScMoveUndo::UndoRef()
443 : {
444 62 : ScDocument& rDoc = pDocShell->GetDocument();
445 62 : ScRange aRange(0,0,0, MAXCOL,MAXROW,pRefUndoDoc->GetTableCount()-1);
446 62 : pRefUndoDoc->CopyToDocument( aRange, IDF_FORMULA, false, &rDoc, NULL, false );
447 62 : if (pRefUndoData)
448 48 : 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 62 : }
453 :
454 62 : void ScMoveUndo::BeginUndo()
455 : {
456 62 : ScSimpleUndo::BeginUndo();
457 :
458 62 : EnableDrawAdjust( &pDocShell->GetDocument(), false );
459 :
460 62 : if (pRefUndoDoc && eMode == SC_UNDO_REFFIRST)
461 14 : UndoRef();
462 62 : }
463 :
464 62 : void ScMoveUndo::EndUndo()
465 : {
466 62 : DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() ); // must also be called when pointer is null
467 :
468 62 : if (pRefUndoDoc && eMode == SC_UNDO_REFLAST)
469 48 : UndoRef();
470 :
471 62 : EnableDrawAdjust( &pDocShell->GetDocument(), true );
472 :
473 62 : ScSimpleUndo::EndUndo();
474 62 : }
475 :
476 12 : ScDBFuncUndo::ScDBFuncUndo( ScDocShell* pDocSh, const ScRange& rOriginal, SdrUndoAction* pDrawUndo ) :
477 : ScSimpleUndo( pDocSh ),
478 : aOriginalRange( rOriginal ),
479 12 : mpDrawUndo( pDrawUndo )
480 : {
481 12 : pAutoDBRange = pDocSh->GetOldAutoDBRange();
482 12 : }
483 :
484 24 : ScDBFuncUndo::~ScDBFuncUndo()
485 : {
486 12 : DeleteSdrUndoAction( mpDrawUndo );
487 12 : delete pAutoDBRange;
488 12 : }
489 :
490 0 : void ScDBFuncUndo::SetDrawUndoAction( SdrUndoAction* pDrawUndo )
491 : {
492 0 : DeleteSdrUndoAction( mpDrawUndo );
493 0 : mpDrawUndo = pDrawUndo;
494 0 : }
495 :
496 0 : void ScDBFuncUndo::BeginUndo()
497 : {
498 0 : ScSimpleUndo::BeginUndo();
499 0 : DoSdrUndoAction( mpDrawUndo, &pDocShell->GetDocument() );
500 0 : }
501 :
502 0 : void ScDBFuncUndo::EndUndo()
503 : {
504 0 : ScSimpleUndo::EndUndo();
505 :
506 0 : if ( pAutoDBRange )
507 : {
508 0 : ScDocument& rDoc = pDocShell->GetDocument();
509 0 : SCTAB nTab = rDoc.GetVisibleTab();
510 0 : ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab);
511 0 : if (pNoNameData )
512 : {
513 : SCCOL nRangeX1;
514 : SCROW nRangeY1;
515 : SCCOL nRangeX2;
516 : SCROW nRangeY2;
517 : SCTAB nRangeTab;
518 0 : pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
519 0 : pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
520 :
521 0 : *pNoNameData = *pAutoDBRange;
522 :
523 0 : if ( pAutoDBRange->HasAutoFilter() )
524 : {
525 : // restore AutoFilter buttons
526 0 : pAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
527 0 : rDoc.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
528 0 : pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
529 : }
530 : }
531 : }
532 0 : }
533 :
534 0 : void ScDBFuncUndo::BeginRedo()
535 : {
536 0 : RedoSdrUndoAction( mpDrawUndo );
537 0 : if ( pAutoDBRange )
538 : {
539 : // move the database range to this function's position again (see ScDocShell::GetDBData)
540 :
541 0 : ScDocument& rDoc = pDocShell->GetDocument();
542 0 : ScDBData* pNoNameData = rDoc.GetAnonymousDBData(aOriginalRange.aStart.Tab());
543 0 : if ( pNoNameData )
544 : {
545 :
546 : SCCOL nRangeX1;
547 : SCROW nRangeY1;
548 : SCCOL nRangeX2;
549 : SCROW nRangeY2;
550 : SCTAB nRangeTab;
551 0 : pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
552 0 : pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
553 :
554 0 : pNoNameData->SetSortParam( ScSortParam() );
555 0 : pNoNameData->SetQueryParam( ScQueryParam() );
556 0 : pNoNameData->SetSubTotalParam( ScSubTotalParam() );
557 :
558 0 : pNoNameData->SetArea( aOriginalRange.aStart.Tab(),
559 0 : aOriginalRange.aStart.Col(), aOriginalRange.aStart.Row(),
560 0 : aOriginalRange.aEnd.Col(), aOriginalRange.aEnd.Row() );
561 :
562 0 : pNoNameData->SetByRow( true );
563 0 : pNoNameData->SetAutoFilter( false );
564 : // header is always set with the operation in redo
565 : }
566 : }
567 :
568 0 : ScSimpleUndo::BeginRedo();
569 0 : }
570 :
571 0 : void ScDBFuncUndo::EndRedo()
572 : {
573 0 : ScSimpleUndo::EndRedo();
574 0 : }
575 :
576 0 : ScUndoWrapper::ScUndoWrapper( SfxUndoAction* pUndo ) :
577 0 : pWrappedUndo( pUndo )
578 : {
579 0 : }
580 :
581 0 : ScUndoWrapper::~ScUndoWrapper()
582 : {
583 0 : delete pWrappedUndo;
584 0 : }
585 :
586 0 : void ScUndoWrapper::ForgetWrappedUndo()
587 : {
588 0 : pWrappedUndo = NULL; // don't delete in dtor - pointer must be stored outside
589 0 : }
590 :
591 0 : OUString ScUndoWrapper::GetComment() const
592 : {
593 0 : if (pWrappedUndo)
594 0 : return pWrappedUndo->GetComment();
595 0 : return OUString();
596 : }
597 :
598 0 : OUString ScUndoWrapper::GetRepeatComment(SfxRepeatTarget& rTarget) const
599 : {
600 0 : if (pWrappedUndo)
601 0 : return pWrappedUndo->GetRepeatComment(rTarget);
602 0 : return OUString();
603 : }
604 :
605 0 : sal_uInt16 ScUndoWrapper::GetId() const
606 : {
607 0 : if (pWrappedUndo)
608 0 : return pWrappedUndo->GetId();
609 : else
610 0 : return 0;
611 : }
612 :
613 0 : void ScUndoWrapper::SetLinkToSfxLinkUndoAction(SfxLinkUndoAction* pSfxLinkUndoAction)
614 : {
615 0 : if (pWrappedUndo)
616 0 : pWrappedUndo->SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
617 : else
618 0 : SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
619 0 : }
620 :
621 0 : bool ScUndoWrapper::Merge( SfxUndoAction* pNextAction )
622 : {
623 0 : if (pWrappedUndo)
624 0 : return pWrappedUndo->Merge(pNextAction);
625 : else
626 0 : return false;
627 : }
628 :
629 0 : void ScUndoWrapper::Undo()
630 : {
631 0 : if (pWrappedUndo)
632 0 : pWrappedUndo->Undo();
633 0 : }
634 :
635 0 : void ScUndoWrapper::Redo()
636 : {
637 0 : if (pWrappedUndo)
638 0 : pWrappedUndo->Redo();
639 0 : }
640 :
641 0 : void ScUndoWrapper::Repeat(SfxRepeatTarget& rTarget)
642 : {
643 0 : if (pWrappedUndo)
644 0 : pWrappedUndo->Repeat(rTarget);
645 0 : }
646 :
647 0 : bool ScUndoWrapper::CanRepeat(SfxRepeatTarget& rTarget) const
648 : {
649 0 : if (pWrappedUndo)
650 0 : return pWrappedUndo->CanRepeat(rTarget);
651 : else
652 0 : return false;
653 228 : }
654 :
655 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
