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 "scitems.hxx"
21 : #include <editeng/eeitem.hxx>
22 : #include <editeng/editobj.hxx>
23 : #include <svl/zforlist.hxx>
24 : #include <sfx2/app.hxx>
25 :
26 : #include "undocell.hxx"
27 : #include "document.hxx"
28 : #include "docpool.hxx"
29 : #include "patattr.hxx"
30 : #include "docsh.hxx"
31 : #include "tabvwsh.hxx"
32 : #include "globstr.hrc"
33 : #include "global.hxx"
34 : #include "cell.hxx"
35 : #include "target.hxx"
36 : #include "undoolk.hxx"
37 : #include "detdata.hxx"
38 : #include "stlpool.hxx"
39 : #include "printfun.hxx"
40 : #include "rangenam.hxx"
41 : #include "chgtrack.hxx"
42 : #include "sc.hrc"
43 : #include "docuno.hxx"
44 :
45 : using ::boost::shared_ptr;
46 :
47 0 : TYPEINIT1(ScUndoCursorAttr, ScSimpleUndo);
48 0 : TYPEINIT1(ScUndoEnterData, ScSimpleUndo);
49 0 : TYPEINIT1(ScUndoEnterValue, ScSimpleUndo);
50 0 : TYPEINIT1(ScUndoPutCell, ScSimpleUndo);
51 0 : TYPEINIT1(ScUndoPageBreak, ScSimpleUndo);
52 0 : TYPEINIT1(ScUndoPrintZoom, ScSimpleUndo);
53 0 : TYPEINIT1(ScUndoThesaurus, ScSimpleUndo);
54 0 : TYPEINIT1(ScUndoReplaceNote, ScSimpleUndo);
55 0 : TYPEINIT1(ScUndoShowHideNote, ScSimpleUndo);
56 0 : TYPEINIT1(ScUndoDetective, ScSimpleUndo);
57 0 : TYPEINIT1(ScUndoRangeNames, ScSimpleUndo);
58 :
59 0 : ScUndoCursorAttr::ScUndoCursorAttr( ScDocShell* pNewDocShell,
60 : SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
61 : const ScPatternAttr* pOldPat, const ScPatternAttr* pNewPat,
62 : const ScPatternAttr* pApplyPat, sal_Bool bAutomatic ) :
63 : ScSimpleUndo( pNewDocShell ),
64 : nCol( nNewCol ),
65 : nRow( nNewRow ),
66 : nTab( nNewTab ),
67 : pOldEditData( static_cast<EditTextObject*>(NULL) ),
68 : pNewEditData( static_cast<EditTextObject*>(NULL) ),
69 0 : bIsAutomatic( bAutomatic )
70 : {
71 0 : ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
72 0 : pNewPattern = (ScPatternAttr*) &pPool->Put( *pNewPat );
73 0 : pOldPattern = (ScPatternAttr*) &pPool->Put( *pOldPat );
74 0 : pApplyPattern = (ScPatternAttr*) &pPool->Put( *pApplyPat );
75 0 : }
76 :
77 0 : ScUndoCursorAttr::~ScUndoCursorAttr()
78 : {
79 0 : ScDocumentPool* pPool = pDocShell->GetDocument()->GetPool();
80 0 : pPool->Remove(*pNewPattern);
81 0 : pPool->Remove(*pOldPattern);
82 0 : pPool->Remove(*pApplyPattern);
83 0 : }
84 :
85 0 : rtl::OUString ScUndoCursorAttr::GetComment() const
86 : {
87 : //! own text for automatic attribution
88 :
89 0 : sal_uInt16 nId = STR_UNDO_CURSORATTR; // "Attribute"
90 0 : return ScGlobal::GetRscString( nId );
91 : }
92 :
93 0 : void ScUndoCursorAttr::SetEditData( EditTextObject* pOld, EditTextObject* pNew )
94 : {
95 0 : pOldEditData.reset(pOld);
96 0 : pNewEditData.reset(pNew);
97 0 : }
98 :
99 0 : void ScUndoCursorAttr::DoChange( const ScPatternAttr* pWhichPattern, const shared_ptr<EditTextObject>& pEditData ) const
100 : {
101 0 : ScDocument* pDoc = pDocShell->GetDocument();
102 0 : pDoc->SetPattern( nCol, nRow, nTab, *pWhichPattern, true );
103 :
104 : ScBaseCell* pCell;
105 0 : pDoc->GetCell(nCol, nRow, nTab, pCell);
106 0 : if (pCell && pCell->GetCellType() == CELLTYPE_EDIT && pEditData.get())
107 0 : static_cast<ScEditCell*>(pCell)->SetData(pEditData.get(), NULL);
108 :
109 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
110 0 : if (pViewShell)
111 : {
112 0 : pViewShell->SetTabNo( nTab );
113 0 : pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
114 0 : pViewShell->AdjustBlockHeight();
115 : }
116 :
117 0 : const SfxItemSet& rApplySet = pApplyPattern->GetItemSet();
118 0 : sal_Bool bPaintExt = ( rApplySet.GetItemState( ATTR_SHADOW, sal_True ) != SFX_ITEM_DEFAULT ||
119 0 : rApplySet.GetItemState( ATTR_CONDITIONAL, sal_True ) != SFX_ITEM_DEFAULT );
120 0 : sal_Bool bPaintRows = ( rApplySet.GetItemState( ATTR_HOR_JUSTIFY, sal_True ) != SFX_ITEM_DEFAULT );
121 :
122 0 : sal_uInt16 nFlags = SC_PF_TESTMERGE;
123 0 : if (bPaintExt)
124 0 : nFlags |= SC_PF_LINES;
125 0 : if (bPaintRows)
126 0 : nFlags |= SC_PF_WHOLEROWS;
127 0 : pDocShell->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID, nFlags );
128 0 : }
129 :
130 0 : void ScUndoCursorAttr::Undo()
131 : {
132 0 : BeginUndo();
133 0 : DoChange(pOldPattern, pOldEditData);
134 :
135 0 : if ( bIsAutomatic )
136 : {
137 : // if automatic formatting is reversed, then
138 : // automatic formatting should also not continue to be done
139 :
140 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
141 0 : if (pViewShell)
142 0 : pViewShell->ForgetFormatArea();
143 : }
144 :
145 0 : EndUndo();
146 0 : }
147 :
148 0 : void ScUndoCursorAttr::Redo()
149 : {
150 0 : BeginRedo();
151 0 : DoChange(pNewPattern, pNewEditData);
152 0 : EndRedo();
153 0 : }
154 :
155 0 : void ScUndoCursorAttr::Repeat(SfxRepeatTarget& rTarget)
156 : {
157 0 : if (rTarget.ISA(ScTabViewTarget))
158 0 : ((ScTabViewTarget&)rTarget).GetViewShell()->ApplySelectionPattern( *pApplyPattern );
159 0 : }
160 :
161 0 : sal_Bool ScUndoCursorAttr::CanRepeat(SfxRepeatTarget& rTarget) const
162 : {
163 0 : return (rTarget.ISA(ScTabViewTarget));
164 : }
165 :
166 0 : ScUndoEnterData::ScUndoEnterData( ScDocShell* pNewDocShell,
167 : SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
168 : SCTAB nNewCount, SCTAB* pNewTabs, ScBaseCell** ppOldData,
169 : sal_Bool* pHasForm, sal_uLong* pOldForm,
170 : const String& rNewStr, EditTextObject* pObj ) :
171 : ScSimpleUndo( pNewDocShell ),
172 : aNewString( rNewStr ),
173 : pTabs( pNewTabs ),
174 : ppOldCells( ppOldData ),
175 : pHasFormat( pHasForm ),
176 : pOldFormats( pOldForm ),
177 : pNewEditData( pObj ),
178 : nCol( nNewCol ),
179 : nRow( nNewRow ),
180 : nTab( nNewTab ),
181 0 : nCount( nNewCount )
182 : {
183 0 : SetChangeTrack();
184 0 : }
185 :
186 0 : ScUndoEnterData::~ScUndoEnterData()
187 : {
188 0 : for (sal_uInt16 i=0; i<nCount; i++)
189 0 : if (ppOldCells[i])
190 0 : ppOldCells[i]->Delete();
191 0 : delete[] ppOldCells;
192 :
193 0 : delete[] pHasFormat;
194 0 : delete[] pOldFormats;
195 0 : delete[] pTabs;
196 :
197 0 : delete pNewEditData;
198 0 : }
199 :
200 0 : rtl::OUString ScUndoEnterData::GetComment() const
201 : {
202 0 : return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Input"
203 : }
204 :
205 0 : void ScUndoEnterData::DoChange() const
206 : {
207 : // only when needed (old or new Edit cell, or Attribute)?
208 0 : for (sal_uInt16 i=0; i<nCount; i++)
209 0 : pDocShell->AdjustRowHeight( nRow, nRow, pTabs[i] );
210 :
211 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
212 0 : if (pViewShell)
213 : {
214 0 : pViewShell->SetTabNo( nTab );
215 0 : pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
216 : }
217 :
218 0 : pDocShell->PostDataChanged();
219 0 : }
220 :
221 0 : void ScUndoEnterData::SetChangeTrack()
222 : {
223 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
224 0 : if ( pChangeTrack )
225 : {
226 0 : nEndChangeAction = pChangeTrack->GetActionMax() + 1;
227 0 : ScAddress aPos( nCol, nRow, nTab );
228 0 : for (sal_uInt16 i=0; i<nCount; i++)
229 : {
230 0 : aPos.SetTab( pTabs[i] );
231 0 : sal_uLong nFormat = 0;
232 0 : if ( pHasFormat && pOldFormats )
233 : {
234 0 : if ( pHasFormat[i] )
235 0 : nFormat = pOldFormats[i];
236 : }
237 0 : pChangeTrack->AppendContent( aPos, ppOldCells[i], nFormat );
238 : }
239 0 : if ( nEndChangeAction > pChangeTrack->GetActionMax() )
240 0 : nEndChangeAction = 0; // nothing is appended
241 : }
242 : else
243 0 : nEndChangeAction = 0;
244 0 : }
245 :
246 0 : void ScUndoEnterData::Undo()
247 : {
248 0 : BeginUndo();
249 :
250 0 : ScDocument* pDoc = pDocShell->GetDocument();
251 0 : for (sal_uInt16 i=0; i<nCount; i++)
252 : {
253 0 : ScBaseCell* pNewCell = ppOldCells[i] ? ppOldCells[i]->Clone( *pDoc, SC_CLONECELL_STARTLISTENING ) : 0;
254 0 : pDoc->PutCell( nCol, nRow, pTabs[i], pNewCell );
255 :
256 0 : if (pHasFormat && pOldFormats)
257 : {
258 0 : if ( pHasFormat[i] )
259 0 : pDoc->ApplyAttr( nCol, nRow, pTabs[i],
260 0 : SfxUInt32Item( ATTR_VALUE_FORMAT, pOldFormats[i] ) );
261 : else
262 : {
263 0 : ScPatternAttr aPattern( *pDoc->GetPattern( nCol, nRow, pTabs[i] ) );
264 0 : aPattern.GetItemSet().ClearItem( ATTR_VALUE_FORMAT );
265 0 : pDoc->SetPattern( nCol, nRow, pTabs[i], aPattern, sal_True );
266 : }
267 : }
268 0 : pDocShell->PostPaintCell( nCol, nRow, pTabs[i] );
269 : }
270 :
271 0 : ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
272 0 : if ( pChangeTrack && nEndChangeAction >= sal::static_int_cast<sal_uLong>(nCount) )
273 0 : pChangeTrack->Undo( nEndChangeAction - nCount + 1, nEndChangeAction );
274 :
275 0 : DoChange();
276 0 : EndUndo();
277 :
278 : // #i97876# Spreadsheet data changes are not notified
279 0 : ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
280 0 : if ( pModelObj && pModelObj->HasChangesListeners() )
281 : {
282 0 : ScRangeList aChangeRanges;
283 0 : for ( sal_uInt16 i = 0; i < nCount; ++i )
284 : {
285 0 : aChangeRanges.Append( ScRange( nCol, nRow, pTabs[i] ) );
286 : }
287 0 : pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
288 : }
289 0 : }
290 :
291 0 : void ScUndoEnterData::Redo()
292 : {
293 0 : BeginRedo();
294 :
295 0 : ScDocument* pDoc = pDocShell->GetDocument();
296 0 : for (sal_uInt16 i=0; i<nCount; i++)
297 : {
298 0 : if (pNewEditData)
299 0 : pDoc->PutCell( nCol, nRow, pTabs[i], new ScEditCell( pNewEditData,
300 0 : pDoc, NULL ) );
301 : else
302 0 : pDoc->SetString( nCol, nRow, pTabs[i], aNewString );
303 0 : pDocShell->PostPaintCell( nCol, nRow, pTabs[i] );
304 : }
305 :
306 0 : SetChangeTrack();
307 :
308 0 : DoChange();
309 0 : EndRedo();
310 :
311 : // #i97876# Spreadsheet data changes are not notified
312 0 : ScModelObj* pModelObj = ScModelObj::getImplementation( pDocShell->GetModel() );
313 0 : if ( pModelObj && pModelObj->HasChangesListeners() )
314 : {
315 0 : ScRangeList aChangeRanges;
316 0 : for ( sal_uInt16 i = 0; i < nCount; ++i )
317 : {
318 0 : aChangeRanges.Append( ScRange( nCol, nRow, pTabs[i] ) );
319 : }
320 0 : pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
321 : }
322 0 : }
323 :
324 0 : void ScUndoEnterData::Repeat(SfxRepeatTarget& rTarget)
325 : {
326 0 : if (rTarget.ISA(ScTabViewTarget))
327 : {
328 0 : String aTemp = aNewString;
329 0 : ((ScTabViewTarget&)rTarget).GetViewShell()->EnterDataAtCursor( aTemp );
330 : }
331 0 : }
332 :
333 0 : sal_Bool ScUndoEnterData::CanRepeat(SfxRepeatTarget& rTarget) const
334 : {
335 0 : return (rTarget.ISA(ScTabViewTarget));
336 : }
337 :
338 :
339 0 : ScUndoEnterValue::ScUndoEnterValue( ScDocShell* pNewDocShell, const ScAddress& rNewPos,
340 : ScBaseCell* pUndoCell, double nVal ) :
341 : ScSimpleUndo( pNewDocShell ),
342 : aPos ( rNewPos ),
343 : pOldCell ( pUndoCell ),
344 0 : nValue ( nVal )
345 : {
346 0 : SetChangeTrack();
347 0 : }
348 :
349 0 : ScUndoEnterValue::~ScUndoEnterValue()
350 : {
351 0 : if (pOldCell)
352 0 : pOldCell->Delete();
353 0 : }
354 :
355 0 : rtl::OUString ScUndoEnterValue::GetComment() const
356 : {
357 0 : return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Input"
358 : }
359 :
360 0 : void ScUndoEnterValue::SetChangeTrack()
361 : {
362 0 : ScDocument* pDoc = pDocShell->GetDocument();
363 0 : ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
364 0 : if ( pChangeTrack )
365 : {
366 0 : nEndChangeAction = pChangeTrack->GetActionMax() + 1;
367 0 : pChangeTrack->AppendContent( aPos, pOldCell );
368 0 : if ( nEndChangeAction > pChangeTrack->GetActionMax() )
369 0 : nEndChangeAction = 0; // nothing is appended
370 : }
371 : else
372 0 : nEndChangeAction = 0;
373 0 : }
374 :
375 0 : void ScUndoEnterValue::Undo()
376 : {
377 0 : BeginUndo();
378 :
379 0 : ScDocument* pDoc = pDocShell->GetDocument();
380 0 : ScBaseCell* pNewCell = pOldCell ? pOldCell->Clone( *pDoc, SC_CLONECELL_STARTLISTENING ) : 0;
381 :
382 0 : pDoc->PutCell( aPos, pNewCell );
383 :
384 0 : pDocShell->PostPaintCell( aPos );
385 :
386 0 : ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
387 0 : if ( pChangeTrack )
388 0 : pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
389 :
390 0 : EndUndo();
391 0 : }
392 :
393 0 : void ScUndoEnterValue::Redo()
394 : {
395 0 : BeginRedo();
396 :
397 0 : ScDocument* pDoc = pDocShell->GetDocument();
398 0 : pDoc->SetValue( aPos.Col(), aPos.Row(), aPos.Tab(), nValue );
399 0 : pDocShell->PostPaintCell( aPos );
400 :
401 0 : SetChangeTrack();
402 :
403 0 : EndRedo();
404 0 : }
405 :
406 0 : void ScUndoEnterValue::Repeat(SfxRepeatTarget& /* rTarget */)
407 : {
408 : // makes no sense
409 0 : }
410 :
411 0 : sal_Bool ScUndoEnterValue::CanRepeat(SfxRepeatTarget& /* rTarget */) const
412 : {
413 0 : return false;
414 : }
415 :
416 0 : ScUndoPutCell::ScUndoPutCell( ScDocShell* pNewDocShell, const ScAddress& rNewPos,
417 : ScBaseCell* pUndoCell, ScBaseCell* pRedoCell ) :
418 : ScSimpleUndo( pNewDocShell ),
419 : aPos ( rNewPos ),
420 : pOldCell ( pUndoCell ),
421 0 : pEnteredCell( pRedoCell )
422 : {
423 0 : SetChangeTrack();
424 0 : }
425 :
426 0 : ScUndoPutCell::~ScUndoPutCell()
427 : {
428 0 : if (pOldCell)
429 0 : pOldCell->Delete();
430 0 : if (pEnteredCell)
431 0 : pEnteredCell->Delete();
432 0 : }
433 :
434 0 : rtl::OUString ScUndoPutCell::GetComment() const
435 : {
436 0 : return ScGlobal::GetRscString( STR_UNDO_ENTERDATA ); // "Input"
437 : }
438 :
439 0 : void ScUndoPutCell::SetChangeTrack()
440 : {
441 0 : ScDocument* pDoc = pDocShell->GetDocument();
442 0 : ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
443 0 : if ( pChangeTrack )
444 : {
445 0 : nEndChangeAction = pChangeTrack->GetActionMax() + 1;
446 0 : pChangeTrack->AppendContent( aPos, pOldCell );
447 0 : if ( nEndChangeAction > pChangeTrack->GetActionMax() )
448 0 : nEndChangeAction = 0; // Nothing is appended
449 : }
450 : else
451 0 : nEndChangeAction = 0;
452 0 : }
453 :
454 0 : void ScUndoPutCell::Undo()
455 : {
456 0 : BeginUndo();
457 :
458 0 : ScDocument* pDoc = pDocShell->GetDocument();
459 0 : ScBaseCell* pNewCell = pOldCell ? pOldCell->Clone( *pDoc, aPos, SC_CLONECELL_STARTLISTENING ) : 0;
460 :
461 0 : pDoc->PutCell( aPos.Col(), aPos.Row(), aPos.Tab(), pNewCell );
462 :
463 0 : pDocShell->PostPaintCell( aPos );
464 :
465 0 : ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
466 0 : if ( pChangeTrack )
467 0 : pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
468 :
469 0 : EndUndo();
470 0 : }
471 :
472 0 : void ScUndoPutCell::Redo()
473 : {
474 0 : BeginRedo();
475 :
476 0 : ScDocument* pDoc = pDocShell->GetDocument();
477 0 : ScBaseCell* pNewCell = pEnteredCell ? pEnteredCell->Clone( *pDoc, aPos, SC_CLONECELL_STARTLISTENING ) : 0;
478 :
479 0 : pDoc->PutCell( aPos.Col(), aPos.Row(), aPos.Tab(), pNewCell );
480 :
481 0 : pDocShell->PostPaintCell( aPos );
482 :
483 0 : SetChangeTrack();
484 :
485 0 : EndRedo();
486 0 : }
487 :
488 0 : void ScUndoPutCell::Repeat(SfxRepeatTarget& /* rTarget */)
489 : {
490 : // makes no sense
491 0 : }
492 :
493 0 : sal_Bool ScUndoPutCell::CanRepeat(SfxRepeatTarget& /* rTarget */) const
494 : {
495 0 : return false;
496 : }
497 :
498 0 : ScUndoPageBreak::ScUndoPageBreak( ScDocShell* pNewDocShell,
499 : SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
500 : sal_Bool bNewColumn, sal_Bool bNewInsert ) :
501 : ScSimpleUndo( pNewDocShell ),
502 : nCol( nNewCol ),
503 : nRow( nNewRow ),
504 : nTab( nNewTab ),
505 : bColumn( bNewColumn ),
506 0 : bInsert( bNewInsert )
507 : {
508 0 : }
509 :
510 0 : ScUndoPageBreak::~ScUndoPageBreak()
511 : {
512 0 : }
513 :
514 0 : rtl::OUString ScUndoPageBreak::GetComment() const
515 : {
516 : //"Column break" | "Row break" "insert" | "delete"
517 : return String ( bColumn ?
518 : ( bInsert ?
519 : ScGlobal::GetRscString( STR_UNDO_INSCOLBREAK ) :
520 : ScGlobal::GetRscString( STR_UNDO_DELCOLBREAK )
521 : ) :
522 : ( bInsert ?
523 : ScGlobal::GetRscString( STR_UNDO_INSROWBREAK ) :
524 : ScGlobal::GetRscString( STR_UNDO_DELROWBREAK )
525 0 : ) );
526 : }
527 :
528 0 : void ScUndoPageBreak::DoChange( sal_Bool bInsertP ) const
529 : {
530 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
531 :
532 0 : if (pViewShell)
533 : {
534 0 : pViewShell->SetTabNo( nTab );
535 0 : pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
536 :
537 0 : if (bInsertP)
538 0 : pViewShell->InsertPageBreak(bColumn, false);
539 : else
540 0 : pViewShell->DeletePageBreak(bColumn, false);
541 :
542 0 : pDocShell->GetDocument()->InvalidatePageBreaks(nTab);
543 : }
544 0 : }
545 :
546 0 : void ScUndoPageBreak::Undo()
547 : {
548 0 : BeginUndo();
549 0 : DoChange(!bInsert);
550 0 : EndUndo();
551 0 : }
552 :
553 0 : void ScUndoPageBreak::Redo()
554 : {
555 0 : BeginRedo();
556 0 : DoChange(bInsert);
557 0 : EndRedo();
558 0 : }
559 :
560 0 : void ScUndoPageBreak::Repeat(SfxRepeatTarget& rTarget)
561 : {
562 0 : if (rTarget.ISA(ScTabViewTarget))
563 : {
564 0 : ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
565 :
566 0 : if (bInsert)
567 0 : rViewShell.InsertPageBreak(bColumn, sal_True);
568 : else
569 0 : rViewShell.DeletePageBreak(bColumn, sal_True);
570 : }
571 0 : }
572 :
573 0 : sal_Bool ScUndoPageBreak::CanRepeat(SfxRepeatTarget& rTarget) const
574 : {
575 0 : return (rTarget.ISA(ScTabViewTarget));
576 : }
577 :
578 0 : ScUndoPrintZoom::ScUndoPrintZoom( ScDocShell* pNewDocShell,
579 : SCTAB nT, sal_uInt16 nOS, sal_uInt16 nOP, sal_uInt16 nNS, sal_uInt16 nNP ) :
580 : ScSimpleUndo( pNewDocShell ),
581 : nTab( nT ),
582 : nOldScale( nOS ),
583 : nOldPages( nOP ),
584 : nNewScale( nNS ),
585 0 : nNewPages( nNP )
586 : {
587 0 : }
588 :
589 0 : ScUndoPrintZoom::~ScUndoPrintZoom()
590 : {
591 0 : }
592 :
593 0 : rtl::OUString ScUndoPrintZoom::GetComment() const
594 : {
595 0 : return ScGlobal::GetRscString( STR_UNDO_PRINTSCALE );
596 : }
597 :
598 0 : void ScUndoPrintZoom::DoChange( sal_Bool bUndo )
599 : {
600 0 : sal_uInt16 nScale = bUndo ? nOldScale : nNewScale;
601 0 : sal_uInt16 nPages = bUndo ? nOldPages : nNewPages;
602 :
603 0 : ScDocument* pDoc = pDocShell->GetDocument();
604 0 : String aStyleName = pDoc->GetPageStyle( nTab );
605 0 : ScStyleSheetPool* pStylePool = pDoc->GetStyleSheetPool();
606 0 : SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aStyleName, SFX_STYLE_FAMILY_PAGE );
607 : OSL_ENSURE( pStyleSheet, "PageStyle not found" );
608 0 : if ( pStyleSheet )
609 : {
610 0 : SfxItemSet& rSet = pStyleSheet->GetItemSet();
611 0 : rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, nScale ) );
612 0 : rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALETOPAGES, nPages ) );
613 :
614 0 : ScPrintFunc aPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab );
615 0 : aPrintFunc.UpdatePages();
616 0 : }
617 0 : }
618 :
619 0 : void ScUndoPrintZoom::Undo()
620 : {
621 0 : BeginUndo();
622 0 : DoChange(sal_True);
623 0 : EndUndo();
624 0 : }
625 :
626 0 : void ScUndoPrintZoom::Redo()
627 : {
628 0 : BeginRedo();
629 0 : DoChange(false);
630 0 : EndRedo();
631 0 : }
632 :
633 0 : void ScUndoPrintZoom::Repeat(SfxRepeatTarget& rTarget)
634 : {
635 0 : if (rTarget.ISA(ScTabViewTarget))
636 : {
637 0 : ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
638 0 : ScViewData* pViewData = rViewShell.GetViewData();
639 0 : pViewData->GetDocShell()->SetPrintZoom( pViewData->GetTabNo(), nNewScale, nNewPages );
640 : }
641 0 : }
642 :
643 0 : sal_Bool ScUndoPrintZoom::CanRepeat(SfxRepeatTarget& rTarget) const
644 : {
645 0 : return (rTarget.ISA(ScTabViewTarget));
646 : }
647 :
648 0 : ScUndoThesaurus::ScUndoThesaurus( ScDocShell* pNewDocShell,
649 : SCCOL nNewCol, SCROW nNewRow, SCTAB nNewTab,
650 : const String& rNewUndoStr, const EditTextObject* pUndoTObj,
651 : const String& rNewRedoStr, const EditTextObject* pRedoTObj) :
652 : ScSimpleUndo( pNewDocShell ),
653 : nCol( nNewCol ),
654 : nRow( nNewRow ),
655 : nTab( nNewTab ),
656 : aUndoStr( rNewUndoStr ),
657 0 : aRedoStr( rNewRedoStr )
658 : {
659 0 : pUndoTObject = (pUndoTObj) ? pUndoTObj->Clone() : NULL;
660 0 : pRedoTObject = (pRedoTObj) ? pRedoTObj->Clone() : NULL;
661 :
662 : ScBaseCell* pOldCell;
663 0 : if ( pUndoTObject )
664 0 : pOldCell = new ScEditCell( pUndoTObject, pDocShell->GetDocument(), NULL );
665 : else
666 0 : pOldCell = new ScStringCell( aUndoStr );
667 0 : SetChangeTrack( pOldCell );
668 0 : pOldCell->Delete();
669 0 : }
670 :
671 0 : ScUndoThesaurus::~ScUndoThesaurus()
672 : {
673 0 : delete pUndoTObject;
674 0 : delete pRedoTObject;
675 0 : }
676 :
677 0 : rtl::OUString ScUndoThesaurus::GetComment() const
678 : {
679 0 : return ScGlobal::GetRscString( STR_UNDO_THESAURUS ); // "Thesaurus"
680 : }
681 :
682 0 : void ScUndoThesaurus::SetChangeTrack( ScBaseCell* pOldCell )
683 : {
684 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
685 0 : if ( pChangeTrack )
686 : {
687 0 : nEndChangeAction = pChangeTrack->GetActionMax() + 1;
688 0 : pChangeTrack->AppendContent( ScAddress( nCol, nRow, nTab ), pOldCell );
689 0 : if ( nEndChangeAction > pChangeTrack->GetActionMax() )
690 0 : nEndChangeAction = 0; // nothing is appended
691 : }
692 : else
693 0 : nEndChangeAction = 0;
694 0 : }
695 :
696 0 : void ScUndoThesaurus::DoChange( sal_Bool bUndo, const String& rStr,
697 : const EditTextObject* pTObj )
698 : {
699 0 : ScDocument* pDoc = pDocShell->GetDocument();
700 :
701 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
702 0 : if (pViewShell)
703 : {
704 0 : pViewShell->SetTabNo( nTab );
705 0 : pViewShell->MoveCursorAbs( nCol, nRow, SC_FOLLOW_JUMP, false, false );
706 : }
707 :
708 0 : if (pTObj)
709 : {
710 : ScBaseCell* pCell;
711 0 : pDoc->GetCell( nCol, nRow, nTab, pCell );
712 0 : if (pCell)
713 : {
714 0 : if (pCell->GetCellType() == CELLTYPE_EDIT )
715 : {
716 0 : ScEditCell* pNewCell = new ScEditCell( pTObj, pDoc, NULL );
717 0 : pDoc->PutCell( nCol, nRow, nTab, pNewCell );
718 0 : if ( !bUndo )
719 0 : SetChangeTrack( pCell );
720 : }
721 : else
722 : {
723 : OSL_FAIL("Not CELLTYPE_EDIT for Un/RedoThesaurus");
724 : }
725 : }
726 : }
727 : else
728 : {
729 0 : ScBaseCell* pCell = NULL;
730 0 : if ( !bUndo )
731 0 : pDoc->GetCell( nCol, nRow, nTab, pCell );
732 0 : pDoc->SetString( nCol, nRow, nTab, rStr );
733 0 : if ( !bUndo )
734 0 : SetChangeTrack( pCell );
735 : }
736 :
737 0 : pDocShell->PostPaintCell( nCol, nRow, nTab );
738 0 : }
739 :
740 0 : void ScUndoThesaurus::Undo()
741 : {
742 0 : BeginUndo();
743 0 : DoChange( sal_True, aUndoStr, pUndoTObject );
744 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument()->GetChangeTrack();
745 0 : if ( pChangeTrack )
746 0 : pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
747 0 : EndUndo();
748 0 : }
749 :
750 0 : void ScUndoThesaurus::Redo()
751 : {
752 0 : BeginRedo();
753 0 : DoChange( false, aRedoStr, pRedoTObject );
754 0 : EndRedo();
755 0 : }
756 :
757 0 : void ScUndoThesaurus::Repeat(SfxRepeatTarget& rTarget)
758 : {
759 0 : if (rTarget.ISA(ScTabViewTarget))
760 0 : ((ScTabViewTarget&)rTarget).GetViewShell()->DoThesaurus( sal_True );
761 0 : }
762 :
763 0 : sal_Bool ScUndoThesaurus::CanRepeat(SfxRepeatTarget& rTarget) const
764 : {
765 0 : return (rTarget.ISA(ScTabViewTarget));
766 : }
767 :
768 0 : ScUndoReplaceNote::ScUndoReplaceNote( ScDocShell& rDocShell, const ScAddress& rPos,
769 : const ScNoteData& rNoteData, bool bInsert, SdrUndoAction* pDrawUndo ) :
770 : ScSimpleUndo( &rDocShell ),
771 : maPos( rPos ),
772 0 : mpDrawUndo( pDrawUndo )
773 : {
774 : OSL_ENSURE( rNoteData.mpCaption, "ScUndoReplaceNote::ScUndoReplaceNote - missing note caption" );
775 0 : (bInsert ? maNewData : maOldData) = rNoteData;
776 0 : }
777 :
778 0 : ScUndoReplaceNote::ScUndoReplaceNote( ScDocShell& rDocShell, const ScAddress& rPos,
779 : const ScNoteData& rOldData, const ScNoteData& rNewData, SdrUndoAction* pDrawUndo ) :
780 : ScSimpleUndo( &rDocShell ),
781 : maPos( rPos ),
782 : maOldData( rOldData ),
783 : maNewData( rNewData ),
784 0 : mpDrawUndo( pDrawUndo )
785 : {
786 : OSL_ENSURE( maOldData.mpCaption || maNewData.mpCaption, "ScUndoReplaceNote::ScUndoReplaceNote - missing note captions" );
787 : OSL_ENSURE( !maOldData.mxInitData.get() && !maNewData.mxInitData.get(), "ScUndoReplaceNote::ScUndoReplaceNote - unexpected unitialized note" );
788 0 : }
789 :
790 0 : ScUndoReplaceNote::~ScUndoReplaceNote()
791 : {
792 0 : DeleteSdrUndoAction( mpDrawUndo );
793 0 : }
794 :
795 0 : void ScUndoReplaceNote::Undo()
796 : {
797 0 : BeginUndo();
798 0 : DoSdrUndoAction( mpDrawUndo, pDocShell->GetDocument() );
799 : /* Undo insert -> remove new note.
800 : Undo remove -> insert old note.
801 : Undo replace -> remove new note, insert old note. */
802 0 : DoRemoveNote( maNewData );
803 0 : DoInsertNote( maOldData );
804 0 : pDocShell->PostPaintCell( maPos );
805 0 : EndUndo();
806 0 : }
807 :
808 0 : void ScUndoReplaceNote::Redo()
809 : {
810 0 : BeginRedo();
811 0 : RedoSdrUndoAction( mpDrawUndo );
812 : /* Redo insert -> insert new note.
813 : Redo remove -> remove old note.
814 : Redo replace -> remove old note, insert new note. */
815 0 : DoRemoveNote( maOldData );
816 0 : DoInsertNote( maNewData );
817 0 : pDocShell->PostPaintCell( maPos );
818 0 : EndRedo();
819 0 : }
820 :
821 0 : void ScUndoReplaceNote::Repeat( SfxRepeatTarget& /*rTarget*/ )
822 : {
823 0 : }
824 :
825 0 : sal_Bool ScUndoReplaceNote::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
826 : {
827 0 : return false;
828 : }
829 :
830 0 : rtl::OUString ScUndoReplaceNote::GetComment() const
831 : {
832 : return ScGlobal::GetRscString( maNewData.mpCaption ?
833 0 : (maOldData.mpCaption ? STR_UNDO_EDITNOTE : STR_UNDO_INSERTNOTE) : STR_UNDO_DELETENOTE );
834 : }
835 :
836 0 : void ScUndoReplaceNote::DoInsertNote( const ScNoteData& rNoteData )
837 : {
838 0 : if( rNoteData.mpCaption )
839 : {
840 0 : ScDocument& rDoc = *pDocShell->GetDocument();
841 : OSL_ENSURE( !rDoc.GetNotes( maPos.Tab() )->findByAddress(maPos), "ScUndoReplaceNote::DoInsertNote - unexpected cell note" );
842 0 : ScPostIt* pNote = new ScPostIt( rDoc, maPos, rNoteData, false );
843 0 : rDoc.GetNotes(maPos.Tab())->insert( maPos, pNote );
844 : }
845 0 : }
846 :
847 0 : void ScUndoReplaceNote::DoRemoveNote( const ScNoteData& rNoteData )
848 : {
849 0 : if( rNoteData.mpCaption )
850 : {
851 0 : ScDocument& rDoc = *pDocShell->GetDocument();
852 : OSL_ENSURE( rDoc.GetNotes( maPos.Tab() )->findByAddress(maPos), "ScUndoReplaceNote::DoRemoveNote - missing cell note" );
853 0 : if( ScPostIt* pNote = rDoc.GetNotes(maPos.Tab())->ReleaseNote( maPos ) )
854 : {
855 : /* Forget pointer to caption object to suppress removing the
856 : caption object from the drawing layer while deleting pNote
857 : (removing the caption is done by a drawing undo action). */
858 0 : pNote->ForgetCaption();
859 0 : delete pNote;
860 : }
861 : }
862 0 : }
863 :
864 0 : ScUndoShowHideNote::ScUndoShowHideNote( ScDocShell& rDocShell, const ScAddress& rPos, bool bShow ) :
865 : ScSimpleUndo( &rDocShell ),
866 : maPos( rPos ),
867 0 : mbShown( bShow )
868 : {
869 0 : }
870 :
871 0 : ScUndoShowHideNote::~ScUndoShowHideNote()
872 : {
873 0 : }
874 :
875 0 : void ScUndoShowHideNote::Undo()
876 : {
877 0 : BeginUndo();
878 0 : if( ScPostIt* pNote = pDocShell->GetDocument()->GetNotes( maPos.Tab() )->findByAddress(maPos) )
879 0 : pNote->ShowCaption( maPos, !mbShown );
880 0 : EndUndo();
881 0 : }
882 :
883 0 : void ScUndoShowHideNote::Redo()
884 : {
885 0 : BeginRedo();
886 0 : if( ScPostIt* pNote = pDocShell->GetDocument()->GetNotes( maPos.Tab() )->findByAddress(maPos) )
887 0 : pNote->ShowCaption( maPos, mbShown );
888 0 : EndRedo();
889 0 : }
890 :
891 0 : void ScUndoShowHideNote::Repeat( SfxRepeatTarget& /*rTarget*/ )
892 : {
893 0 : }
894 :
895 0 : sal_Bool ScUndoShowHideNote::CanRepeat( SfxRepeatTarget& /*rTarget*/ ) const
896 : {
897 0 : return false;
898 : }
899 :
900 0 : rtl::OUString ScUndoShowHideNote::GetComment() const
901 : {
902 0 : return ScGlobal::GetRscString( mbShown ? STR_UNDO_SHOWNOTE : STR_UNDO_HIDENOTE );
903 : }
904 :
905 0 : ScUndoDetective::ScUndoDetective( ScDocShell* pNewDocShell,
906 : SdrUndoAction* pDraw, const ScDetOpData* pOperation,
907 : ScDetOpList* pUndoList ) :
908 : ScSimpleUndo( pNewDocShell ),
909 : pOldList ( pUndoList ),
910 : nAction ( 0 ),
911 0 : pDrawUndo ( pDraw )
912 : {
913 0 : bIsDelete = ( pOperation == NULL );
914 0 : if (!bIsDelete)
915 : {
916 0 : nAction = (sal_uInt16) pOperation->GetOperation();
917 0 : aPos = pOperation->GetPos();
918 : }
919 0 : }
920 :
921 0 : ScUndoDetective::~ScUndoDetective()
922 : {
923 0 : DeleteSdrUndoAction( pDrawUndo );
924 0 : delete pOldList;
925 0 : }
926 :
927 0 : rtl::OUString ScUndoDetective::GetComment() const
928 : {
929 0 : sal_uInt16 nId = STR_UNDO_DETDELALL;
930 0 : if ( !bIsDelete )
931 0 : switch ( (ScDetOpType) nAction )
932 : {
933 0 : case SCDETOP_ADDSUCC: nId = STR_UNDO_DETADDSUCC; break;
934 0 : case SCDETOP_DELSUCC: nId = STR_UNDO_DETDELSUCC; break;
935 0 : case SCDETOP_ADDPRED: nId = STR_UNDO_DETADDPRED; break;
936 0 : case SCDETOP_DELPRED: nId = STR_UNDO_DETDELPRED; break;
937 0 : case SCDETOP_ADDERROR: nId = STR_UNDO_DETADDERROR; break;
938 : }
939 :
940 0 : return ScGlobal::GetRscString( nId );
941 : }
942 :
943 0 : void ScUndoDetective::Undo()
944 : {
945 0 : BeginUndo();
946 :
947 0 : ScDocument* pDoc = pDocShell->GetDocument();
948 0 : DoSdrUndoAction(pDrawUndo, pDoc);
949 :
950 0 : if (bIsDelete)
951 : {
952 0 : if ( pOldList )
953 0 : pDoc->SetDetOpList( new ScDetOpList(*pOldList) );
954 : }
955 : else
956 : {
957 : // Remove entry from list
958 :
959 0 : ScDetOpList* pList = pDoc->GetDetOpList();
960 0 : if (pList && pList->Count())
961 : {
962 0 : ScDetOpDataVector& rVec = pList->GetDataVector();
963 0 : ScDetOpDataVector::iterator it = rVec.begin() + rVec.size() - 1;
964 0 : if ( it->GetOperation() == (ScDetOpType) nAction && it->GetPos() == aPos )
965 0 : rVec.erase( it);
966 : else
967 : {
968 : OSL_FAIL("Detective entry could not be found in list");
969 : }
970 : }
971 : }
972 :
973 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
974 0 : if (pViewShell)
975 0 : pViewShell->RecalcPPT(); //! use broadcast instead?
976 :
977 0 : EndUndo();
978 0 : }
979 :
980 0 : void ScUndoDetective::Redo()
981 : {
982 0 : BeginRedo();
983 :
984 0 : RedoSdrUndoAction(pDrawUndo);
985 :
986 0 : ScDocument* pDoc = pDocShell->GetDocument();
987 :
988 0 : if (bIsDelete)
989 0 : pDoc->ClearDetectiveOperations();
990 : else
991 0 : pDoc->AddDetectiveOperation( ScDetOpData( aPos, (ScDetOpType) nAction ) );
992 :
993 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
994 0 : if (pViewShell)
995 0 : pViewShell->RecalcPPT(); //! use broadcast instead?
996 :
997 0 : EndRedo();
998 0 : }
999 :
1000 0 : void ScUndoDetective::Repeat(SfxRepeatTarget& /* rTarget */)
1001 : {
1002 : // makes no sense
1003 0 : }
1004 :
1005 0 : sal_Bool ScUndoDetective::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1006 : {
1007 0 : return false;
1008 : }
1009 :
1010 0 : ScUndoRangeNames::ScUndoRangeNames( ScDocShell* pNewDocShell,
1011 : ScRangeName* pOld, ScRangeName* pNew, SCTAB nTab ) :
1012 : ScSimpleUndo( pNewDocShell ),
1013 : pOldRanges ( pOld ),
1014 : pNewRanges ( pNew ),
1015 0 : mnTab ( nTab )
1016 : {
1017 0 : }
1018 :
1019 0 : ScUndoRangeNames::~ScUndoRangeNames()
1020 : {
1021 0 : delete pOldRanges;
1022 0 : delete pNewRanges;
1023 0 : }
1024 :
1025 0 : rtl::OUString ScUndoRangeNames::GetComment() const
1026 : {
1027 0 : return ScGlobal::GetRscString( STR_UNDO_RANGENAMES );
1028 : }
1029 :
1030 0 : void ScUndoRangeNames::DoChange( sal_Bool bUndo )
1031 : {
1032 0 : ScDocument* pDoc = pDocShell->GetDocument();
1033 0 : pDoc->CompileNameFormula( sal_True ); // CreateFormulaString
1034 :
1035 0 : if ( bUndo )
1036 : {
1037 0 : if (mnTab >= 0)
1038 0 : pDoc->SetRangeName( mnTab, new ScRangeName( *pOldRanges ) );
1039 : else
1040 0 : pDoc->SetRangeName( new ScRangeName( *pOldRanges ) );
1041 : }
1042 : else
1043 : {
1044 0 : if (mnTab >= 0)
1045 0 : pDoc->SetRangeName( mnTab, new ScRangeName( *pNewRanges ) );
1046 : else
1047 0 : pDoc->SetRangeName( new ScRangeName( *pNewRanges ) );
1048 : }
1049 :
1050 0 : pDoc->CompileNameFormula( false ); // CompileFormulaString
1051 :
1052 0 : SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
1053 0 : }
1054 :
1055 0 : void ScUndoRangeNames::Undo()
1056 : {
1057 0 : BeginUndo();
1058 0 : DoChange( sal_True );
1059 0 : EndUndo();
1060 0 : }
1061 :
1062 0 : void ScUndoRangeNames::Redo()
1063 : {
1064 0 : BeginRedo();
1065 0 : DoChange( false );
1066 0 : EndRedo();
1067 0 : }
1068 :
1069 0 : void ScUndoRangeNames::Repeat(SfxRepeatTarget& /* rTarget */)
1070 : {
1071 : // makes no sense
1072 0 : }
1073 :
1074 0 : sal_Bool ScUndoRangeNames::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1075 : {
1076 0 : return false;
1077 15 : }
1078 :
1079 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
