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