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