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 <sfx2/app.hxx>
21 : #include <sfx2/bindings.hxx>
22 : #include <sfx2/dispatch.hxx>
23 : #include <svl/smplhint.hxx>
24 :
25 : #include "undotab.hxx"
26 : #include "document.hxx"
27 : #include "docsh.hxx"
28 : #include "tabvwsh.hxx"
29 : #include "globstr.hrc"
30 : #include "global.hxx"
31 : #include "sc.hrc"
32 : #include "undoolk.hxx"
33 : #include "target.hxx"
34 : #include "uiitems.hxx"
35 : #include "prnsave.hxx"
36 : #include "printfun.hxx"
37 : #include "chgtrack.hxx"
38 : #include "tabprotection.hxx"
39 : #include "viewdata.hxx"
40 : #include "progress.hxx"
41 : #include "markdata.hxx"
42 :
43 : // for ScUndoRenameObject - might me moved to another file later
44 : #include <svx/svditer.hxx>
45 : #include <svx/svdoole2.hxx>
46 : #include <svx/svdpage.hxx>
47 : #include "drwlayer.hxx"
48 : #include "scresid.hxx"
49 :
50 : #include <utility>
51 : #include <vector>
52 : #include <boost/scoped_ptr.hpp>
53 :
54 : extern bool bDrawIsInUndo; // somewhere as member!
55 :
56 : using namespace com::sun::star;
57 : using ::com::sun::star::uno::Sequence;
58 : using ::std::unique_ptr;
59 : using ::std::vector;
60 : using ::boost::shared_ptr;
61 :
62 0 : TYPEINIT1(ScUndoInsertTab, SfxUndoAction);
63 0 : TYPEINIT1(ScUndoInsertTables, SfxUndoAction);
64 0 : TYPEINIT1(ScUndoDeleteTab, SfxUndoAction);
65 0 : TYPEINIT1(ScUndoRenameTab, SfxUndoAction);
66 0 : TYPEINIT1(ScUndoMoveTab, SfxUndoAction);
67 0 : TYPEINIT1(ScUndoCopyTab, SfxUndoAction);
68 0 : TYPEINIT1(ScUndoMakeScenario, SfxUndoAction);
69 0 : TYPEINIT1(ScUndoImportTab, SfxUndoAction);
70 0 : TYPEINIT1(ScUndoRemoveLink, SfxUndoAction);
71 0 : TYPEINIT1(ScUndoShowHideTab, SfxUndoAction);
72 0 : TYPEINIT1(ScUndoPrintRange, SfxUndoAction);
73 0 : TYPEINIT1(ScUndoScenarioFlags, SfxUndoAction);
74 0 : TYPEINIT1(ScUndoRenameObject, SfxUndoAction);
75 0 : TYPEINIT1(ScUndoLayoutRTL, SfxUndoAction);
76 0 : TYPEINIT1(ScUndoTabColor, SfxUndoAction);
77 :
78 37 : ScUndoInsertTab::ScUndoInsertTab( ScDocShell* pNewDocShell,
79 : SCTAB nTabNum,
80 : bool bApp,
81 : const OUString& rNewName) :
82 : ScSimpleUndo( pNewDocShell ),
83 : sNewName( rNewName ),
84 : pDrawUndo( NULL ),
85 : nTab( nTabNum ),
86 37 : bAppend( bApp )
87 : {
88 37 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
89 37 : SetChangeTrack();
90 37 : }
91 :
92 111 : ScUndoInsertTab::~ScUndoInsertTab()
93 : {
94 37 : DeleteSdrUndoAction( pDrawUndo );
95 74 : }
96 :
97 53 : OUString ScUndoInsertTab::GetComment() const
98 : {
99 53 : if (bAppend)
100 12 : return ScGlobal::GetRscString( STR_UNDO_APPEND_TAB );
101 : else
102 41 : return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB );
103 : }
104 :
105 37 : void ScUndoInsertTab::SetChangeTrack()
106 : {
107 37 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
108 37 : if ( pChangeTrack )
109 : {
110 0 : ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
111 0 : pChangeTrack->AppendInsert( aRange );
112 0 : nEndChangeAction = pChangeTrack->GetActionMax();
113 : }
114 : else
115 37 : nEndChangeAction = 0;
116 37 : }
117 :
118 0 : void ScUndoInsertTab::Undo()
119 : {
120 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
121 0 : pViewShell->SetTabNo(nTab);
122 :
123 0 : pDocShell->SetInUndo( true ); //! BeginUndo
124 0 : bDrawIsInUndo = true;
125 0 : pViewShell->DeleteTable( nTab, false );
126 0 : bDrawIsInUndo = false;
127 0 : pDocShell->SetInUndo( false ); //! EndUndo
128 :
129 0 : DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() );
130 :
131 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
132 0 : if ( pChangeTrack )
133 0 : pChangeTrack->Undo( nEndChangeAction, nEndChangeAction );
134 :
135 : // SetTabNo(...,sal_True) for all views to sync with drawing layer pages
136 0 : pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
137 0 : }
138 :
139 0 : void ScUndoInsertTab::Redo()
140 : {
141 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
142 :
143 0 : RedoSdrUndoAction( pDrawUndo ); // Draw Redo first
144 :
145 0 : pDocShell->SetInUndo( true ); //! BeginRedo
146 0 : bDrawIsInUndo = true;
147 0 : if (bAppend)
148 0 : pViewShell->AppendTable( sNewName, false );
149 : else
150 : {
151 0 : pViewShell->SetTabNo(nTab);
152 0 : pViewShell->InsertTable( sNewName, nTab, false );
153 : }
154 0 : bDrawIsInUndo = false;
155 0 : pDocShell->SetInUndo( false ); //! EndRedo
156 :
157 0 : SetChangeTrack();
158 0 : }
159 :
160 0 : void ScUndoInsertTab::Repeat(SfxRepeatTarget& rTarget)
161 : {
162 0 : if (rTarget.ISA(ScTabViewTarget))
163 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData().GetDispatcher().
164 0 : Execute(FID_INS_TABLE, SfxCallMode::SLOT | SfxCallMode::RECORD);
165 0 : }
166 :
167 10 : bool ScUndoInsertTab::CanRepeat(SfxRepeatTarget& rTarget) const
168 : {
169 10 : return rTarget.ISA(ScTabViewTarget);
170 : }
171 :
172 0 : ScUndoInsertTables::ScUndoInsertTables( ScDocShell* pNewDocShell,
173 : SCTAB nTabNum,
174 : std::vector<OUString>& newNameList) :
175 : ScSimpleUndo( pNewDocShell ),
176 : pDrawUndo( NULL ),
177 : aNameList( newNameList ),
178 0 : nTab( nTabNum )
179 : {
180 0 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
181 :
182 0 : SetChangeTrack();
183 0 : }
184 :
185 0 : ScUndoInsertTables::~ScUndoInsertTables()
186 : {
187 0 : DeleteSdrUndoAction( pDrawUndo );
188 0 : }
189 :
190 0 : OUString ScUndoInsertTables::GetComment() const
191 : {
192 0 : return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB );
193 : }
194 :
195 0 : void ScUndoInsertTables::SetChangeTrack()
196 : {
197 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
198 0 : if ( pChangeTrack )
199 : {
200 0 : nStartChangeAction = pChangeTrack->GetActionMax() + 1;
201 0 : nEndChangeAction = 0;
202 0 : ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
203 0 : for( size_t i = 0; i < aNameList.size(); i++ )
204 : {
205 0 : aRange.aStart.SetTab( sal::static_int_cast<SCTAB>( nTab + i ) );
206 0 : aRange.aEnd.SetTab( sal::static_int_cast<SCTAB>( nTab + i ) );
207 0 : pChangeTrack->AppendInsert( aRange );
208 0 : nEndChangeAction = pChangeTrack->GetActionMax();
209 : }
210 : }
211 : else
212 0 : nStartChangeAction = nEndChangeAction = 0;
213 0 : }
214 :
215 0 : void ScUndoInsertTables::Undo()
216 : {
217 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
218 0 : pViewShell->SetTabNo(nTab);
219 :
220 0 : pDocShell->SetInUndo( true ); //! BeginUndo
221 0 : bDrawIsInUndo = true;
222 :
223 0 : pViewShell->DeleteTables( nTab, static_cast<SCTAB>(aNameList.size()) );
224 :
225 0 : bDrawIsInUndo = false;
226 0 : pDocShell->SetInUndo( false ); //! EndUndo
227 :
228 0 : DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() );
229 :
230 0 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
231 0 : if ( pChangeTrack )
232 0 : pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
233 :
234 : // SetTabNo(...,sal_True) for all views to sync with drawing layer pages
235 0 : pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
236 0 : }
237 :
238 0 : void ScUndoInsertTables::Redo()
239 : {
240 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
241 :
242 0 : RedoSdrUndoAction( pDrawUndo ); // Draw Redo first
243 :
244 0 : pDocShell->SetInUndo( true ); //! BeginRedo
245 0 : bDrawIsInUndo = true;
246 0 : pViewShell->SetTabNo(nTab);
247 0 : pViewShell->InsertTables( aNameList, nTab, static_cast<SCTAB>(aNameList.size()),false );
248 :
249 0 : bDrawIsInUndo = false;
250 0 : pDocShell->SetInUndo( false ); //! EndRedo
251 :
252 0 : SetChangeTrack();
253 0 : }
254 :
255 0 : void ScUndoInsertTables::Repeat(SfxRepeatTarget& rTarget)
256 : {
257 0 : if (rTarget.ISA(ScTabViewTarget))
258 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData().GetDispatcher().
259 0 : Execute(FID_INS_TABLE, SfxCallMode::SLOT | SfxCallMode::RECORD);
260 0 : }
261 :
262 0 : bool ScUndoInsertTables::CanRepeat(SfxRepeatTarget& rTarget) const
263 : {
264 0 : return rTarget.ISA(ScTabViewTarget);
265 : }
266 :
267 20 : ScUndoDeleteTab::ScUndoDeleteTab( ScDocShell* pNewDocShell, const vector<SCTAB> &aTab,
268 : ScDocument* pUndoDocument, ScRefUndoData* pRefData ) :
269 20 : ScMoveUndo( pNewDocShell, pUndoDocument, pRefData, SC_UNDO_REFLAST )
270 : {
271 20 : theTabs.insert(theTabs.end(), aTab.begin(), aTab.end() );
272 20 : SetChangeTrack();
273 20 : }
274 :
275 60 : ScUndoDeleteTab::~ScUndoDeleteTab()
276 : {
277 20 : theTabs.clear();
278 40 : }
279 :
280 22 : OUString ScUndoDeleteTab::GetComment() const
281 : {
282 22 : return ScGlobal::GetRscString( STR_UNDO_DELETE_TAB );
283 : }
284 :
285 20 : void ScUndoDeleteTab::SetChangeTrack()
286 : {
287 20 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
288 20 : if ( pChangeTrack )
289 : {
290 : sal_uLong nTmpChangeAction;
291 0 : nStartChangeAction = pChangeTrack->GetActionMax() + 1;
292 0 : nEndChangeAction = 0;
293 0 : ScRange aRange( 0, 0, 0, MAXCOL, MAXROW, 0 );
294 0 : for ( size_t i = 0; i < theTabs.size(); ++i )
295 : {
296 0 : aRange.aStart.SetTab( theTabs[i] );
297 0 : aRange.aEnd.SetTab( theTabs[i] );
298 : pChangeTrack->AppendDeleteRange( aRange, pRefUndoDoc,
299 0 : nTmpChangeAction, nEndChangeAction, (short) i );
300 : }
301 : }
302 : else
303 20 : nStartChangeAction = nEndChangeAction = 0;
304 20 : }
305 :
306 0 : static SCTAB lcl_GetVisibleTabBefore( ScDocument& rDoc, SCTAB nTab )
307 : {
308 0 : while ( nTab > 0 && !rDoc.IsVisible( nTab ) )
309 0 : --nTab;
310 :
311 0 : return nTab;
312 : }
313 :
314 2 : void ScUndoDeleteTab::Undo()
315 : {
316 2 : BeginUndo();
317 2 : unsigned int i=0;
318 2 : ScDocument& rDoc = pDocShell->GetDocument();
319 :
320 2 : bool bLink = false;
321 2 : OUString aName;
322 :
323 4 : for(i=0; i<theTabs.size(); ++i)
324 : {
325 2 : SCTAB nTab = theTabs[i];
326 2 : pRefUndoDoc->GetName( nTab, aName );
327 :
328 2 : bDrawIsInUndo = true;
329 2 : bool bOk = rDoc.InsertTab(nTab, aName, false, true);
330 2 : bDrawIsInUndo = false;
331 2 : if (bOk)
332 : {
333 2 : pRefUndoDoc->CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,false, &rDoc );
334 :
335 2 : OUString aOldName;
336 2 : pRefUndoDoc->GetName( nTab, aOldName );
337 2 : rDoc.RenameTab( nTab, aOldName, false );
338 2 : if (pRefUndoDoc->IsLinked(nTab))
339 : {
340 0 : rDoc.SetLink( nTab, pRefUndoDoc->GetLinkMode(nTab), pRefUndoDoc->GetLinkDoc(nTab),
341 : pRefUndoDoc->GetLinkFlt(nTab), pRefUndoDoc->GetLinkOpt(nTab),
342 0 : pRefUndoDoc->GetLinkTab(nTab), pRefUndoDoc->GetLinkRefreshDelay(nTab) );
343 0 : bLink = true;
344 : }
345 :
346 2 : if ( pRefUndoDoc->IsScenario(nTab) )
347 : {
348 0 : rDoc.SetScenario( nTab, true );
349 0 : OUString aComment;
350 0 : Color aColor;
351 : sal_uInt16 nScenFlags;
352 0 : pRefUndoDoc->GetScenarioData( nTab, aComment, aColor, nScenFlags );
353 0 : rDoc.SetScenarioData( nTab, aComment, aColor, nScenFlags );
354 0 : bool bActive = pRefUndoDoc->IsActiveScenario( nTab );
355 0 : rDoc.SetActiveScenario( nTab, bActive );
356 : }
357 2 : rDoc.SetVisible( nTab, pRefUndoDoc->IsVisible( nTab ) );
358 2 : rDoc.SetTabBgColor( nTab, pRefUndoDoc->GetTabBgColor(nTab) );
359 2 : rDoc.SetSheetEvents( nTab, pRefUndoDoc->GetSheetEvents( nTab ) );
360 2 : rDoc.SetLayoutRTL( nTab, pRefUndoDoc->IsLayoutRTL( nTab ) );
361 :
362 2 : if ( pRefUndoDoc->IsTabProtected( nTab ) )
363 0 : rDoc.SetTabProtection(nTab, pRefUndoDoc->GetTabProtection(nTab));
364 : }
365 : }
366 2 : if (bLink)
367 : {
368 0 : pDocShell->UpdateLinks(); // update Link Manager
369 : }
370 :
371 2 : EndUndo(); // Draw-Undo has to be called before Broadcast!
372 :
373 2 : ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
374 2 : if ( pChangeTrack )
375 0 : pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
376 :
377 4 : for(i=0; i<theTabs.size(); ++i)
378 : {
379 2 : pDocShell->Broadcast( ScTablesHint( SC_TAB_INSERTED, theTabs[i]) );
380 : }
381 2 : SfxApplication* pSfxApp = SfxGetpApp(); // Navigator
382 2 : pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
383 2 : pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
384 2 : pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
385 :
386 2 : pDocShell->PostPaint(0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_ALL ); // incl. extras
387 :
388 : // not ShowTable due to SetTabNo(..., sal_True):
389 2 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
390 2 : if (pViewShell)
391 0 : pViewShell->SetTabNo( lcl_GetVisibleTabBefore( rDoc, theTabs[0] ), true );
392 2 : }
393 :
394 0 : void ScUndoDeleteTab::Redo()
395 : {
396 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
397 0 : pViewShell->SetTabNo( lcl_GetVisibleTabBefore( pDocShell->GetDocument(), theTabs.front() ) );
398 :
399 0 : RedoSdrUndoAction( pDrawUndo ); // Draw Redo first
400 :
401 0 : pDocShell->SetInUndo( true ); //! BeginRedo
402 0 : bDrawIsInUndo = true;
403 0 : pViewShell->DeleteTables( theTabs, false );
404 0 : bDrawIsInUndo = false;
405 0 : pDocShell->SetInUndo( true ); //! EndRedo
406 :
407 0 : SetChangeTrack();
408 :
409 : // SetTabNo(...,sal_True) for all views to sync with drawing layer pages
410 0 : pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
411 0 : }
412 :
413 0 : void ScUndoDeleteTab::Repeat(SfxRepeatTarget& rTarget)
414 : {
415 0 : if (rTarget.ISA(ScTabViewTarget))
416 : {
417 0 : ScTabViewShell* pViewShell = static_cast<ScTabViewTarget&>(rTarget).GetViewShell();
418 0 : pViewShell->DeleteTable( pViewShell->GetViewData().GetTabNo(), true );
419 : }
420 0 : }
421 :
422 0 : bool ScUndoDeleteTab::CanRepeat(SfxRepeatTarget& rTarget) const
423 : {
424 0 : return rTarget.ISA(ScTabViewTarget);
425 : }
426 :
427 3 : ScUndoRenameTab::ScUndoRenameTab( ScDocShell* pNewDocShell,
428 : SCTAB nT,
429 : const OUString& rOldName,
430 : const OUString& rNewName) :
431 : ScSimpleUndo( pNewDocShell ),
432 3 : nTab ( nT )
433 : {
434 3 : sOldName = rOldName;
435 3 : sNewName = rNewName;
436 3 : }
437 :
438 4 : ScUndoRenameTab::~ScUndoRenameTab()
439 : {
440 4 : }
441 :
442 2 : OUString ScUndoRenameTab::GetComment() const
443 : {
444 2 : return ScGlobal::GetRscString( STR_UNDO_RENAME_TAB );
445 : }
446 :
447 2 : void ScUndoRenameTab::DoChange( SCTAB nTabP, const OUString& rName ) const
448 : {
449 2 : ScDocument& rDoc = pDocShell->GetDocument();
450 2 : rDoc.RenameTab( nTabP, rName );
451 :
452 2 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator
453 :
454 2 : pDocShell->PostPaintGridAll();
455 2 : pDocShell->PostPaintExtras();
456 2 : pDocShell->PostDataChanged();
457 :
458 : // The sheet name might be used in a formula ...
459 2 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
460 2 : if (pViewShell)
461 0 : pViewShell->UpdateInputHandler();
462 2 : }
463 :
464 1 : void ScUndoRenameTab::Undo()
465 : {
466 1 : DoChange(nTab, sOldName);
467 1 : }
468 :
469 1 : void ScUndoRenameTab::Redo()
470 : {
471 1 : DoChange(nTab, sNewName);
472 1 : }
473 :
474 0 : void ScUndoRenameTab::Repeat(SfxRepeatTarget& /* rTarget */)
475 : {
476 : // makes no sense
477 0 : }
478 :
479 0 : bool ScUndoRenameTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const
480 : {
481 0 : return false;
482 : }
483 :
484 0 : ScUndoMoveTab::ScUndoMoveTab(
485 : ScDocShell* pNewDocShell, vector<SCTAB>* pOldTabs, vector<SCTAB>* pNewTabs,
486 : vector<OUString>* pOldNames, vector<OUString>* pNewNames) :
487 : ScSimpleUndo( pNewDocShell ),
488 : mpOldTabs(pOldTabs), mpNewTabs(pNewTabs),
489 0 : mpOldNames(pOldNames), mpNewNames(pNewNames)
490 : {
491 0 : if (mpOldNames && mpOldTabs->size() != mpOldNames->size())
492 : // The sizes differ. Something is wrong.
493 0 : mpOldNames.reset();
494 :
495 0 : if (mpNewNames && mpNewTabs->size() != mpNewNames->size())
496 : // The sizes differ. Something is wrong.
497 0 : mpNewNames.reset();
498 0 : }
499 :
500 0 : ScUndoMoveTab::~ScUndoMoveTab()
501 : {
502 0 : }
503 :
504 0 : OUString ScUndoMoveTab::GetComment() const
505 : {
506 0 : return ScGlobal::GetRscString( STR_UNDO_MOVE_TAB );
507 : }
508 :
509 0 : void ScUndoMoveTab::DoChange( bool bUndo ) const
510 : {
511 0 : ScDocument& rDoc = pDocShell->GetDocument();
512 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
513 :
514 0 : if (bUndo) // UnDo
515 : {
516 0 : size_t i = mpNewTabs->size();
517 : boost::scoped_ptr<ScProgress> pProgress(new ScProgress(pDocShell , ScGlobal::GetRscString(STR_UNDO_MOVE_TAB),
518 0 : i * rDoc.GetCodeCount()));
519 0 : for (; i > 0; --i)
520 : {
521 0 : SCTAB nDestTab = (*mpNewTabs)[i-1];
522 0 : SCTAB nOldTab = (*mpOldTabs)[i-1];
523 0 : if (nDestTab > MAXTAB) // appended ?
524 0 : nDestTab = rDoc.GetTableCount() - 1;
525 :
526 0 : rDoc.MoveTab( nDestTab, nOldTab, pProgress.get() );
527 0 : pViewShell->GetViewData().MoveTab( nDestTab, nOldTab );
528 0 : pViewShell->SetTabNo( nOldTab, true );
529 0 : if (mpOldNames)
530 : {
531 0 : const OUString& rOldName = (*mpOldNames)[i-1];
532 0 : rDoc.RenameTab(nOldTab, rOldName);
533 : }
534 0 : }
535 : }
536 : else
537 : {
538 0 : size_t n = mpNewTabs->size();
539 : boost::scoped_ptr<ScProgress> pProgress(new ScProgress(pDocShell , ScGlobal::GetRscString(STR_UNDO_MOVE_TAB),
540 0 : n * rDoc.GetCodeCount()));
541 0 : for (size_t i = 0; i < n; ++i)
542 : {
543 0 : SCTAB nDestTab = (*mpNewTabs)[i];
544 0 : SCTAB nNewTab = nDestTab;
545 0 : SCTAB nOldTab = (*mpOldTabs)[i];
546 0 : if (nDestTab > MAXTAB) // appended ?
547 0 : nDestTab = rDoc.GetTableCount() - 1;
548 :
549 0 : rDoc.MoveTab( nOldTab, nNewTab, pProgress.get() );
550 0 : pViewShell->GetViewData().MoveTab( nOldTab, nNewTab );
551 0 : pViewShell->SetTabNo( nDestTab, true );
552 0 : if (mpNewNames)
553 : {
554 0 : const OUString& rNewName = (*mpNewNames)[i];
555 0 : rDoc.RenameTab(nNewTab, rNewName);
556 : }
557 0 : }
558 : }
559 :
560 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator
561 :
562 0 : pDocShell->PostPaintGridAll();
563 0 : pDocShell->PostPaintExtras();
564 0 : pDocShell->PostDataChanged();
565 0 : }
566 :
567 0 : void ScUndoMoveTab::Undo()
568 : {
569 0 : DoChange( true );
570 0 : }
571 :
572 0 : void ScUndoMoveTab::Redo()
573 : {
574 0 : DoChange( false );
575 0 : }
576 :
577 0 : void ScUndoMoveTab::Repeat(SfxRepeatTarget& /* rTarget */)
578 : {
579 : // No Repeat ! ? !
580 0 : }
581 :
582 0 : bool ScUndoMoveTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const
583 : {
584 0 : return false;
585 : }
586 :
587 0 : ScUndoCopyTab::ScUndoCopyTab(
588 : ScDocShell* pNewDocShell,
589 : vector<SCTAB>* pOldTabs, vector<SCTAB>* pNewTabs,
590 : vector<OUString>* pNewNames) :
591 : ScSimpleUndo( pNewDocShell ),
592 : mpOldTabs(pOldTabs),
593 : mpNewTabs(pNewTabs),
594 : mpNewNames(pNewNames),
595 0 : pDrawUndo( NULL )
596 : {
597 0 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
598 :
599 0 : if (mpNewNames && mpNewTabs->size() != mpNewNames->size())
600 : // The sizes differ. Something is wrong.
601 0 : mpNewNames.reset();
602 0 : }
603 :
604 0 : ScUndoCopyTab::~ScUndoCopyTab()
605 : {
606 0 : DeleteSdrUndoAction( pDrawUndo );
607 0 : }
608 :
609 0 : OUString ScUndoCopyTab::GetComment() const
610 : {
611 0 : return ScGlobal::GetRscString( STR_UNDO_COPY_TAB );
612 : }
613 :
614 0 : void ScUndoCopyTab::DoChange() const
615 : {
616 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
617 :
618 0 : if (pViewShell)
619 0 : pViewShell->SetTabNo((*mpOldTabs)[0],true);
620 :
621 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator
622 :
623 0 : pDocShell->PostPaintGridAll();
624 0 : pDocShell->PostPaintExtras();
625 0 : pDocShell->PostDataChanged();
626 0 : }
627 :
628 0 : void ScUndoCopyTab::Undo()
629 : {
630 0 : ScDocument& rDoc = pDocShell->GetDocument();
631 :
632 0 : DoSdrUndoAction( pDrawUndo, &rDoc ); // before the sheets are deleted
633 :
634 0 : vector<SCTAB>::const_reverse_iterator itr, itrEnd = mpNewTabs->rend();
635 0 : for (itr = mpNewTabs->rbegin(); itr != itrEnd; ++itr)
636 : {
637 0 : SCTAB nDestTab = *itr;
638 0 : if (nDestTab > MAXTAB) // append?
639 0 : nDestTab = rDoc.GetTableCount() - 1;
640 :
641 0 : bDrawIsInUndo = true;
642 0 : rDoc.DeleteTab(nDestTab);
643 0 : bDrawIsInUndo = false;
644 : }
645 :
646 : // ScTablesHint broadcasts after all sheets have been deleted,
647 : // so sheets and draw pages are in sync!
648 :
649 0 : for (itr = mpNewTabs->rbegin(); itr != itrEnd; ++itr)
650 : {
651 0 : SCTAB nDestTab = *itr;
652 0 : if (nDestTab > MAXTAB) // append?
653 0 : nDestTab = rDoc.GetTableCount() - 1;
654 :
655 0 : pDocShell->Broadcast( ScTablesHint( SC_TAB_DELETED, nDestTab ) );
656 : }
657 :
658 0 : DoChange();
659 0 : }
660 :
661 0 : void ScUndoCopyTab::Redo()
662 : {
663 0 : ScDocument& rDoc = pDocShell->GetDocument();
664 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
665 :
666 0 : SCTAB nDestTab = 0;
667 0 : for (size_t i = 0, n = mpNewTabs->size(); i < n; ++i)
668 : {
669 0 : nDestTab = (*mpNewTabs)[i];
670 0 : SCTAB nNewTab = nDestTab;
671 0 : SCTAB nOldTab = (*mpOldTabs)[i];
672 0 : if (nDestTab > MAXTAB) // appended ?
673 0 : nDestTab = rDoc.GetTableCount() - 1;
674 :
675 0 : bDrawIsInUndo = true;
676 0 : rDoc.CopyTab( nOldTab, nNewTab );
677 0 : bDrawIsInUndo = false;
678 :
679 0 : pViewShell->GetViewData().MoveTab( nOldTab, nNewTab );
680 :
681 0 : SCTAB nAdjSource = nOldTab;
682 0 : if ( nNewTab <= nOldTab )
683 0 : ++nAdjSource; // new position of source table after CopyTab
684 :
685 0 : if ( rDoc.IsScenario(nAdjSource) )
686 : {
687 0 : rDoc.SetScenario(nNewTab, true );
688 0 : OUString aComment;
689 0 : Color aColor;
690 : sal_uInt16 nScenFlags;
691 0 : rDoc.GetScenarioData(nAdjSource, aComment, aColor, nScenFlags );
692 0 : rDoc.SetScenarioData(nNewTab, aComment, aColor, nScenFlags );
693 0 : bool bActive = rDoc.IsActiveScenario(nAdjSource);
694 0 : rDoc.SetActiveScenario(nNewTab, bActive );
695 0 : bool bVisible = rDoc.IsVisible(nAdjSource);
696 0 : rDoc.SetVisible(nNewTab,bVisible );
697 : }
698 :
699 0 : if ( rDoc.IsTabProtected( nAdjSource ) )
700 0 : rDoc.CopyTabProtection(nAdjSource, nNewTab);
701 :
702 0 : if (mpNewNames)
703 : {
704 0 : const OUString& rName = (*mpNewNames)[i];
705 0 : rDoc.RenameTab(nNewTab, rName);
706 : }
707 : }
708 :
709 0 : RedoSdrUndoAction( pDrawUndo ); // after the sheets are inserted
710 :
711 0 : pViewShell->SetTabNo( nDestTab, true ); // after draw-undo
712 :
713 0 : DoChange();
714 :
715 0 : }
716 :
717 0 : void ScUndoCopyTab::Repeat(SfxRepeatTarget& /* rTarget */)
718 : {
719 : // no Repeat ! ? !
720 0 : }
721 :
722 0 : bool ScUndoCopyTab::CanRepeat(SfxRepeatTarget& /* rTarget */) const
723 : {
724 0 : return false;
725 : }
726 :
727 1 : ScUndoTabColor::ScUndoTabColor(
728 : ScDocShell* pNewDocShell, SCTAB nT, const Color& aOTabBgColor, const Color& aNTabBgColor) :
729 1 : ScSimpleUndo( pNewDocShell )
730 : {
731 1 : ScUndoTabColorInfo aInfo(nT);
732 1 : aInfo.maOldTabBgColor = aOTabBgColor;
733 1 : aInfo.maNewTabBgColor = aNTabBgColor;
734 1 : aTabColorList.push_back(aInfo);
735 1 : }
736 :
737 0 : ScUndoTabColor::ScUndoTabColor(
738 : ScDocShell* pNewDocShell,
739 : const ScUndoTabColorInfo::List& rUndoTabColorList) :
740 : ScSimpleUndo(pNewDocShell),
741 0 : aTabColorList(rUndoTabColorList)
742 : {
743 0 : }
744 :
745 0 : ScUndoTabColor::~ScUndoTabColor()
746 : {
747 0 : }
748 :
749 0 : OUString ScUndoTabColor::GetComment() const
750 : {
751 0 : if (aTabColorList.size() > 1)
752 0 : return ScGlobal::GetRscString(STR_UNDO_SET_MULTI_TAB_BG_COLOR);
753 0 : return ScGlobal::GetRscString(STR_UNDO_SET_TAB_BG_COLOR);
754 : }
755 :
756 2 : void ScUndoTabColor::DoChange(bool bUndoType) const
757 : {
758 2 : ScDocument& rDoc = pDocShell->GetDocument();
759 :
760 2 : size_t nTabColorCount = aTabColorList.size();
761 4 : for (size_t i = 0; i < nTabColorCount; ++i)
762 : {
763 2 : const ScUndoTabColorInfo& rTabColor = aTabColorList[i];
764 : rDoc.SetTabBgColor(rTabColor.mnTabId,
765 2 : bUndoType ? rTabColor.maOldTabBgColor : rTabColor.maNewTabBgColor);
766 : }
767 :
768 2 : pDocShell->PostPaintExtras();
769 2 : ScDocShellModificator aModificator( *pDocShell );
770 2 : aModificator.SetDocumentModified();
771 2 : }
772 :
773 1 : void ScUndoTabColor::Undo()
774 : {
775 1 : DoChange(true);
776 1 : }
777 :
778 1 : void ScUndoTabColor::Redo()
779 : {
780 1 : DoChange(false);
781 1 : }
782 :
783 0 : void ScUndoTabColor::Repeat(SfxRepeatTarget& /* rTarget */)
784 : {
785 : // makes no sense
786 0 : }
787 :
788 0 : bool ScUndoTabColor::CanRepeat(SfxRepeatTarget& /* rTarget */) const
789 : {
790 0 : return false;
791 : }
792 :
793 1 : ScUndoMakeScenario::ScUndoMakeScenario( ScDocShell* pNewDocShell,
794 : SCTAB nSrc, SCTAB nDest,
795 : const OUString& rN, const OUString& rC,
796 : const Color& rCol, sal_uInt16 nF,
797 : const ScMarkData& rMark ) :
798 : ScSimpleUndo( pNewDocShell ),
799 1 : mpMarkData(new ScMarkData(rMark)),
800 : nSrcTab( nSrc ),
801 : nDestTab( nDest ),
802 : aName( rN ),
803 : aComment( rC ),
804 : aColor( rCol ),
805 : nFlags( nF ),
806 2 : pDrawUndo( NULL )
807 : {
808 1 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
809 1 : }
810 :
811 3 : ScUndoMakeScenario::~ScUndoMakeScenario()
812 : {
813 1 : DeleteSdrUndoAction( pDrawUndo );
814 2 : }
815 :
816 5 : OUString ScUndoMakeScenario::GetComment() const
817 : {
818 5 : return ScGlobal::GetRscString( STR_UNDO_MAKESCENARIO );
819 : }
820 :
821 0 : void ScUndoMakeScenario::Undo()
822 : {
823 0 : ScDocument& rDoc = pDocShell->GetDocument();
824 :
825 0 : pDocShell->SetInUndo( true );
826 0 : bDrawIsInUndo = true;
827 0 : rDoc.DeleteTab( nDestTab );
828 0 : bDrawIsInUndo = false;
829 0 : pDocShell->SetInUndo( false );
830 :
831 0 : DoSdrUndoAction( pDrawUndo, &rDoc );
832 :
833 0 : pDocShell->PostPaint(0,0,nDestTab,MAXCOL,MAXROW,MAXTAB, PAINT_ALL);
834 0 : pDocShell->PostDataChanged();
835 :
836 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
837 0 : if (pViewShell)
838 0 : pViewShell->SetTabNo( nSrcTab, true );
839 :
840 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
841 :
842 : // SetTabNo(...,sal_True) for all views to sync with drawing layer pages
843 0 : pDocShell->Broadcast( SfxSimpleHint( SC_HINT_FORCESETTAB ) );
844 0 : }
845 :
846 0 : void ScUndoMakeScenario::Redo()
847 : {
848 0 : SetViewMarkData(*mpMarkData);
849 :
850 0 : RedoSdrUndoAction( pDrawUndo ); // Draw Redo first
851 :
852 0 : pDocShell->SetInUndo( true );
853 0 : bDrawIsInUndo = true;
854 :
855 0 : pDocShell->MakeScenario( nSrcTab, aName, aComment, aColor, nFlags, *mpMarkData, false );
856 :
857 0 : bDrawIsInUndo = false;
858 0 : pDocShell->SetInUndo( false );
859 :
860 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
861 0 : if (pViewShell)
862 0 : pViewShell->SetTabNo( nDestTab, true );
863 :
864 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
865 0 : }
866 :
867 0 : void ScUndoMakeScenario::Repeat(SfxRepeatTarget& rTarget)
868 : {
869 0 : if (rTarget.ISA(ScTabViewTarget))
870 : {
871 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->MakeScenario( aName, aComment, aColor, nFlags );
872 : }
873 0 : }
874 :
875 2 : bool ScUndoMakeScenario::CanRepeat(SfxRepeatTarget& rTarget) const
876 : {
877 2 : return rTarget.ISA(ScTabViewTarget);
878 : }
879 :
880 0 : ScUndoImportTab::ScUndoImportTab( ScDocShell* pShell,
881 : SCTAB nNewTab, SCTAB nNewCount ) :
882 : ScSimpleUndo( pShell ),
883 : nTab( nNewTab ),
884 : nCount( nNewCount ),
885 : pRedoDoc( NULL ),
886 0 : pDrawUndo( NULL )
887 : {
888 0 : pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
889 0 : }
890 :
891 0 : ScUndoImportTab::~ScUndoImportTab()
892 : {
893 0 : delete pRedoDoc;
894 0 : DeleteSdrUndoAction( pDrawUndo );
895 0 : }
896 :
897 0 : OUString ScUndoImportTab::GetComment() const
898 : {
899 0 : return ScGlobal::GetRscString( STR_UNDO_INSERT_TAB );
900 : }
901 :
902 0 : void ScUndoImportTab::DoChange() const
903 : {
904 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
905 0 : ScDocument& rDoc = pDocShell->GetDocument();
906 0 : SCTAB nTabCount = rDoc.GetTableCount();
907 0 : if (pViewShell)
908 : {
909 0 : if(nTab<nTabCount)
910 : {
911 0 : pViewShell->SetTabNo(nTab,true);
912 : }
913 : else
914 : {
915 0 : pViewShell->SetTabNo(nTab-1,true);
916 : }
917 : }
918 :
919 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); // Navigator
920 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB,
921 0 : PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS );
922 0 : }
923 :
924 0 : void ScUndoImportTab::Undo()
925 : {
926 : // Inserted range names, etc.
927 :
928 : SCTAB i;
929 0 : ScDocument& rDoc = pDocShell->GetDocument();
930 0 : bool bMakeRedo = !pRedoDoc;
931 0 : if (bMakeRedo)
932 : {
933 0 : pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
934 0 : pRedoDoc->InitUndo( &rDoc, nTab,nTab+nCount-1, true,true );
935 :
936 0 : OUString aOldName;
937 0 : for (i=0; i<nCount; i++)
938 : {
939 0 : SCTAB nTabPos=nTab+i;
940 :
941 0 : rDoc.CopyToDocument(0,0,nTabPos, MAXCOL,MAXROW,nTabPos, IDF_ALL,false, pRedoDoc );
942 0 : rDoc.GetName( nTabPos, aOldName );
943 0 : pRedoDoc->RenameTab( nTabPos, aOldName, false );
944 0 : pRedoDoc->SetTabBgColor( nTabPos, rDoc.GetTabBgColor(nTabPos) );
945 :
946 0 : if ( rDoc.IsScenario(nTabPos) )
947 : {
948 0 : pRedoDoc->SetScenario(nTabPos, true );
949 0 : OUString aComment;
950 0 : Color aColor;
951 : sal_uInt16 nScenFlags;
952 0 : rDoc.GetScenarioData(nTabPos, aComment, aColor, nScenFlags );
953 0 : pRedoDoc->SetScenarioData(nTabPos, aComment, aColor, nScenFlags );
954 0 : bool bActive = rDoc.IsActiveScenario(nTabPos);
955 0 : pRedoDoc->SetActiveScenario(nTabPos, bActive );
956 0 : bool bVisible = rDoc.IsVisible(nTabPos);
957 0 : pRedoDoc->SetVisible(nTabPos,bVisible );
958 : }
959 :
960 0 : if ( rDoc.IsTabProtected( nTabPos ) )
961 0 : pRedoDoc->SetTabProtection(nTabPos, rDoc.GetTabProtection(nTabPos));
962 0 : }
963 :
964 : }
965 :
966 0 : DoSdrUndoAction( pDrawUndo, &rDoc ); // before the sheets are deleted
967 :
968 0 : bDrawIsInUndo = true;
969 0 : for (i=0; i<nCount; i++)
970 0 : rDoc.DeleteTab( nTab );
971 0 : bDrawIsInUndo = false;
972 :
973 0 : DoChange();
974 0 : }
975 :
976 0 : void ScUndoImportTab::Redo()
977 : {
978 0 : if (!pRedoDoc)
979 : {
980 : OSL_FAIL("Where is my Redo Document?");
981 0 : return;
982 : }
983 :
984 0 : ScDocument& rDoc = pDocShell->GetDocument();
985 0 : OUString aName;
986 : SCTAB i;
987 0 : for (i=0; i<nCount; i++) // first insert all sheets (#63304#)
988 : {
989 0 : SCTAB nTabPos=nTab+i;
990 0 : pRedoDoc->GetName(nTabPos,aName);
991 0 : bDrawIsInUndo = true;
992 0 : rDoc.InsertTab(nTabPos,aName);
993 0 : bDrawIsInUndo = false;
994 : }
995 0 : for (i=0; i<nCount; i++) // then copy into inserted sheets
996 : {
997 0 : SCTAB nTabPos=nTab+i;
998 0 : pRedoDoc->CopyToDocument(0,0,nTabPos, MAXCOL,MAXROW,nTabPos, IDF_ALL,false, &rDoc );
999 0 : rDoc.SetTabBgColor( nTabPos, pRedoDoc->GetTabBgColor(nTabPos) );
1000 :
1001 0 : if ( pRedoDoc->IsScenario(nTabPos) )
1002 : {
1003 0 : rDoc.SetScenario(nTabPos, true );
1004 0 : OUString aComment;
1005 0 : Color aColor;
1006 : sal_uInt16 nScenFlags;
1007 0 : pRedoDoc->GetScenarioData(nTabPos, aComment, aColor, nScenFlags );
1008 0 : rDoc.SetScenarioData(nTabPos, aComment, aColor, nScenFlags );
1009 0 : bool bActive = pRedoDoc->IsActiveScenario(nTabPos);
1010 0 : rDoc.SetActiveScenario(nTabPos, bActive );
1011 0 : bool bVisible=pRedoDoc->IsVisible(nTabPos);
1012 0 : rDoc.SetVisible(nTabPos,bVisible );
1013 : }
1014 :
1015 0 : if ( pRedoDoc->IsTabProtected( nTabPos ) )
1016 0 : rDoc.SetTabProtection(nTabPos, pRedoDoc->GetTabProtection(nTabPos));
1017 : }
1018 :
1019 0 : RedoSdrUndoAction( pDrawUndo ); // after the sheets are inserted
1020 :
1021 0 : DoChange();
1022 : }
1023 :
1024 0 : void ScUndoImportTab::Repeat(SfxRepeatTarget& rTarget)
1025 : {
1026 0 : if (rTarget.ISA(ScTabViewTarget))
1027 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData().GetDispatcher().
1028 0 : Execute(FID_INS_TABLE, SfxCallMode::SLOT | SfxCallMode::RECORD);
1029 0 : }
1030 :
1031 0 : bool ScUndoImportTab::CanRepeat(SfxRepeatTarget& rTarget) const
1032 : {
1033 0 : return rTarget.ISA(ScTabViewTarget);
1034 : }
1035 :
1036 0 : ScUndoRemoveLink::ScUndoRemoveLink( ScDocShell* pShell, const OUString& rDocName ) :
1037 : ScSimpleUndo( pShell ),
1038 : aDocName( rDocName ),
1039 : nRefreshDelay( 0 ),
1040 0 : nCount( 0 )
1041 : {
1042 0 : ScDocument& rDoc = pDocShell->GetDocument();
1043 0 : SCTAB nTabCount = rDoc.GetTableCount();
1044 0 : pTabs = new SCTAB[nTabCount];
1045 0 : pModes = new sal_uInt8[nTabCount];
1046 0 : pTabNames = new OUString[nTabCount];
1047 :
1048 0 : for (SCTAB i=0; i<nTabCount; i++)
1049 : {
1050 0 : sal_uInt8 nMode = rDoc.GetLinkMode(i);
1051 0 : if (nMode)
1052 0 : if (rDoc.GetLinkDoc(i) == aDocName)
1053 : {
1054 0 : if (!nCount)
1055 : {
1056 0 : aFltName = rDoc.GetLinkFlt(i);
1057 0 : aOptions = rDoc.GetLinkOpt(i);
1058 0 : nRefreshDelay = rDoc.GetLinkRefreshDelay(i);
1059 : }
1060 : else
1061 : {
1062 : OSL_ENSURE(OUString(aFltName) == rDoc.GetLinkFlt(i) &&
1063 : OUString(aOptions) == rDoc.GetLinkOpt(i),
1064 : "different Filter for a Document?");
1065 : }
1066 0 : pTabs[nCount] = i;
1067 0 : pModes[nCount] = nMode;
1068 0 : pTabNames[nCount] = rDoc.GetLinkTab(i);
1069 0 : ++nCount;
1070 : }
1071 : }
1072 0 : }
1073 :
1074 0 : ScUndoRemoveLink::~ScUndoRemoveLink()
1075 : {
1076 0 : delete pTabs;
1077 0 : delete pModes;
1078 0 : delete[] pTabNames;
1079 0 : }
1080 :
1081 0 : OUString ScUndoRemoveLink::GetComment() const
1082 : {
1083 0 : return ScGlobal::GetRscString( STR_UNDO_REMOVELINK );
1084 : }
1085 :
1086 0 : void ScUndoRemoveLink::DoChange( bool bLink ) const
1087 : {
1088 0 : ScDocument& rDoc = pDocShell->GetDocument();
1089 0 : OUString aEmpty;
1090 0 : for (sal_uInt16 i=0; i<nCount; i++)
1091 0 : if (bLink) // establish link
1092 0 : rDoc.SetLink( pTabs[i], pModes[i], aDocName, aFltName, aOptions, pTabNames[i], nRefreshDelay );
1093 : else // remove link
1094 0 : rDoc.SetLink( pTabs[i], SC_LINK_NONE, aEmpty, aEmpty, aEmpty, aEmpty, 0 );
1095 0 : pDocShell->UpdateLinks();
1096 0 : }
1097 :
1098 0 : void ScUndoRemoveLink::Undo()
1099 : {
1100 0 : DoChange( true );
1101 0 : }
1102 :
1103 0 : void ScUndoRemoveLink::Redo()
1104 : {
1105 0 : DoChange( false );
1106 0 : }
1107 :
1108 0 : void ScUndoRemoveLink::Repeat(SfxRepeatTarget& /* rTarget */)
1109 : {
1110 : // makes no sense
1111 0 : }
1112 :
1113 0 : bool ScUndoRemoveLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1114 : {
1115 0 : return false;
1116 : }
1117 :
1118 2 : ScUndoShowHideTab::ScUndoShowHideTab( ScDocShell* pShell, const std::vector<SCTAB>& newUndoTabs, bool bNewShow ) :
1119 : ScSimpleUndo( pShell ),
1120 : undoTabs( newUndoTabs ),
1121 2 : bShow( bNewShow )
1122 : {
1123 2 : }
1124 :
1125 4 : ScUndoShowHideTab::~ScUndoShowHideTab()
1126 : {
1127 4 : }
1128 :
1129 0 : void ScUndoShowHideTab::DoChange( bool bShowP ) const
1130 : {
1131 0 : ScDocument& rDoc = pDocShell->GetDocument();
1132 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1133 :
1134 : SCTAB nTab;
1135 :
1136 0 : for(std::vector<SCTAB>::const_iterator itr = undoTabs.begin(), itrEnd = undoTabs.end(); itr != itrEnd; ++itr)
1137 : {
1138 0 : nTab = *itr;
1139 0 : rDoc.SetVisible( nTab, bShowP );
1140 0 : if (pViewShell)
1141 0 : pViewShell->SetTabNo(nTab,true);
1142 : }
1143 :
1144 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1145 0 : pDocShell->SetDocumentModified();
1146 0 : }
1147 :
1148 0 : void ScUndoShowHideTab::Undo()
1149 : {
1150 0 : DoChange(!bShow);
1151 0 : }
1152 :
1153 0 : void ScUndoShowHideTab::Redo()
1154 : {
1155 0 : DoChange(bShow);
1156 0 : }
1157 :
1158 0 : void ScUndoShowHideTab::Repeat(SfxRepeatTarget& rTarget)
1159 : {
1160 0 : if (rTarget.ISA(ScTabViewTarget))
1161 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData().GetDispatcher().
1162 : Execute( bShow ? FID_TABLE_SHOW : FID_TABLE_HIDE,
1163 0 : SfxCallMode::SLOT | SfxCallMode::RECORD);
1164 0 : }
1165 :
1166 2 : bool ScUndoShowHideTab::CanRepeat(SfxRepeatTarget& rTarget) const
1167 : {
1168 2 : return rTarget.ISA(ScTabViewTarget);
1169 : }
1170 :
1171 6 : OUString ScUndoShowHideTab::GetComment() const
1172 : {
1173 : sal_uInt16 nId;
1174 6 : if (undoTabs.size() > 1)
1175 : {
1176 0 : nId = bShow ? STR_UNDO_SHOWTABS : STR_UNDO_HIDETABS;
1177 : }
1178 : else
1179 : {
1180 6 : nId = bShow ? STR_UNDO_SHOWTAB : STR_UNDO_HIDETAB;
1181 : }
1182 :
1183 6 : return ScGlobal::GetRscString( nId );
1184 : }
1185 :
1186 2 : ScUndoDocProtect::ScUndoDocProtect(ScDocShell* pShell, unique_ptr<ScDocProtection> && pProtectSettings) :
1187 : ScSimpleUndo(pShell),
1188 2 : mpProtectSettings(std::move(pProtectSettings))
1189 : {
1190 2 : }
1191 :
1192 4 : ScUndoDocProtect::~ScUndoDocProtect()
1193 : {
1194 4 : }
1195 :
1196 0 : void ScUndoDocProtect::DoProtect(bool bProtect)
1197 : {
1198 0 : ScDocument& rDoc = pDocShell->GetDocument();
1199 :
1200 0 : if (bProtect)
1201 : {
1202 : // set protection.
1203 0 : unique_ptr<ScDocProtection> pCopy(new ScDocProtection(*mpProtectSettings));
1204 0 : pCopy->setProtected(true);
1205 0 : rDoc.SetDocProtection(pCopy.get());
1206 : }
1207 : else
1208 : {
1209 : // remove protection.
1210 0 : rDoc.SetDocProtection(NULL);
1211 : }
1212 :
1213 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1214 0 : if (pViewShell)
1215 : {
1216 0 : pViewShell->UpdateLayerLocks();
1217 0 : pViewShell->UpdateInputHandler(true); // so that input can be immediately entered again
1218 : }
1219 :
1220 0 : pDocShell->PostPaintGridAll();
1221 0 : }
1222 :
1223 0 : void ScUndoDocProtect::Undo()
1224 : {
1225 0 : BeginUndo();
1226 0 : DoProtect(!mpProtectSettings->isProtected());
1227 0 : EndUndo();
1228 0 : }
1229 :
1230 0 : void ScUndoDocProtect::Redo()
1231 : {
1232 0 : BeginRedo();
1233 0 : DoProtect(mpProtectSettings->isProtected());
1234 0 : EndRedo();
1235 0 : }
1236 :
1237 0 : void ScUndoDocProtect::Repeat(SfxRepeatTarget& /* rTarget */)
1238 : {
1239 : // makes no sense
1240 0 : }
1241 :
1242 2 : bool ScUndoDocProtect::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1243 : {
1244 2 : return false; // makes no sense
1245 : }
1246 :
1247 4 : OUString ScUndoDocProtect::GetComment() const
1248 : {
1249 4 : sal_uInt16 nId = mpProtectSettings->isProtected() ? STR_UNDO_PROTECT_DOC : STR_UNDO_UNPROTECT_DOC;
1250 4 : return ScGlobal::GetRscString( nId );
1251 : }
1252 :
1253 0 : ScUndoTabProtect::ScUndoTabProtect(ScDocShell* pShell, SCTAB nTab, unique_ptr<ScTableProtection> && pProtectSettings) :
1254 : ScSimpleUndo(pShell),
1255 : mnTab(nTab),
1256 0 : mpProtectSettings(std::move(pProtectSettings))
1257 : {
1258 0 : }
1259 :
1260 0 : ScUndoTabProtect::~ScUndoTabProtect()
1261 : {
1262 0 : }
1263 :
1264 0 : void ScUndoTabProtect::DoProtect(bool bProtect)
1265 : {
1266 0 : ScDocument& rDoc = pDocShell->GetDocument();
1267 :
1268 0 : if (bProtect)
1269 : {
1270 : // set protection.
1271 0 : unique_ptr<ScTableProtection> pCopy(new ScTableProtection(*mpProtectSettings));
1272 0 : pCopy->setProtected(true);
1273 0 : rDoc.SetTabProtection(mnTab, pCopy.get());
1274 : }
1275 : else
1276 : {
1277 : // remove protection.
1278 0 : rDoc.SetTabProtection(mnTab, NULL);
1279 : }
1280 :
1281 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1282 0 : if (pViewShell)
1283 : {
1284 0 : pViewShell->UpdateLayerLocks();
1285 0 : pViewShell->UpdateInputHandler(true); // so that input can be immediately entered again
1286 : }
1287 :
1288 0 : pDocShell->PostPaintGridAll();
1289 0 : }
1290 :
1291 0 : void ScUndoTabProtect::Undo()
1292 : {
1293 0 : BeginUndo();
1294 0 : DoProtect(!mpProtectSettings->isProtected());
1295 0 : EndUndo();
1296 0 : }
1297 :
1298 0 : void ScUndoTabProtect::Redo()
1299 : {
1300 0 : BeginRedo();
1301 0 : DoProtect(mpProtectSettings->isProtected());
1302 0 : EndRedo();
1303 0 : }
1304 :
1305 0 : void ScUndoTabProtect::Repeat(SfxRepeatTarget& /* rTarget */)
1306 : {
1307 : // makes no sense
1308 0 : }
1309 :
1310 0 : bool ScUndoTabProtect::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1311 : {
1312 0 : return false; // makes no sense
1313 : }
1314 :
1315 0 : OUString ScUndoTabProtect::GetComment() const
1316 : {
1317 0 : sal_uInt16 nId = mpProtectSettings->isProtected() ? STR_UNDO_PROTECT_TAB : STR_UNDO_UNPROTECT_TAB;
1318 0 : return ScGlobal::GetRscString( nId );
1319 : }
1320 :
1321 2 : ScUndoPrintRange::ScUndoPrintRange( ScDocShell* pShell, SCTAB nNewTab,
1322 : ScPrintRangeSaver* pOld, ScPrintRangeSaver* pNew ) :
1323 : ScSimpleUndo( pShell ),
1324 : nTab( nNewTab ),
1325 : pOldRanges( pOld ),
1326 2 : pNewRanges( pNew )
1327 : {
1328 2 : }
1329 :
1330 6 : ScUndoPrintRange::~ScUndoPrintRange()
1331 : {
1332 2 : delete pOldRanges;
1333 2 : delete pNewRanges;
1334 4 : }
1335 :
1336 0 : void ScUndoPrintRange::DoChange(bool bUndo)
1337 : {
1338 0 : ScDocument& rDoc = pDocShell->GetDocument();
1339 0 : if (bUndo)
1340 0 : rDoc.RestorePrintRanges( *pOldRanges );
1341 : else
1342 0 : rDoc.RestorePrintRanges( *pNewRanges );
1343 :
1344 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1345 0 : if (pViewShell)
1346 0 : pViewShell->SetTabNo( nTab );
1347 :
1348 0 : ScPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab ).UpdatePages();
1349 :
1350 0 : pDocShell->PostPaint( ScRange(0,0,nTab,MAXCOL,MAXROW,nTab), PAINT_GRID );
1351 0 : }
1352 :
1353 0 : void ScUndoPrintRange::Undo()
1354 : {
1355 0 : BeginUndo();
1356 0 : DoChange( true );
1357 0 : EndUndo();
1358 0 : }
1359 :
1360 0 : void ScUndoPrintRange::Redo()
1361 : {
1362 0 : BeginRedo();
1363 0 : DoChange( false );
1364 0 : EndRedo();
1365 0 : }
1366 :
1367 0 : void ScUndoPrintRange::Repeat(SfxRepeatTarget& /* rTarget */)
1368 : {
1369 : // makes no sense
1370 0 : }
1371 :
1372 0 : bool ScUndoPrintRange::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1373 : {
1374 0 : return false; // makes no sense
1375 : }
1376 :
1377 2 : OUString ScUndoPrintRange::GetComment() const
1378 : {
1379 2 : return ScGlobal::GetRscString( STR_UNDO_PRINTRANGES );
1380 : }
1381 :
1382 0 : ScUndoScenarioFlags::ScUndoScenarioFlags( ScDocShell* pNewDocShell, SCTAB nT,
1383 : const OUString& rON, const OUString& rNN, const OUString& rOC, const OUString& rNC,
1384 : const Color& rOCol, const Color& rNCol, sal_uInt16 nOF, sal_uInt16 nNF ) :
1385 : ScSimpleUndo( pNewDocShell ),
1386 : nTab ( nT ),
1387 : aOldName ( rON ),
1388 : aNewName ( rNN ),
1389 : aOldComment ( rOC ),
1390 : aNewComment ( rNC ),
1391 : aOldColor ( rOCol ),
1392 : aNewColor ( rNCol ),
1393 : nOldFlags ( nOF ),
1394 0 : nNewFlags ( nNF )
1395 : {
1396 0 : }
1397 :
1398 0 : ScUndoScenarioFlags::~ScUndoScenarioFlags()
1399 : {
1400 0 : }
1401 :
1402 0 : OUString ScUndoScenarioFlags::GetComment() const
1403 : {
1404 0 : return ScGlobal::GetRscString( STR_UNDO_EDITSCENARIO );
1405 : }
1406 :
1407 0 : void ScUndoScenarioFlags::Undo()
1408 : {
1409 0 : ScDocument& rDoc = pDocShell->GetDocument();
1410 :
1411 0 : rDoc.RenameTab( nTab, aOldName );
1412 0 : rDoc.SetScenarioData( nTab, aOldComment, aOldColor, nOldFlags );
1413 :
1414 0 : pDocShell->PostPaintGridAll();
1415 : // The sheet name might be used in a formula ...
1416 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1417 0 : if (pViewShell)
1418 0 : pViewShell->UpdateInputHandler();
1419 :
1420 0 : if ( aOldName != aNewName )
1421 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1422 0 : }
1423 :
1424 0 : void ScUndoScenarioFlags::Redo()
1425 : {
1426 0 : ScDocument& rDoc = pDocShell->GetDocument();
1427 :
1428 0 : rDoc.RenameTab( nTab, aNewName );
1429 0 : rDoc.SetScenarioData( nTab, aNewComment, aNewColor, nNewFlags );
1430 :
1431 0 : pDocShell->PostPaintGridAll();
1432 : // The sheet name might be used in a formula ...
1433 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1434 0 : if (pViewShell)
1435 0 : pViewShell->UpdateInputHandler();
1436 :
1437 0 : if ( aOldName != aNewName )
1438 0 : SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
1439 0 : }
1440 :
1441 0 : void ScUndoScenarioFlags::Repeat(SfxRepeatTarget& /* rTarget */)
1442 : {
1443 : // Repeat makes no sense
1444 0 : }
1445 :
1446 0 : bool ScUndoScenarioFlags::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1447 : {
1448 0 : return false;
1449 : }
1450 :
1451 : // (move to different file?)
1452 0 : ScUndoRenameObject::ScUndoRenameObject( ScDocShell* pNewDocShell, const OUString& rPN,
1453 : const OUString& rON, const OUString& rNN ) :
1454 : ScSimpleUndo( pNewDocShell ),
1455 : aPersistName( rPN ),
1456 : aOldName ( rON ),
1457 0 : aNewName ( rNN )
1458 : {
1459 0 : }
1460 :
1461 0 : ScUndoRenameObject::~ScUndoRenameObject()
1462 : {
1463 0 : }
1464 :
1465 0 : OUString ScUndoRenameObject::GetComment() const
1466 : {
1467 : // string resource shared with title for dialog
1468 0 : return OUString( ScResId(SCSTR_RENAMEOBJECT) );
1469 : }
1470 :
1471 0 : SdrObject* ScUndoRenameObject::GetObject()
1472 : {
1473 0 : ScDocument& rDoc = pDocShell->GetDocument();
1474 0 : ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer();
1475 0 : if ( pDrawLayer )
1476 : {
1477 0 : sal_uInt16 nCount = pDrawLayer->GetPageCount();
1478 0 : for (sal_uInt16 nTab=0; nTab<nCount; nTab++)
1479 : {
1480 0 : SdrPage* pPage = pDrawLayer->GetPage(nTab);
1481 : assert(pPage && "Page ?");
1482 :
1483 0 : SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
1484 0 : SdrObject* pObject = aIter.Next();
1485 0 : while (pObject)
1486 : {
1487 0 : if ( pObject->GetObjIdentifier() == OBJ_OLE2 &&
1488 0 : static_cast<SdrOle2Obj*>(pObject)->GetPersistName() == aPersistName )
1489 : {
1490 0 : return pObject;
1491 : }
1492 :
1493 0 : pObject = aIter.Next();
1494 : }
1495 0 : }
1496 : }
1497 : OSL_FAIL("Object not found");
1498 0 : return NULL;
1499 : }
1500 :
1501 0 : void ScUndoRenameObject::Undo()
1502 : {
1503 0 : BeginUndo();
1504 0 : SdrObject* pObj = GetObject();
1505 0 : if ( pObj )
1506 0 : pObj->SetName( aOldName );
1507 0 : EndUndo();
1508 0 : }
1509 :
1510 0 : void ScUndoRenameObject::Redo()
1511 : {
1512 0 : BeginRedo();
1513 0 : SdrObject* pObj = GetObject();
1514 0 : if ( pObj )
1515 0 : pObj->SetName( aNewName );
1516 0 : EndRedo();
1517 0 : }
1518 :
1519 0 : void ScUndoRenameObject::Repeat(SfxRepeatTarget& /* rTarget */)
1520 : {
1521 0 : }
1522 :
1523 0 : bool ScUndoRenameObject::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1524 : {
1525 0 : return false;
1526 : }
1527 :
1528 4 : ScUndoLayoutRTL::ScUndoLayoutRTL( ScDocShell* pShell, SCTAB nNewTab, bool bNewRTL ) :
1529 : ScSimpleUndo( pShell ),
1530 : nTab( nNewTab ),
1531 4 : bRTL( bNewRTL )
1532 : {
1533 4 : }
1534 :
1535 8 : ScUndoLayoutRTL::~ScUndoLayoutRTL()
1536 : {
1537 8 : }
1538 :
1539 0 : void ScUndoLayoutRTL::DoChange( bool bNew )
1540 : {
1541 0 : pDocShell->SetInUndo( true );
1542 :
1543 0 : ScDocument& rDoc = pDocShell->GetDocument();
1544 0 : rDoc.SetLayoutRTL( nTab, bNew );
1545 :
1546 0 : ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1547 0 : if (pViewShell)
1548 0 : pViewShell->SetTabNo(nTab,true);
1549 :
1550 0 : pDocShell->SetDocumentModified();
1551 :
1552 0 : pDocShell->SetInUndo( false );
1553 0 : }
1554 :
1555 0 : void ScUndoLayoutRTL::Undo()
1556 : {
1557 0 : DoChange(!bRTL);
1558 0 : }
1559 :
1560 0 : void ScUndoLayoutRTL::Redo()
1561 : {
1562 0 : DoChange(bRTL);
1563 0 : }
1564 :
1565 0 : void ScUndoLayoutRTL::Repeat(SfxRepeatTarget& rTarget)
1566 : {
1567 0 : if (rTarget.ISA(ScTabViewTarget))
1568 0 : static_cast<ScTabViewTarget&>(rTarget).GetViewShell()->GetViewData().GetDispatcher().
1569 0 : Execute( FID_TAB_RTL, SfxCallMode::SLOT | SfxCallMode::RECORD);
1570 0 : }
1571 :
1572 2 : bool ScUndoLayoutRTL::CanRepeat(SfxRepeatTarget& rTarget) const
1573 : {
1574 2 : return rTarget.ISA(ScTabViewTarget);
1575 : }
1576 :
1577 8 : OUString ScUndoLayoutRTL::GetComment() const
1578 : {
1579 8 : return ScGlobal::GetRscString( STR_UNDO_TAB_RTL );
1580 156 : }
1581 :
1582 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
