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