xref: /aoo4110/main/sc/source/ui/undo/undodat.cxx (revision b1cdbd2c)
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 ---------------------------------------------------------------
28 
29 #include <sfx2/app.hxx>
30 
31 #include "undodat.hxx"
32 #include "undoutil.hxx"
33 #include "undoolk.hxx"
34 #include "document.hxx"
35 #include "docsh.hxx"
36 #include "tabvwsh.hxx"
37 #include "olinetab.hxx"
38 #include "dbcolect.hxx"
39 #include "rangenam.hxx"
40 #include "pivot.hxx"
41 #include "globstr.hrc"
42 #include "global.hxx"
43 #include "target.hxx"
44 #include "chartarr.hxx"
45 #include "dbdocfun.hxx"
46 #include "olinefun.hxx"
47 #include "dpobject.hxx"
48 #include "attrib.hxx"
49 #include "hints.hxx"
50 #include "sc.hrc"
51 
52 // -----------------------------------------------------------------------
53 
54 TYPEINIT1(ScUndoDoOutline,          ScSimpleUndo);
55 TYPEINIT1(ScUndoMakeOutline,        ScSimpleUndo);
56 TYPEINIT1(ScUndoOutlineLevel,       ScSimpleUndo);
57 TYPEINIT1(ScUndoOutlineBlock,       ScSimpleUndo);
58 TYPEINIT1(ScUndoRemoveAllOutlines,  ScSimpleUndo);
59 TYPEINIT1(ScUndoAutoOutline,        ScSimpleUndo);
60 TYPEINIT1(ScUndoSubTotals,          ScDBFuncUndo);
61 TYPEINIT1(ScUndoSort,               ScDBFuncUndo);
62 TYPEINIT1(ScUndoQuery,              ScDBFuncUndo);
63 TYPEINIT1(ScUndoAutoFilter,         ScDBFuncUndo);
64 TYPEINIT1(ScUndoDBData,             ScSimpleUndo);
65 TYPEINIT1(ScUndoImportData,         ScSimpleUndo);
66 TYPEINIT1(ScUndoRepeatDB,           ScSimpleUndo);
67 //UNUSED2008-05  TYPEINIT1(ScUndoPivot,              ScSimpleUndo);
68 TYPEINIT1(ScUndoDataPilot,          ScSimpleUndo);
69 TYPEINIT1(ScUndoConsolidate,        ScSimpleUndo);
70 TYPEINIT1(ScUndoChartData,          ScSimpleUndo);
71 
72 // -----------------------------------------------------------------------
73 
74 
75 //
76 //		Outline-Gruppen ein- oder ausblenden
77 //
78 
ScUndoDoOutline(ScDocShell * pNewDocShell,SCCOLROW nNewStart,SCCOLROW nNewEnd,SCTAB nNewTab,ScDocument * pNewUndoDoc,sal_Bool bNewColumns,sal_uInt16 nNewLevel,sal_uInt16 nNewEntry,sal_Bool bNewShow)79 ScUndoDoOutline::ScUndoDoOutline( ScDocShell* pNewDocShell,
80 							SCCOLROW nNewStart, SCCOLROW nNewEnd, SCTAB nNewTab,
81 							ScDocument* pNewUndoDoc, sal_Bool bNewColumns,
82 							sal_uInt16 nNewLevel, sal_uInt16 nNewEntry, sal_Bool bNewShow ) :
83 	ScSimpleUndo( pNewDocShell ),
84 	nStart( nNewStart ),
85 	nEnd( nNewEnd ),
86 	nTab( nNewTab ),
87 	pUndoDoc( pNewUndoDoc ),
88 	bColumns( bNewColumns ),
89 	nLevel( nNewLevel ),
90 	nEntry( nNewEntry ),
91 	bShow( bNewShow )
92 {
93 }
94 
~ScUndoDoOutline()95 __EXPORT ScUndoDoOutline::~ScUndoDoOutline()
96 {
97 	delete pUndoDoc;
98 }
99 
GetComment() const100 String __EXPORT ScUndoDoOutline::GetComment() const
101 {	// Detail einblenden" "Detail ausblenden"
102 	return bShow ?
103 		ScGlobal::GetRscString( STR_UNDO_DOOUTLINE ) :
104 		ScGlobal::GetRscString( STR_UNDO_REDOOUTLINE );
105 }
106 
Undo()107 void __EXPORT ScUndoDoOutline::Undo()
108 {
109 	BeginUndo();
110 
111 	ScDocument* pDoc = pDocShell->GetDocument();
112 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
113 
114 	//	Tabelle muss vorher umgeschaltet sein (#46952#) !!!
115 
116 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
117 	if ( nVisTab != nTab )
118 		pViewShell->SetTabNo( nTab );
119 
120 	//	inverse Funktion ausfuehren
121 
122 	if (bShow)
123 		pViewShell->HideOutline( bColumns, nLevel, nEntry, sal_False, sal_False );
124 	else
125 		pViewShell->ShowOutline( bColumns, nLevel, nEntry, sal_False, sal_False );
126 
127 	//	Original Spalten-/Zeilenstatus
128 
129 	if (bColumns)
130         pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
131                 static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, sal_False, pDoc);
132 	else
133 		pUndoDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, sal_False, pDoc );
134 
135 	pViewShell->UpdateScrollBars();
136 
137 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP);
138 
139 	EndUndo();
140 }
141 
Redo()142 void __EXPORT ScUndoDoOutline::Redo()
143 {
144 	BeginRedo();
145 
146 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
147 
148 	//	Tabelle muss vorher umgeschaltet sein (#46952#) !!!
149 
150 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
151 	if ( nVisTab != nTab )
152 		pViewShell->SetTabNo( nTab );
153 
154 	if (bShow)
155 		pViewShell->ShowOutline( bColumns, nLevel, nEntry, sal_False );
156 	else
157 		pViewShell->HideOutline( bColumns, nLevel, nEntry, sal_False );
158 
159 	EndRedo();
160 }
161 
Repeat(SfxRepeatTarget &)162 void __EXPORT ScUndoDoOutline::Repeat(SfxRepeatTarget& /* rTarget */)
163 {
164 }
165 
CanRepeat(SfxRepeatTarget &) const166 sal_Bool __EXPORT ScUndoDoOutline::CanRepeat(SfxRepeatTarget& /* rTarget */) const
167 {
168 	return sal_False;						// geht nicht
169 }
170 
171 //
172 //		Outline-Gruppen erzeugen oder loeschen
173 //
174 
ScUndoMakeOutline(ScDocShell * pNewDocShell,SCCOL nStartX,SCROW nStartY,SCTAB nStartZ,SCCOL nEndX,SCROW nEndY,SCTAB nEndZ,ScOutlineTable * pNewUndoTab,sal_Bool bNewColumns,sal_Bool bNewMake)175 ScUndoMakeOutline::ScUndoMakeOutline( ScDocShell* pNewDocShell,
176 							SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
177 							SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
178 							ScOutlineTable* pNewUndoTab, sal_Bool bNewColumns, sal_Bool bNewMake ) :
179 	ScSimpleUndo( pNewDocShell ),
180 	aBlockStart( nStartX, nStartY, nStartZ ),
181 	aBlockEnd( nEndX, nEndY, nEndZ ),
182 	pUndoTable( pNewUndoTab ),
183 	bColumns( bNewColumns ),
184 	bMake( bNewMake )
185 {
186 }
187 
~ScUndoMakeOutline()188 __EXPORT ScUndoMakeOutline::~ScUndoMakeOutline()
189 {
190 	delete pUndoTable;
191 }
192 
GetComment() const193 String __EXPORT ScUndoMakeOutline::GetComment() const
194 {	// "Gruppierung" "Gruppierung aufheben"
195 	return bMake ?
196 		ScGlobal::GetRscString( STR_UNDO_MAKEOUTLINE ) :
197 		ScGlobal::GetRscString( STR_UNDO_REMAKEOUTLINE );
198 }
199 
Undo()200 void __EXPORT ScUndoMakeOutline::Undo()
201 {
202 	BeginUndo();
203 
204 	ScDocument* pDoc = pDocShell->GetDocument();
205 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
206 	SCTAB nTab = aBlockStart.Tab();
207 
208 	ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart, aBlockEnd );
209 
210 	pDoc->SetOutlineTable( nTab, pUndoTable );
211 
212 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
213 	if ( nVisTab != nTab )
214 		pViewShell->SetTabNo( nTab );
215 
216 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
217 
218 	EndUndo();
219 }
220 
Redo()221 void __EXPORT ScUndoMakeOutline::Redo()
222 {
223 	BeginRedo();
224 
225 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
226 
227 	ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart, aBlockEnd );
228 
229 	if (bMake)
230 		pViewShell->MakeOutline( bColumns, sal_False );
231 	else
232 		pViewShell->RemoveOutline( bColumns, sal_False );
233 
234 	pDocShell->PostPaint(0,0,aBlockStart.Tab(),MAXCOL,MAXROW,aBlockEnd.Tab(),PAINT_GRID);
235 
236 	EndRedo();
237 }
238 
Repeat(SfxRepeatTarget & rTarget)239 void __EXPORT ScUndoMakeOutline::Repeat(SfxRepeatTarget& rTarget)
240 {
241 	if (rTarget.ISA(ScTabViewTarget))
242 	{
243 		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
244 
245 		if (bMake)
246 			rViewShell.MakeOutline( bColumns, sal_True );
247 		else
248 			rViewShell.RemoveOutline( bColumns, sal_True );
249 	}
250 }
251 
CanRepeat(SfxRepeatTarget & rTarget) const252 sal_Bool __EXPORT ScUndoMakeOutline::CanRepeat(SfxRepeatTarget& rTarget) const
253 {
254 	return (rTarget.ISA(ScTabViewTarget));
255 }
256 
257 //
258 //		Outline-Ebene auswaehlen
259 //
260 
ScUndoOutlineLevel(ScDocShell * pNewDocShell,SCCOLROW nNewStart,SCCOLROW nNewEnd,SCTAB nNewTab,ScDocument * pNewUndoDoc,ScOutlineTable * pNewUndoTab,sal_Bool bNewColumns,sal_uInt16 nNewLevel)261 ScUndoOutlineLevel::ScUndoOutlineLevel( ScDocShell* pNewDocShell,
262 						SCCOLROW nNewStart, SCCOLROW nNewEnd, SCTAB nNewTab,
263 						ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
264 						sal_Bool bNewColumns, sal_uInt16 nNewLevel ) :
265 	ScSimpleUndo( pNewDocShell ),
266 	nStart( nNewStart ),
267 	nEnd( nNewEnd ),
268 	nTab( nNewTab ),
269 	pUndoDoc( pNewUndoDoc ),
270 	pUndoTable( pNewUndoTab ),
271 	bColumns( bNewColumns ),
272 	nLevel( nNewLevel )
273 {
274 }
275 
~ScUndoOutlineLevel()276 __EXPORT ScUndoOutlineLevel::~ScUndoOutlineLevel()
277 {
278 	delete pUndoDoc;
279 	delete pUndoTable;
280 }
281 
GetComment() const282 String __EXPORT ScUndoOutlineLevel::GetComment() const
283 {	// "Gliederungsebene auswaehlen";
284 	return ScGlobal::GetRscString( STR_UNDO_OUTLINELEVEL );
285 }
286 
Undo()287 void __EXPORT ScUndoOutlineLevel::Undo()
288 {
289 	BeginUndo();
290 
291 	ScDocument* pDoc = pDocShell->GetDocument();
292 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
293 
294 	//	Original Outline-Table
295 
296 	pDoc->SetOutlineTable( nTab, pUndoTable );
297 
298 	//	Original Spalten-/Zeilenstatus
299 
300 	if (bColumns)
301         pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
302                 static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, sal_False, pDoc);
303 	else
304 		pUndoDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, sal_False, pDoc );
305 
306 	pDoc->UpdatePageBreaks( nTab );
307 
308 	pViewShell->UpdateScrollBars();
309 
310 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
311 	if ( nVisTab != nTab )
312 		pViewShell->SetTabNo( nTab );
313 
314 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP);
315 
316 	EndUndo();
317 }
318 
Redo()319 void __EXPORT ScUndoOutlineLevel::Redo()
320 {
321 	BeginRedo();
322 
323 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
324 
325 	//	Tabelle muss vorher umgeschaltet sein (#46952#) !!!
326 
327 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
328 	if ( nVisTab != nTab )
329 		pViewShell->SetTabNo( nTab );
330 
331 	pViewShell->SelectLevel( bColumns, nLevel, sal_False );
332 
333 	EndRedo();
334 }
335 
Repeat(SfxRepeatTarget & rTarget)336 void __EXPORT ScUndoOutlineLevel::Repeat(SfxRepeatTarget& rTarget)
337 {
338 	if (rTarget.ISA(ScTabViewTarget))
339 		((ScTabViewTarget&)rTarget).GetViewShell()->SelectLevel( bColumns, nLevel, sal_True );
340 }
341 
CanRepeat(SfxRepeatTarget & rTarget) const342 sal_Bool __EXPORT ScUndoOutlineLevel::CanRepeat(SfxRepeatTarget& rTarget) const
343 {
344 	return (rTarget.ISA(ScTabViewTarget));
345 }
346 
347 //
348 //		Outline ueber Blockmarken ein- oder ausblenden
349 //
350 
ScUndoOutlineBlock(ScDocShell * pNewDocShell,SCCOL nStartX,SCROW nStartY,SCTAB nStartZ,SCCOL nEndX,SCROW nEndY,SCTAB nEndZ,ScDocument * pNewUndoDoc,ScOutlineTable * pNewUndoTab,sal_Bool bNewShow)351 ScUndoOutlineBlock::ScUndoOutlineBlock( ScDocShell* pNewDocShell,
352 						SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
353 						SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
354 						ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab, sal_Bool bNewShow ) :
355 	ScSimpleUndo( pNewDocShell ),
356 	aBlockStart( nStartX, nStartY, nStartZ ),
357 	aBlockEnd( nEndX, nEndY, nEndZ ),
358 	pUndoDoc( pNewUndoDoc ),
359 	pUndoTable( pNewUndoTab ),
360 	bShow( bNewShow )
361 {
362 }
363 
~ScUndoOutlineBlock()364 __EXPORT ScUndoOutlineBlock::~ScUndoOutlineBlock()
365 {
366 	delete pUndoDoc;
367 	delete pUndoTable;
368 }
369 
GetComment() const370 String __EXPORT ScUndoOutlineBlock::GetComment() const
371 {	// "Detail einblenden" "Detail ausblenden"
372 	return bShow ?
373 		ScGlobal::GetRscString( STR_UNDO_DOOUTLINEBLK ) :
374 		ScGlobal::GetRscString( STR_UNDO_REDOOUTLINEBLK );
375 }
376 
Undo()377 void __EXPORT ScUndoOutlineBlock::Undo()
378 {
379 	BeginUndo();
380 
381 	ScDocument* pDoc = pDocShell->GetDocument();
382 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
383 	SCTAB nTab = aBlockStart.Tab();
384 
385 	//	Original Outline-Table
386 
387 	pDoc->SetOutlineTable( nTab, pUndoTable );
388 
389 	//	Original Spalten-/Zeilenstatus
390 
391 	SCCOLROW	nStartCol = aBlockStart.Col();
392 	SCCOLROW	nEndCol = aBlockEnd.Col();
393 	SCCOLROW	nStartRow = aBlockStart.Row();
394 	SCCOLROW	nEndRow = aBlockEnd.Row();
395 
396 	if (!bShow)
397 	{								//	Groesse des ausgeblendeten Blocks
398 		sal_uInt16 nLevel;
399 		pUndoTable->GetColArray()->FindTouchedLevel( nStartCol, nEndCol, nLevel );
400 		pUndoTable->GetColArray()->ExtendBlock( nLevel, nStartCol, nEndCol );
401 		pUndoTable->GetRowArray()->FindTouchedLevel( nStartRow, nEndRow, nLevel );
402 		pUndoTable->GetRowArray()->ExtendBlock( nLevel, nStartRow, nEndRow );
403 	}
404 
405     pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
406             static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, sal_False, pDoc );
407 	pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, sal_False, pDoc );
408 
409 	pDoc->UpdatePageBreaks( nTab );
410 
411 	pViewShell->UpdateScrollBars();
412 
413 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
414 	if ( nVisTab != nTab )
415 		pViewShell->SetTabNo( nTab );
416 
417 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP);
418 
419 	EndUndo();
420 }
421 
Redo()422 void __EXPORT ScUndoOutlineBlock::Redo()
423 {
424 	BeginRedo();
425 
426 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
427 
428 	ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart, aBlockEnd );
429 	if (bShow)
430 		pViewShell->ShowMarkedOutlines( sal_False );
431 	else
432 		pViewShell->HideMarkedOutlines( sal_False );
433 
434 	EndRedo();
435 }
436 
Repeat(SfxRepeatTarget & rTarget)437 void __EXPORT ScUndoOutlineBlock::Repeat(SfxRepeatTarget& rTarget)
438 {
439 	if (rTarget.ISA(ScTabViewTarget))
440 	{
441 		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
442 
443 		if (bShow)
444 			rViewShell.ShowMarkedOutlines( sal_True );
445 		else
446 			rViewShell.HideMarkedOutlines( sal_True );
447 	}
448 }
449 
CanRepeat(SfxRepeatTarget & rTarget) const450 sal_Bool __EXPORT ScUndoOutlineBlock::CanRepeat(SfxRepeatTarget& rTarget) const
451 {
452 	return (rTarget.ISA(ScTabViewTarget));
453 }
454 
455 //
456 //		alle Outlines loeschen
457 //
458 
ScUndoRemoveAllOutlines(ScDocShell * pNewDocShell,SCCOL nStartX,SCROW nStartY,SCTAB nStartZ,SCCOL nEndX,SCROW nEndY,SCTAB nEndZ,ScDocument * pNewUndoDoc,ScOutlineTable * pNewUndoTab)459 ScUndoRemoveAllOutlines::ScUndoRemoveAllOutlines( ScDocShell* pNewDocShell,
460 									SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
461 									SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
462 									ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab ) :
463 	ScSimpleUndo( pNewDocShell ),
464 	aBlockStart( nStartX, nStartY, nStartZ ),
465 	aBlockEnd( nEndX, nEndY, nEndZ ),
466 	pUndoDoc( pNewUndoDoc ),
467 	pUndoTable( pNewUndoTab )
468 {
469 }
470 
~ScUndoRemoveAllOutlines()471 __EXPORT ScUndoRemoveAllOutlines::~ScUndoRemoveAllOutlines()
472 {
473 	delete pUndoDoc;
474 	delete pUndoTable;
475 }
476 
GetComment() const477 String __EXPORT ScUndoRemoveAllOutlines::GetComment() const
478 {	// "Gliederung entfernen"
479 	return ScGlobal::GetRscString( STR_UNDO_REMOVEALLOTLNS );
480 }
481 
Undo()482 void __EXPORT ScUndoRemoveAllOutlines::Undo()
483 {
484 	BeginUndo();
485 
486 	ScDocument* pDoc = pDocShell->GetDocument();
487 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
488 	SCTAB nTab = aBlockStart.Tab();
489 
490 	//	Original Outline-Table
491 
492 	pDoc->SetOutlineTable( nTab, pUndoTable );
493 
494 	//	Original Spalten-/Zeilenstatus
495 
496 	SCCOL	nStartCol = aBlockStart.Col();
497 	SCCOL	nEndCol = aBlockEnd.Col();
498 	SCROW	nStartRow = aBlockStart.Row();
499 	SCROW	nEndRow = aBlockEnd.Row();
500 
501 	pUndoDoc->CopyToDocument( nStartCol, 0, nTab, nEndCol, MAXROW, nTab, IDF_NONE, sal_False, pDoc );
502 	pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, sal_False, pDoc );
503 
504 	pDoc->UpdatePageBreaks( nTab );
505 
506 	pViewShell->UpdateScrollBars();
507 
508 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
509 	if ( nVisTab != nTab )
510 		pViewShell->SetTabNo( nTab );
511 
512 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
513 
514 	EndUndo();
515 }
516 
Redo()517 void __EXPORT ScUndoRemoveAllOutlines::Redo()
518 {
519 	BeginRedo();
520 
521 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
522 
523 	//	Tabelle muss vorher umgeschaltet sein (#46952#) !!!
524 
525 	SCTAB nTab = aBlockStart.Tab();
526 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
527 	if ( nVisTab != nTab )
528 		pViewShell->SetTabNo( nTab );
529 
530 	pViewShell->RemoveAllOutlines( sal_False );
531 
532 	EndRedo();
533 }
534 
Repeat(SfxRepeatTarget & rTarget)535 void __EXPORT ScUndoRemoveAllOutlines::Repeat(SfxRepeatTarget& rTarget)
536 {
537 	if (rTarget.ISA(ScTabViewTarget))
538 		((ScTabViewTarget&)rTarget).GetViewShell()->RemoveAllOutlines( sal_True );
539 }
540 
CanRepeat(SfxRepeatTarget & rTarget) const541 sal_Bool __EXPORT ScUndoRemoveAllOutlines::CanRepeat(SfxRepeatTarget& rTarget) const
542 {
543 	return (rTarget.ISA(ScTabViewTarget));
544 }
545 
546 //
547 //		Auto-Outline
548 //
549 
ScUndoAutoOutline(ScDocShell * pNewDocShell,SCCOL nStartX,SCROW nStartY,SCTAB nStartZ,SCCOL nEndX,SCROW nEndY,SCTAB nEndZ,ScDocument * pNewUndoDoc,ScOutlineTable * pNewUndoTab)550 ScUndoAutoOutline::ScUndoAutoOutline( ScDocShell* pNewDocShell,
551 									SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
552 									SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
553 									ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab ) :
554 	ScSimpleUndo( pNewDocShell ),
555 	aBlockStart( nStartX, nStartY, nStartZ ),
556 	aBlockEnd( nEndX, nEndY, nEndZ ),
557 	pUndoDoc( pNewUndoDoc ),
558 	pUndoTable( pNewUndoTab )
559 {
560 }
561 
~ScUndoAutoOutline()562 __EXPORT ScUndoAutoOutline::~ScUndoAutoOutline()
563 {
564 	delete pUndoDoc;
565 	delete pUndoTable;
566 }
567 
GetComment() const568 String __EXPORT ScUndoAutoOutline::GetComment() const
569 {	// "Auto-Gliederung"
570 	return ScGlobal::GetRscString( STR_UNDO_AUTOOUTLINE );
571 }
572 
Undo()573 void __EXPORT ScUndoAutoOutline::Undo()
574 {
575 	BeginUndo();
576 
577 	ScDocument* pDoc = pDocShell->GetDocument();
578 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
579 	SCTAB nTab = aBlockStart.Tab();
580 
581 	//	Original Outline-Table
582 
583 	pDoc->SetOutlineTable( nTab, pUndoTable );
584 
585 	//	Original Spalten-/Zeilenstatus
586 
587 	if (pUndoDoc && pUndoTable)
588 	{
589 		SCCOLROW nStartCol;
590 		SCCOLROW nStartRow;
591 		SCCOLROW nEndCol;
592 		SCCOLROW nEndRow;
593 		pUndoTable->GetColArray()->GetRange( nStartCol, nEndCol );
594 		pUndoTable->GetRowArray()->GetRange( nStartRow, nEndRow );
595 
596         pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
597                 static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, sal_False,
598                 pDoc);
599 		pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, sal_False, pDoc );
600 
601 		pViewShell->UpdateScrollBars();
602 	}
603 
604 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
605 	if ( nVisTab != nTab )
606 		pViewShell->SetTabNo( nTab );
607 
608 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
609 
610 	EndUndo();
611 }
612 
Redo()613 void __EXPORT ScUndoAutoOutline::Redo()
614 {
615 	BeginRedo();
616 
617 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
618 
619 	SCTAB nTab = aBlockStart.Tab();
620 	if (pViewShell)
621 	{
622 		//	Tabelle muss vorher umgeschaltet sein (#46952#) !!!
623 
624 		SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
625 		if ( nVisTab != nTab )
626 			pViewShell->SetTabNo( nTab );
627 	}
628 
629 	ScRange aRange( aBlockStart.Col(), aBlockStart.Row(), nTab,
630 					aBlockEnd.Col(),   aBlockEnd.Row(),   nTab );
631 	ScOutlineDocFunc aFunc( *pDocShell );
632 	aFunc.AutoOutline( aRange, sal_False, sal_False );
633 
634 	//	auf der View markieren
635 	//	Wenn's beim Aufruf eine Mehrfachselektion war, ist es jetzt der
636 	//	umschliessende Bereich...
637 
638 	if (pViewShell)
639 		pViewShell->MarkRange( aRange );
640 
641 	EndRedo();
642 }
643 
Repeat(SfxRepeatTarget & rTarget)644 void __EXPORT ScUndoAutoOutline::Repeat(SfxRepeatTarget& rTarget)
645 {
646 	if (rTarget.ISA(ScTabViewTarget))
647 		((ScTabViewTarget&)rTarget).GetViewShell()->AutoOutline( sal_True );
648 }
649 
CanRepeat(SfxRepeatTarget & rTarget) const650 sal_Bool __EXPORT ScUndoAutoOutline::CanRepeat(SfxRepeatTarget& rTarget) const
651 {
652 	return (rTarget.ISA(ScTabViewTarget));
653 }
654 
655 //
656 //		Zwischenergebnisse
657 //
658 
ScUndoSubTotals(ScDocShell * pNewDocShell,SCTAB nNewTab,const ScSubTotalParam & rNewParam,SCROW nNewEndY,ScDocument * pNewUndoDoc,ScOutlineTable * pNewUndoTab,ScRangeName * pNewUndoRange,ScDBCollection * pNewUndoDB)659 ScUndoSubTotals::ScUndoSubTotals( ScDocShell* pNewDocShell, SCTAB nNewTab,
660 								const ScSubTotalParam& rNewParam, SCROW nNewEndY,
661 								ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
662 								ScRangeName* pNewUndoRange, ScDBCollection* pNewUndoDB ) :
663 	ScDBFuncUndo( pNewDocShell, ScRange( rNewParam.nCol1, rNewParam.nRow1, nNewTab,
664 	                                     rNewParam.nCol2, rNewParam.nRow2, nNewTab ) ),
665 	nTab( nNewTab ),
666 	aParam( rNewParam ),
667 	nNewEndRow( nNewEndY ),
668 	pUndoDoc( pNewUndoDoc ),
669 	pUndoTable( pNewUndoTab ),
670 	pUndoRange( pNewUndoRange ),
671 	pUndoDB( pNewUndoDB )
672 {
673 }
674 
~ScUndoSubTotals()675 __EXPORT ScUndoSubTotals::~ScUndoSubTotals()
676 {
677 	delete pUndoDoc;
678 	delete pUndoTable;
679 	delete pUndoRange;
680 	delete pUndoDB;
681 }
682 
GetComment() const683 String __EXPORT ScUndoSubTotals::GetComment() const
684 {	// "Teilergebnisse"
685 	return ScGlobal::GetRscString( STR_UNDO_SUBTOTALS );
686 }
687 
Undo()688 void __EXPORT ScUndoSubTotals::Undo()
689 {
690 	BeginUndo();
691 
692 	ScDocument* pDoc = pDocShell->GetDocument();
693 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
694 
695 	//	um einzelnen DB-Bereich anzupassen
696 /*	ScDBData* pOldDBData = ScUndoUtil::GetOldDBData( pUndoDBData, pDoc, nTab,
697 										aParam.nCol1, aParam.nRow1, aParam.nCol2, nNewEndRow );
698 */
699 
700 	if (nNewEndRow > aParam.nRow2)
701 	{
702 		pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, aParam.nRow2+1, static_cast<SCSIZE>(nNewEndRow-aParam.nRow2) );
703 	}
704 	else if (nNewEndRow < aParam.nRow2)
705 	{
706 		pDoc->InsertRow( 0,nTab, MAXCOL,nTab, nNewEndRow+1, static_cast<SCSIZE>(aParam.nRow2-nNewEndRow) );
707 	}
708 
709 
710 	//	Original Outline-Table
711 
712 	pDoc->SetOutlineTable( nTab, pUndoTable );
713 
714 	//	Original Spalten-/Zeilenstatus
715 
716 	if (pUndoDoc && pUndoTable)
717 	{
718 		SCCOLROW nStartCol;
719 		SCCOLROW nStartRow;
720 		SCCOLROW nEndCol;
721 		SCCOLROW nEndRow;
722 		pUndoTable->GetColArray()->GetRange( nStartCol, nEndCol );
723 		pUndoTable->GetRowArray()->GetRange( nStartRow, nEndRow );
724 
725         pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
726                 static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, sal_False,
727                 pDoc);
728 		pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, sal_False, pDoc );
729 
730 		pViewShell->UpdateScrollBars();
731 	}
732 
733 	//	Original-Daten & Referenzen
734 
735 	ScUndoUtil::MarkSimpleBlock( pDocShell, 0, aParam.nRow1+1, nTab,
736 											MAXCOL, aParam.nRow2, nTab );
737 
738 	pDoc->DeleteAreaTab( 0,aParam.nRow1+1, MAXCOL,aParam.nRow2, nTab, IDF_ALL );
739 
740 	pUndoDoc->CopyToDocument( 0, aParam.nRow1+1, nTab, MAXCOL, aParam.nRow2, nTab,
741 															IDF_NONE, sal_False, pDoc );	// Flags
742 	pUndoDoc->UndoToDocument( 0, aParam.nRow1+1, nTab, MAXCOL, aParam.nRow2, nTab,
743 															IDF_ALL, sal_False, pDoc );
744 
745 	ScUndoUtil::MarkSimpleBlock( pDocShell, aParam.nCol1,aParam.nRow1,nTab,
746 											aParam.nCol2,aParam.nRow2,nTab );
747 
748 /*	if (pUndoDBData)
749 		*pOldDBData = *pUndoDBData;
750 */
751 	if (pUndoRange)
752 		pDoc->SetRangeName( new ScRangeName( *pUndoRange ) );
753 	if (pUndoDB)
754 		pDoc->SetDBCollection( new ScDBCollection( *pUndoDB ), sal_True );
755 
756 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
757 	if ( nVisTab != nTab )
758 		pViewShell->SetTabNo( nTab );
759 
760 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
761 	pDocShell->PostDataChanged();
762 
763 	EndUndo();
764 }
765 
Redo()766 void __EXPORT ScUndoSubTotals::Redo()
767 {
768 	BeginRedo();
769 
770 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
771 
772 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
773 	if ( nVisTab != nTab )
774 		pViewShell->SetTabNo( nTab );
775 
776 	ScUndoUtil::MarkSimpleBlock( pDocShell, aParam.nCol1,aParam.nRow1,nTab,
777 											aParam.nCol2,aParam.nRow2,nTab );
778 	pViewShell->DoSubTotals( aParam, sal_False );
779 
780 	EndRedo();
781 }
782 
Repeat(SfxRepeatTarget &)783 void __EXPORT ScUndoSubTotals::Repeat(SfxRepeatTarget& /* rTarget */)
784 {
785 }
786 
CanRepeat(SfxRepeatTarget &) const787 sal_Bool __EXPORT ScUndoSubTotals::CanRepeat(SfxRepeatTarget& /* rTarget */) const
788 {
789 	return sal_False;						// geht nicht wegen Spaltennummern
790 }
791 
792 //
793 //		Sortieren
794 //
795 
ScUndoSort(ScDocShell * pNewDocShell,SCTAB nNewTab,const ScSortParam & rParam,sal_Bool bQuery,ScDocument * pNewUndoDoc,ScDBCollection * pNewUndoDB,const ScRange * pDest)796 ScUndoSort::ScUndoSort( ScDocShell* pNewDocShell,
797 						SCTAB nNewTab, const ScSortParam& rParam,
798 						sal_Bool bQuery, ScDocument* pNewUndoDoc, ScDBCollection* pNewUndoDB,
799 						const ScRange* pDest ) :
800 	ScDBFuncUndo( pNewDocShell, ScRange( rParam.nCol1, rParam.nRow1, nNewTab,
801 	                                     rParam.nCol2, rParam.nRow2, nNewTab ) ),
802 	nTab( nNewTab ),
803 	aSortParam( rParam ),
804 	bRepeatQuery( bQuery ),
805 	pUndoDoc( pNewUndoDoc ),
806 	pUndoDB( pNewUndoDB ),
807 	bDestArea( sal_False )
808 {
809 	if ( pDest )
810 	{
811 		bDestArea = sal_True;
812 		aDestRange = *pDest;
813 	}
814 }
815 
~ScUndoSort()816 __EXPORT ScUndoSort::~ScUndoSort()
817 {
818 	delete pUndoDoc;
819 	delete pUndoDB;
820 }
821 
GetComment() const822 String __EXPORT ScUndoSort::GetComment() const
823 {
824 	return ScGlobal::GetRscString( STR_UNDO_SORT );
825 }
826 
Undo()827 void __EXPORT ScUndoSort::Undo()
828 {
829 	BeginUndo();
830 
831 	ScDocument* pDoc = pDocShell->GetDocument();
832 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
833 
834 	SCCOL nStartCol = aSortParam.nCol1;
835 	SCROW nStartRow = aSortParam.nRow1;
836 	SCCOL nEndCol	 = aSortParam.nCol2;
837 	SCROW nEndRow	 = aSortParam.nRow2;
838 	SCTAB nSortTab  = nTab;
839 	if ( !aSortParam.bInplace )
840 	{
841 		nStartCol = aSortParam.nDestCol;
842 		nStartRow = aSortParam.nDestRow;
843 		nEndCol   = nStartCol + ( aSortParam.nCol2 - aSortParam.nCol1 );
844 		nEndRow   = nStartRow + ( aSortParam.nRow2 - aSortParam.nRow1 );
845 		nSortTab  = aSortParam.nDestTab;
846 	}
847 
848 	ScUndoUtil::MarkSimpleBlock( pDocShell, nStartCol, nStartRow, nSortTab,
849 								 nEndCol, nEndRow, nSortTab );
850 
851     // do not delete/copy note captions, they are handled in drawing undo (ScDBFuncUndo::mpDrawUndo)
852     pDoc->DeleteAreaTab( nStartCol,nStartRow, nEndCol,nEndRow, nSortTab, IDF_ALL|IDF_NOCAPTIONS );
853 	pUndoDoc->CopyToDocument( nStartCol, nStartRow, nSortTab, nEndCol, nEndRow, nSortTab,
854                                 IDF_ALL|IDF_NOCAPTIONS, sal_False, pDoc );
855 
856 	if (bDestArea)
857 	{
858         // do not delete/copy note captions, they are handled in drawing undo (ScDBFuncUndo::mpDrawUndo)
859         pDoc->DeleteAreaTab( aDestRange, IDF_ALL|IDF_NOCAPTIONS );
860         pUndoDoc->CopyToDocument( aDestRange, IDF_ALL|IDF_NOCAPTIONS, sal_False, pDoc );
861 	}
862 
863 	//	Zeilenhoehen immer (wegen automatischer Anpassung)
864 	//!	auf ScBlockUndo umstellen
865 //	if (bRepeatQuery)
866 		pUndoDoc->CopyToDocument( 0, nStartRow, nSortTab, MAXCOL, nEndRow, nSortTab,
867 								IDF_NONE, sal_False, pDoc );
868 
869 	if (pUndoDB)
870 		pDoc->SetDBCollection( new ScDBCollection( *pUndoDB ), sal_True );
871 
872 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
873 	if ( nVisTab != nSortTab )
874 		pViewShell->SetTabNo( nSortTab );
875 
876 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
877 	pDocShell->PostDataChanged();
878 
879 	EndUndo();
880 }
881 
Redo()882 void __EXPORT ScUndoSort::Redo()
883 {
884 	BeginRedo();
885 
886 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
887 
888 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
889 	if ( nVisTab != nTab )
890 		pViewShell->SetTabNo( nTab );
891 
892 //	pViewShell->DoneBlockMode();
893 //	pViewShell->InitOwnBlockMode();
894 //	pViewShell->GetViewData()->GetMarkData() = aMarkData;	// CopyMarksTo
895 
896 	pViewShell->MarkRange( ScRange( aSortParam.nCol1, aSortParam.nRow1, nTab,
897 									  aSortParam.nCol2, aSortParam.nRow2, nTab ) );
898 
899 	pViewShell->Sort( aSortParam, sal_False );
900 
901 	//	Quellbereich painten wegen Markierung
902 	if ( !aSortParam.bInplace )
903 		pDocShell->PostPaint( aSortParam.nCol1, aSortParam.nRow1, nTab,
904 							  aSortParam.nCol2, aSortParam.nRow2, nTab, PAINT_GRID );
905 
906 	EndRedo();
907 }
908 
Repeat(SfxRepeatTarget &)909 void __EXPORT ScUndoSort::Repeat(SfxRepeatTarget& /* rTarget */)
910 {
911 }
912 
CanRepeat(SfxRepeatTarget &) const913 sal_Bool __EXPORT ScUndoSort::CanRepeat(SfxRepeatTarget& /* rTarget */) const
914 {
915 	return sal_False;						// geht nicht wegen Spaltennummern
916 }
917 
918 //
919 //		Filtern
920 //
921 
ScUndoQuery(ScDocShell * pNewDocShell,SCTAB nNewTab,const ScQueryParam & rParam,ScDocument * pNewUndoDoc,ScDBCollection * pNewUndoDB,const ScRange * pOld,sal_Bool bSize,const ScRange * pAdvSrc)922 ScUndoQuery::ScUndoQuery( ScDocShell* pNewDocShell, SCTAB nNewTab, const ScQueryParam& rParam,
923 							ScDocument* pNewUndoDoc, ScDBCollection* pNewUndoDB,
924 							const ScRange* pOld, sal_Bool bSize, const ScRange* pAdvSrc ) :
925 	ScDBFuncUndo( pNewDocShell, ScRange( rParam.nCol1, rParam.nRow1, nNewTab,
926 	                                     rParam.nCol2, rParam.nRow2, nNewTab ) ),
927 	pDrawUndo( NULL ),
928 	nTab( nNewTab ),
929 	aQueryParam( rParam ),
930 	pUndoDoc( pNewUndoDoc ),
931 //	pUndoDBData( pNewData )
932 	pUndoDB( pNewUndoDB ),
933 	bIsAdvanced( sal_False ),
934 	bDestArea( sal_False ),
935 	bDoSize( bSize )
936 {
937 	if ( pOld )
938 	{
939 		bDestArea = sal_True;
940 		aOldDest = *pOld;
941 	}
942 	if ( pAdvSrc )
943 	{
944 		bIsAdvanced = sal_True;
945 		aAdvSource = *pAdvSrc;
946 	}
947 
948     pDrawUndo = GetSdrUndoAction( pDocShell->GetDocument() );
949 }
950 
~ScUndoQuery()951 __EXPORT ScUndoQuery::~ScUndoQuery()
952 {
953 	delete pUndoDoc;
954 //	delete pUndoDBData;
955 	delete pUndoDB;
956     DeleteSdrUndoAction( pDrawUndo );
957 }
958 
GetComment() const959 String __EXPORT ScUndoQuery::GetComment() const
960 {	// "Filtern";
961 	return ScGlobal::GetRscString( STR_UNDO_QUERY );
962 }
963 
Undo()964 void __EXPORT ScUndoQuery::Undo()
965 {
966 	BeginUndo();
967 
968 	ScDocument* pDoc = pDocShell->GetDocument();
969 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
970 
971 	sal_Bool bCopy = !aQueryParam.bInplace;
972 	SCCOL nDestEndCol = 0;
973 	SCROW nDestEndRow = 0;
974 	if (bCopy)
975 	{
976 		nDestEndCol = aQueryParam.nDestCol + ( aQueryParam.nCol2-aQueryParam.nCol1 );
977 		nDestEndRow = aQueryParam.nDestRow + ( aQueryParam.nRow2-aQueryParam.nRow1 );
978 
979 		ScDBData* pData = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,
980 												aQueryParam.nDestTab, sal_True );
981 		if (pData)
982 		{
983 			ScRange aNewDest;
984 			pData->GetArea( aNewDest );
985 			nDestEndCol = aNewDest.aEnd.Col();
986 			nDestEndRow = aNewDest.aEnd.Row();
987 		}
988 
989 		if ( bDoSize && bDestArea )
990 		{
991 			//	aDestRange ist der alte Bereich
992 			pDoc->FitBlock( ScRange(
993 								aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
994 								nDestEndCol, nDestEndRow, aQueryParam.nDestTab ),
995 							aOldDest );
996 		}
997 
998 		ScUndoUtil::MarkSimpleBlock( pDocShell,
999 									aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
1000 									nDestEndCol, nDestEndRow, aQueryParam.nDestTab );
1001 		pDoc->DeleteAreaTab( aQueryParam.nDestCol, aQueryParam.nDestRow,
1002 							nDestEndCol, nDestEndRow, aQueryParam.nDestTab, IDF_ALL );
1003 
1004 		pViewShell->DoneBlockMode();
1005 
1006 		pUndoDoc->CopyToDocument( aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
1007 									nDestEndCol, nDestEndRow, aQueryParam.nDestTab,
1008 									IDF_ALL, sal_False, pDoc );
1009 		//	Attribute werden immer mitkopiert (#49287#)
1010 
1011 		//	Rest von altem Bereich
1012 		if ( bDestArea && !bDoSize )
1013 		{
1014 			pDoc->DeleteAreaTab( aOldDest, IDF_ALL );
1015 			pUndoDoc->CopyToDocument( aOldDest, IDF_ALL, sal_False, pDoc );
1016 		}
1017 	}
1018 	else
1019 		pUndoDoc->CopyToDocument( 0, aQueryParam.nRow1, nTab, MAXCOL, aQueryParam.nRow2, nTab,
1020 										IDF_NONE, sal_False, pDoc );
1021 
1022 	if (pUndoDB)
1023 		pDoc->SetDBCollection( new ScDBCollection( *pUndoDB ), sal_True );
1024 
1025 	if (!bCopy)
1026     {
1027         pDoc->InvalidatePageBreaks(nTab);
1028 		pDoc->UpdatePageBreaks( nTab );
1029     }
1030 
1031     ScRange aDirtyRange( 0 , aQueryParam.nRow1, nTab,
1032         MAXCOL, aQueryParam.nRow2, nTab );
1033     pDoc->SetDirty( aDirtyRange );
1034 
1035     DoSdrUndoAction( pDrawUndo, pDoc );
1036 
1037 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1038 	if ( nVisTab != nTab )
1039 		pViewShell->SetTabNo( nTab );
1040 
1041 		//	Paint
1042 
1043 	if (bCopy)
1044 	{
1045 		SCCOL nEndX = nDestEndCol;
1046 		SCROW nEndY = nDestEndRow;
1047 		if (bDestArea)
1048 		{
1049 			if ( aOldDest.aEnd.Col() > nEndX )
1050 				nEndX = aOldDest.aEnd.Col();
1051 			if ( aOldDest.aEnd.Row() > nEndY )
1052 				nEndY = aOldDest.aEnd.Row();
1053 		}
1054 		if (bDoSize)
1055 			nEndY = MAXROW;
1056 		pDocShell->PostPaint( aQueryParam.nDestCol, aQueryParam.nDestRow, aQueryParam.nDestTab,
1057 									nEndX, nEndY, aQueryParam.nDestTab, PAINT_GRID );
1058 	}
1059 	else
1060 		pDocShell->PostPaint( 0, aQueryParam.nRow1, nTab, MAXCOL, MAXROW, nTab,
1061 													PAINT_GRID | PAINT_LEFT );
1062 	pDocShell->PostDataChanged();
1063 
1064 	EndUndo();
1065 }
1066 
Redo()1067 void __EXPORT ScUndoQuery::Redo()
1068 {
1069 	BeginRedo();
1070 
1071 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1072 
1073 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1074 	if ( nVisTab != nTab )
1075 		pViewShell->SetTabNo( nTab );
1076 
1077 	if ( bIsAdvanced )
1078 		pViewShell->Query( aQueryParam, &aAdvSource, sal_False );
1079 	else
1080 		pViewShell->Query( aQueryParam, NULL, sal_False );
1081 
1082 	EndRedo();
1083 }
1084 
Repeat(SfxRepeatTarget &)1085 void __EXPORT ScUndoQuery::Repeat(SfxRepeatTarget& /* rTarget */)
1086 {
1087 }
1088 
CanRepeat(SfxRepeatTarget &) const1089 sal_Bool __EXPORT ScUndoQuery::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1090 {
1091 	return sal_False;						// geht nicht wegen Spaltennummern
1092 }
1093 
1094 //
1095 //      Show or hide AutoFilter buttons (doesn't include filter settings)
1096 //
1097 
ScUndoAutoFilter(ScDocShell * pNewDocShell,const ScRange & rRange,const String & rName,sal_Bool bSet)1098 ScUndoAutoFilter::ScUndoAutoFilter( ScDocShell* pNewDocShell, const ScRange& rRange,
1099                                     const String& rName, sal_Bool bSet ) :
1100     ScDBFuncUndo( pNewDocShell, rRange ),
1101     aDBName( rName ),
1102     bFilterSet( bSet )
1103 {
1104 }
1105 
~ScUndoAutoFilter()1106 ScUndoAutoFilter::~ScUndoAutoFilter()
1107 {
1108 }
1109 
GetComment() const1110 String ScUndoAutoFilter::GetComment() const
1111 {
1112     return ScGlobal::GetRscString( STR_UNDO_QUERY );    // same as ScUndoQuery
1113 }
1114 
DoChange(sal_Bool bUndo)1115 void ScUndoAutoFilter::DoChange( sal_Bool bUndo )
1116 {
1117     sal_Bool bNewFilter = bUndo ? !bFilterSet : bFilterSet;
1118 
1119     sal_uInt16 nIndex;
1120     ScDocument* pDoc = pDocShell->GetDocument();
1121     ScDBCollection* pColl = pDoc->GetDBCollection();
1122     if ( pColl->SearchName( aDBName, nIndex ) )
1123     {
1124         ScDBData* pDBData = (*pColl)[nIndex];
1125         pDBData->SetAutoFilter( bNewFilter );
1126 
1127         SCCOL nRangeX1;
1128         SCROW nRangeY1;
1129         SCCOL nRangeX2;
1130         SCROW nRangeY2;
1131         SCTAB nRangeTab;
1132         pDBData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
1133 
1134         if ( bNewFilter )
1135             pDoc->ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
1136         else
1137             pDoc->RemoveFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
1138 
1139         pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
1140     }
1141 }
1142 
Undo()1143 void ScUndoAutoFilter::Undo()
1144 {
1145     BeginUndo();
1146     DoChange( sal_True );
1147     EndUndo();
1148 }
1149 
Redo()1150 void ScUndoAutoFilter::Redo()
1151 {
1152     BeginRedo();
1153     DoChange( sal_False );
1154     EndRedo();
1155 }
1156 
Repeat(SfxRepeatTarget &)1157 void ScUndoAutoFilter::Repeat(SfxRepeatTarget& /* rTarget */)
1158 {
1159 }
1160 
CanRepeat(SfxRepeatTarget &) const1161 sal_Bool ScUndoAutoFilter::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1162 {
1163     return sal_False;
1164 }
1165 
1166 //
1167 //		Datenbankbereiche aendern (Dialog)
1168 //
1169 
ScUndoDBData(ScDocShell * pNewDocShell,ScDBCollection * pNewUndoColl,ScDBCollection * pNewRedoColl)1170 ScUndoDBData::ScUndoDBData( ScDocShell* pNewDocShell,
1171 							ScDBCollection* pNewUndoColl, ScDBCollection* pNewRedoColl ) :
1172 	ScSimpleUndo( pNewDocShell ),
1173 	pUndoColl( pNewUndoColl ),
1174 	pRedoColl( pNewRedoColl )
1175 {
1176 }
1177 
~ScUndoDBData()1178 __EXPORT ScUndoDBData::~ScUndoDBData()
1179 {
1180 	delete pUndoColl;
1181 	delete pRedoColl;
1182 }
1183 
GetComment() const1184 String __EXPORT ScUndoDBData::GetComment() const
1185 {	// "Datenbankbereiche aendern";
1186 	return ScGlobal::GetRscString( STR_UNDO_DBDATA );
1187 }
1188 
Undo()1189 void __EXPORT ScUndoDBData::Undo()
1190 {
1191 	BeginUndo();
1192 
1193 	ScDocument* pDoc = pDocShell->GetDocument();
1194 
1195 	sal_Bool bOldAutoCalc = pDoc->GetAutoCalc();
1196 	pDoc->SetAutoCalc( sal_False );			// unnoetige Berechnungen vermeiden
1197 	pDoc->CompileDBFormula( sal_True );		// CreateFormulaString
1198 	pDoc->SetDBCollection( new ScDBCollection(*pUndoColl), sal_True );
1199 	pDoc->CompileDBFormula( sal_False );	// CompileFormulaString
1200 	pDoc->SetAutoCalc( bOldAutoCalc );
1201 
1202 	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
1203 
1204 	EndUndo();
1205 }
1206 
Redo()1207 void __EXPORT ScUndoDBData::Redo()
1208 {
1209 	BeginRedo();
1210 
1211 	ScDocument* pDoc = pDocShell->GetDocument();
1212 
1213 	sal_Bool bOldAutoCalc = pDoc->GetAutoCalc();
1214 	pDoc->SetAutoCalc( sal_False );			// unnoetige Berechnungen vermeiden
1215 	pDoc->CompileDBFormula( sal_True );		// CreateFormulaString
1216 	pDoc->SetDBCollection( new ScDBCollection(*pRedoColl), sal_True );
1217 	pDoc->CompileDBFormula( sal_False );	// CompileFormulaString
1218 	pDoc->SetAutoCalc( bOldAutoCalc );
1219 
1220 	SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
1221 
1222 	EndRedo();
1223 }
1224 
Repeat(SfxRepeatTarget &)1225 void __EXPORT ScUndoDBData::Repeat(SfxRepeatTarget& /* rTarget */)
1226 {
1227 }
1228 
CanRepeat(SfxRepeatTarget &) const1229 sal_Bool __EXPORT ScUndoDBData::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1230 {
1231 	return sal_False;						// geht nicht
1232 }
1233 
1234 //
1235 //		Import
1236 //
1237 
ScUndoImportData(ScDocShell * pNewDocShell,SCTAB nNewTab,const ScImportParam & rParam,SCCOL nNewEndX,SCROW nNewEndY,SCCOL nNewFormula,ScDocument * pNewUndoDoc,ScDocument * pNewRedoDoc,ScDBData * pNewUndoData,ScDBData * pNewRedoData)1238 ScUndoImportData::ScUndoImportData( ScDocShell* pNewDocShell, SCTAB nNewTab,
1239 								const ScImportParam& rParam, SCCOL nNewEndX, SCROW nNewEndY,
1240 								SCCOL nNewFormula,
1241 								ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc,
1242 								ScDBData* pNewUndoData, ScDBData* pNewRedoData ) :
1243 	ScSimpleUndo( pNewDocShell ),
1244 	nTab( nNewTab ),
1245 	aImportParam( rParam ),
1246 	nEndCol( nNewEndX ),
1247 	nEndRow( nNewEndY ),
1248 	pUndoDoc( pNewUndoDoc ),
1249 	pRedoDoc( pNewRedoDoc ),
1250 	pUndoDBData( pNewUndoData ),
1251 	pRedoDBData( pNewRedoData ),
1252 	nFormulaCols( nNewFormula ),
1253 	bRedoFilled( sal_False )
1254 {
1255 	// redo doc doesn't contain imported data (but everything else)
1256 }
1257 
~ScUndoImportData()1258 __EXPORT ScUndoImportData::~ScUndoImportData()
1259 {
1260 	delete pUndoDoc;
1261 	delete pRedoDoc;
1262 	delete pUndoDBData;
1263 	delete pRedoDBData;
1264 }
1265 
GetComment() const1266 String __EXPORT ScUndoImportData::GetComment() const
1267 {	// "Importieren";
1268 	return ScGlobal::GetRscString( STR_UNDO_IMPORTDATA );
1269 }
1270 
Undo()1271 void __EXPORT ScUndoImportData::Undo()
1272 {
1273 	BeginUndo();
1274 
1275 	ScDocument* pDoc = pDocShell->GetDocument();
1276 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1277 
1278 	ScUndoUtil::MarkSimpleBlock( pDocShell, aImportParam.nCol1,aImportParam.nRow1,nTab,
1279 														nEndCol,nEndRow,nTab );
1280 
1281 	SCTAB nTable;
1282 	SCCOL nCol1, nCol2;
1283 	SCROW nRow1, nRow2;
1284 	ScDBData* pCurrentData = NULL;
1285 	if (pUndoDBData && pRedoDBData)
1286 	{
1287 		pRedoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1288 		pCurrentData = ScUndoUtil::GetOldDBData( pRedoDBData, pDoc, nTab,
1289 													nCol1, nRow1, nCol2, nRow2 );
1290 
1291 		if ( !bRedoFilled )
1292 		{
1293 			//	read redo data from document at first undo
1294 			//	imported data is deleted later anyway,
1295 			//	so now delete each column after copying to save memory (#41216#)
1296 
1297 			sal_Bool bOldAutoCalc = pDoc->GetAutoCalc();
1298 			pDoc->SetAutoCalc( sal_False );				// outside of the loop
1299 			for (SCCOL nCopyCol = nCol1; nCopyCol <= nCol2; nCopyCol++)
1300 			{
1301 				pDoc->CopyToDocument( nCopyCol,nRow1,nTab, nCopyCol,nRow2,nTab,
1302                                         IDF_CONTENTS & ~IDF_NOTE, sal_False, pRedoDoc );
1303                 pDoc->DeleteAreaTab( nCopyCol,nRow1, nCopyCol,nRow2, nTab, IDF_CONTENTS & ~IDF_NOTE );
1304 				pDoc->DoColResize( nTab, nCopyCol, nCopyCol, 0 );
1305 			}
1306 			pDoc->SetAutoCalc( bOldAutoCalc );
1307 			bRedoFilled = sal_True;
1308 		}
1309 	}
1310 	sal_Bool bMoveCells = pUndoDBData && pRedoDBData &&
1311 						pRedoDBData->IsDoSize();		// in alt und neu gleich
1312 	if (bMoveCells)
1313 	{
1314 		//	Undo: erst die neuen Daten loeschen, dann FitBlock rueckwaerts
1315 
1316 		ScRange aOld, aNew;
1317 		pUndoDBData->GetArea( aOld );
1318 		pRedoDBData->GetArea( aNew );
1319 
1320 		pDoc->DeleteAreaTab( aNew.aStart.Col(), aNew.aStart.Row(),
1321                                 aNew.aEnd.Col(), aNew.aEnd.Row(), nTab, IDF_ALL & ~IDF_NOTE );
1322 
1323 		aOld.aEnd.SetCol( aOld.aEnd.Col() + nFormulaCols );		// FitBlock auch fuer Formeln
1324 		aNew.aEnd.SetCol( aNew.aEnd.Col() + nFormulaCols );
1325 		pDoc->FitBlock( aNew, aOld, sal_False );					// rueckwaerts
1326 	}
1327 	else
1328 		pDoc->DeleteAreaTab( aImportParam.nCol1,aImportParam.nRow1,
1329                                 nEndCol,nEndRow, nTab, IDF_ALL & ~IDF_NOTE );
1330 
1331 	pUndoDoc->CopyToDocument( aImportParam.nCol1,aImportParam.nRow1,nTab,
1332 								nEndCol+nFormulaCols,nEndRow,nTab,
1333                                 IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
1334 
1335 	if (pCurrentData)
1336 	{
1337 		*pCurrentData = *pUndoDBData;
1338 
1339 		pUndoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1340 		ScUndoUtil::MarkSimpleBlock( pDocShell, nCol1, nRow1, nTable, nCol2, nRow2, nTable );
1341 	}
1342 
1343 // erack! it's broadcasted
1344 //	pDoc->SetDirty();
1345 
1346 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1347 	if ( nVisTab != nTab )
1348 		pViewShell->SetTabNo( nTab );
1349 
1350 	if (bMoveCells)
1351 		pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
1352 	else
1353 		pDocShell->PostPaint( aImportParam.nCol1,aImportParam.nRow1,nTab,
1354 								nEndCol,nEndRow,nTab, PAINT_GRID );
1355 	pDocShell->PostDataChanged();
1356 
1357 	EndUndo();
1358 }
1359 
Redo()1360 void __EXPORT ScUndoImportData::Redo()
1361 {
1362 	BeginRedo();
1363 
1364 	ScDocument* pDoc = pDocShell->GetDocument();
1365 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1366 
1367 	ScUndoUtil::MarkSimpleBlock( pDocShell, aImportParam.nCol1,aImportParam.nRow1,nTab,
1368 														nEndCol,nEndRow,nTab );
1369 
1370 	SCTAB nTable;
1371 	SCCOL nCol1, nCol2;
1372 	SCROW nRow1, nRow2;
1373 	ScDBData* pCurrentData = NULL;
1374 	if (pUndoDBData && pRedoDBData)
1375 	{
1376 		pUndoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1377 		pCurrentData = ScUndoUtil::GetOldDBData( pUndoDBData, pDoc, nTab,
1378 													nCol1, nRow1, nCol2, nRow2 );
1379 	}
1380 	sal_Bool bMoveCells = pUndoDBData && pRedoDBData &&
1381 						pRedoDBData->IsDoSize();		// in alt und neu gleich
1382 	if (bMoveCells)
1383 	{
1384 		//	Redo: FitBlock, dann Daten loeschen (noetig fuer CopyToDocument)
1385 
1386 		ScRange aOld, aNew;
1387 		pUndoDBData->GetArea( aOld );
1388 		pRedoDBData->GetArea( aNew );
1389 
1390 		aOld.aEnd.SetCol( aOld.aEnd.Col() + nFormulaCols );		// FitBlock auch fuer Formeln
1391 		aNew.aEnd.SetCol( aNew.aEnd.Col() + nFormulaCols );
1392 		pDoc->FitBlock( aOld, aNew );
1393 
1394 		pDoc->DeleteAreaTab( aNew.aStart.Col(), aNew.aStart.Row(),
1395                                 aNew.aEnd.Col(), aNew.aEnd.Row(), nTab, IDF_ALL & ~IDF_NOTE );
1396 
1397         pRedoDoc->CopyToDocument( aNew, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );        // incl. Formeln
1398 	}
1399 	else
1400 	{
1401 		pDoc->DeleteAreaTab( aImportParam.nCol1,aImportParam.nRow1,
1402                                 nEndCol,nEndRow, nTab, IDF_ALL & ~IDF_NOTE );
1403 		pRedoDoc->CopyToDocument( aImportParam.nCol1,aImportParam.nRow1,nTab,
1404                                 nEndCol,nEndRow,nTab, IDF_ALL & ~IDF_NOTE, sal_False, pDoc );
1405 	}
1406 
1407 	if (pCurrentData)
1408 	{
1409 		*pCurrentData = *pRedoDBData;
1410 
1411 		pRedoDBData->GetArea( nTable, nCol1, nRow1, nCol2, nRow2 );
1412 		ScUndoUtil::MarkSimpleBlock( pDocShell, nCol1, nRow1, nTable, nCol2, nRow2, nTable );
1413 	}
1414 
1415 // erack! it's broadcasted
1416 //	pDoc->SetDirty();
1417 
1418 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1419 	if ( nVisTab != nTab )
1420 		pViewShell->SetTabNo( nTab );
1421 
1422 	if (bMoveCells)
1423 		pDocShell->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
1424 	else
1425 		pDocShell->PostPaint( aImportParam.nCol1,aImportParam.nRow1,nTab,
1426 								nEndCol,nEndRow,nTab, PAINT_GRID );
1427 	pDocShell->PostDataChanged();
1428 
1429 	EndRedo();
1430 }
1431 
Repeat(SfxRepeatTarget & rTarget)1432 void __EXPORT ScUndoImportData::Repeat(SfxRepeatTarget& rTarget)
1433 {
1434 	if (rTarget.ISA(ScTabViewTarget))
1435 	{
1436 		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
1437 
1438 		SCTAB nDummy;
1439 		ScImportParam aNewParam(aImportParam);
1440 		ScDBData* pDBData = rViewShell.GetDBData();
1441 		pDBData->GetArea( nDummy, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
1442 
1443 		rViewShell.ImportData( aNewParam );
1444 	}
1445 }
1446 
CanRepeat(SfxRepeatTarget & rTarget) const1447 sal_Bool __EXPORT ScUndoImportData::CanRepeat(SfxRepeatTarget& rTarget) const
1448 {
1449 	//	Repeat nur fuer Import per DB-Bereich, dann ist pUndoDBData gesetzt
1450 
1451 	if (pUndoDBData)
1452 		return (rTarget.ISA(ScTabViewTarget));
1453 	else
1454 		return sal_False;		// Adressbuch
1455 }
1456 
1457 //
1458 //		Operationen wiederholen
1459 //
1460 
ScUndoRepeatDB(ScDocShell * pNewDocShell,SCTAB nNewTab,SCCOL nStartX,SCROW nStartY,SCCOL nEndX,SCROW nEndY,SCROW nResultEndRow,SCCOL nCurX,SCROW nCurY,ScDocument * pNewUndoDoc,ScOutlineTable * pNewUndoTab,ScRangeName * pNewUndoRange,ScDBCollection * pNewUndoDB,const ScRange * pOldQ,const ScRange * pNewQ)1461 ScUndoRepeatDB::ScUndoRepeatDB( ScDocShell* pNewDocShell, SCTAB nNewTab,
1462 								SCCOL nStartX, SCROW nStartY, SCCOL nEndX, SCROW nEndY,
1463 								SCROW nResultEndRow, SCCOL nCurX, SCROW nCurY,
1464 								ScDocument* pNewUndoDoc, ScOutlineTable* pNewUndoTab,
1465 								ScRangeName* pNewUndoRange, ScDBCollection* pNewUndoDB,
1466 								const ScRange* pOldQ, const ScRange* pNewQ ) :
1467 	ScSimpleUndo( pNewDocShell ),
1468 	aBlockStart( nStartX,nStartY,nNewTab ),
1469 	aBlockEnd( nEndX,nEndY,nNewTab ),
1470 	nNewEndRow( nResultEndRow ),
1471 	aCursorPos( nCurX,nCurY,nNewTab ),
1472 	pUndoDoc( pNewUndoDoc ),
1473 	pUndoTable( pNewUndoTab ),
1474 	pUndoRange( pNewUndoRange ),
1475 	pUndoDB( pNewUndoDB ),
1476 	bQuerySize( sal_False )
1477 {
1478 	if ( pOldQ && pNewQ )
1479 	{
1480 		aOldQuery = *pOldQ;
1481 		aNewQuery = *pNewQ;
1482 		bQuerySize = sal_True;;
1483 	}
1484 }
1485 
~ScUndoRepeatDB()1486 __EXPORT ScUndoRepeatDB::~ScUndoRepeatDB()
1487 {
1488 	delete pUndoDoc;
1489 	delete pUndoTable;
1490 	delete pUndoRange;
1491 	delete pUndoDB;
1492 }
1493 
GetComment() const1494 String __EXPORT ScUndoRepeatDB::GetComment() const
1495 {	// "Wiederholen";       //! bessere Beschreibung!
1496 	return ScGlobal::GetRscString( STR_UNDO_REPEATDB );
1497 }
1498 
Undo()1499 void __EXPORT ScUndoRepeatDB::Undo()
1500 {
1501 	BeginUndo();
1502 
1503 	ScDocument* pDoc = pDocShell->GetDocument();
1504 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1505 	SCTAB nTab = aBlockStart.Tab();
1506 
1507 	if (bQuerySize)
1508 	{
1509 		pDoc->FitBlock( aNewQuery, aOldQuery, sal_False );
1510 
1511 		if ( aNewQuery.aEnd.Col() == aOldQuery.aEnd.Col() )
1512 		{
1513 			SCCOL nFormulaCols = 0;
1514 			SCCOL nCol = aOldQuery.aEnd.Col() + 1;
1515 			SCROW nRow = aOldQuery.aStart.Row() + 1;		//! Header testen
1516 			while ( nCol <= MAXCOL &&
1517 					pDoc->GetCellType(ScAddress( nCol, nRow, nTab )) == CELLTYPE_FORMULA )
1518 				++nCol, ++nFormulaCols;
1519 
1520 			if ( nFormulaCols > 0 )
1521 			{
1522 				ScRange aOldForm = aOldQuery;
1523 				aOldForm.aStart.SetCol( aOldQuery.aEnd.Col() + 1 );
1524 				aOldForm.aEnd.SetCol( aOldQuery.aEnd.Col() + nFormulaCols );
1525 				ScRange aNewForm = aOldForm;
1526 				aNewForm.aEnd.SetRow( aNewQuery.aEnd.Row() );
1527 				pDoc->FitBlock( aNewForm, aOldForm, sal_False );
1528 			}
1529 		}
1530 	}
1531 
1532 	//!		Daten von Filter in anderen Bereich fehlen noch	!!!!!!!!!!!!!!!!!
1533 
1534 	if (nNewEndRow > aBlockEnd.Row())
1535 	{
1536 		pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, aBlockEnd.Row()+1, static_cast<SCSIZE>(nNewEndRow-aBlockEnd.Row()) );
1537 	}
1538 	else if (nNewEndRow < aBlockEnd.Row())
1539 	{
1540 		pDoc->InsertRow( 0,nTab, MAXCOL,nTab, nNewEndRow+1, static_cast<SCSIZE>(nNewEndRow-aBlockEnd.Row()) );
1541 	}
1542 
1543 	//	Original Outline-Table
1544 
1545 	pDoc->SetOutlineTable( nTab, pUndoTable );
1546 
1547 	//	Original Spalten-/Zeilenstatus
1548 
1549 	if (pUndoDoc && pUndoTable)
1550 	{
1551 		SCCOLROW nStartCol;
1552 		SCCOLROW nStartRow;
1553 		SCCOLROW nEndCol;
1554 		SCCOLROW nEndRow;
1555 		pUndoTable->GetColArray()->GetRange( nStartCol, nEndCol );
1556 		pUndoTable->GetRowArray()->GetRange( nStartRow, nEndRow );
1557 
1558         pUndoDoc->CopyToDocument( static_cast<SCCOL>(nStartCol), 0, nTab,
1559                 static_cast<SCCOL>(nEndCol), MAXROW, nTab, IDF_NONE, sal_False,
1560                 pDoc );
1561 		pUndoDoc->CopyToDocument( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab, IDF_NONE, sal_False, pDoc );
1562 
1563 		pViewShell->UpdateScrollBars();
1564 	}
1565 
1566 	//	Original-Daten & Referenzen
1567 
1568 	ScUndoUtil::MarkSimpleBlock( pDocShell, 0, aBlockStart.Row(), nTab,
1569 											MAXCOL, aBlockEnd.Row(), nTab );
1570 	pDoc->DeleteAreaTab( 0, aBlockStart.Row(),
1571 							MAXCOL, aBlockEnd.Row(), nTab, IDF_ALL );
1572 
1573 	pUndoDoc->CopyToDocument( 0, aBlockStart.Row(), nTab, MAXCOL, aBlockEnd.Row(), nTab,
1574 															IDF_NONE, sal_False, pDoc );			// Flags
1575 	pUndoDoc->UndoToDocument( 0, aBlockStart.Row(), nTab, MAXCOL, aBlockEnd.Row(), nTab,
1576 															IDF_ALL, sal_False, pDoc );
1577 
1578 	ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart.Col(),aBlockStart.Row(),nTab,
1579 											aBlockEnd.Col(),aBlockEnd.Row(),nTab );
1580 
1581 	if (pUndoRange)
1582 		pDoc->SetRangeName( new ScRangeName( *pUndoRange ) );
1583 	if (pUndoDB)
1584 		pDoc->SetDBCollection( new ScDBCollection( *pUndoDB ), sal_True );
1585 
1586 // erack! it's broadcasted
1587 //	pDoc->SetDirty();
1588 
1589 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1590 	if ( nVisTab != nTab )
1591 		pViewShell->SetTabNo( nTab );
1592 
1593 	pDocShell->PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_GRID|PAINT_LEFT|PAINT_TOP|PAINT_SIZE);
1594 	pDocShell->PostDataChanged();
1595 
1596 	EndUndo();
1597 }
1598 
Redo()1599 void __EXPORT ScUndoRepeatDB::Redo()
1600 {
1601 	BeginRedo();
1602 
1603 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1604 	SCTAB nTab = aBlockStart.Tab();
1605 
1606 	SCTAB nVisTab = pViewShell->GetViewData()->GetTabNo();
1607 	if ( nVisTab != nTab )
1608 		pViewShell->SetTabNo( nTab );
1609 
1610 	ScUndoUtil::MarkSimpleBlock( pDocShell, aBlockStart.Col(),aBlockStart.Row(),nTab,
1611 											aBlockEnd.Col(),aBlockEnd.Row(),nTab );
1612 	pViewShell->SetCursor( aCursorPos.Col(), aCursorPos.Row() );
1613 
1614 	pViewShell->RepeatDB( sal_False );
1615 
1616 	EndRedo();
1617 }
1618 
Repeat(SfxRepeatTarget & rTarget)1619 void __EXPORT ScUndoRepeatDB::Repeat(SfxRepeatTarget& rTarget)
1620 {
1621 	if (rTarget.ISA(ScTabViewTarget))
1622 		((ScTabViewTarget&)rTarget).GetViewShell()->RepeatDB( sal_True );
1623 }
1624 
CanRepeat(SfxRepeatTarget & rTarget) const1625 sal_Bool __EXPORT ScUndoRepeatDB::CanRepeat(SfxRepeatTarget& rTarget) const
1626 {
1627 	return (rTarget.ISA(ScTabViewTarget));
1628 }
1629 
1630 //UNUSED2008-05  //
1631 //UNUSED2008-05  //		Pivot-Tabellen
1632 //UNUSED2008-05  //
1633 //UNUSED2008-05
1634 //UNUSED2008-05  ScUndoPivot::ScUndoPivot( ScDocShell* pNewDocShell,
1635 //UNUSED2008-05                              const ScArea& rOld, const ScArea& rNew,
1636 //UNUSED2008-05                              ScDocument* pOldDoc, ScDocument* pNewDoc,
1637 //UNUSED2008-05                              const ScPivot* pOldPivot, const ScPivot* pNewPivot ) :
1638 //UNUSED2008-05      ScSimpleUndo( pNewDocShell ),
1639 //UNUSED2008-05      aOldArea( rOld ),
1640 //UNUSED2008-05      aNewArea( rNew ),
1641 //UNUSED2008-05      pOldUndoDoc( pOldDoc ),
1642 //UNUSED2008-05      pNewUndoDoc( pNewDoc )
1643 //UNUSED2008-05  {
1644 //UNUSED2008-05      if (pNewPivot)
1645 //UNUSED2008-05      {
1646 //UNUSED2008-05          pNewPivot->GetParam( aNewParam, aNewQuery, aNewSrc );
1647 //UNUSED2008-05          aNewName = pNewPivot->GetName();
1648 //UNUSED2008-05          aNewTag = pNewPivot->GetTag();
1649 //UNUSED2008-05      }
1650 //UNUSED2008-05      if (pOldPivot)
1651 //UNUSED2008-05      {
1652 //UNUSED2008-05          pOldPivot->GetParam( aOldParam, aOldQuery, aOldSrc );
1653 //UNUSED2008-05          aOldName = pOldPivot->GetName();
1654 //UNUSED2008-05          aOldTag = pOldPivot->GetTag();
1655 //UNUSED2008-05      }
1656 //UNUSED2008-05  }
1657 //UNUSED2008-05
1658 //UNUSED2008-05  __EXPORT ScUndoPivot::~ScUndoPivot()
1659 //UNUSED2008-05  {
1660 //UNUSED2008-05      delete pOldUndoDoc;
1661 //UNUSED2008-05      delete pNewUndoDoc;
1662 //UNUSED2008-05  }
1663 //UNUSED2008-05
1664 //UNUSED2008-05  String __EXPORT ScUndoPivot::GetComment() const
1665 //UNUSED2008-05  {
1666 //UNUSED2008-05      sal_uInt16 nIndex;
1667 //UNUSED2008-05      if ( pOldUndoDoc && pNewUndoDoc )
1668 //UNUSED2008-05          nIndex = STR_UNDO_PIVOT_MODIFY;
1669 //UNUSED2008-05      else if ( pNewUndoDoc )
1670 //UNUSED2008-05          nIndex = STR_UNDO_PIVOT_NEW;
1671 //UNUSED2008-05      else
1672 //UNUSED2008-05          nIndex = STR_UNDO_PIVOT_DELETE;
1673 //UNUSED2008-05
1674 //UNUSED2008-05      return ScGlobal::GetRscString( nIndex );
1675 //UNUSED2008-05  }
1676 //UNUSED2008-05
1677 //UNUSED2008-05  void __EXPORT ScUndoPivot::Undo()
1678 //UNUSED2008-05  {
1679 //UNUSED2008-05      BeginUndo();
1680 //UNUSED2008-05
1681 //UNUSED2008-05      ScDocument* pDoc = pDocShell->GetDocument();
1682 //UNUSED2008-05
1683 //UNUSED2008-05      if (pNewUndoDoc)
1684 //UNUSED2008-05      {
1685 //UNUSED2008-05          pDoc->DeleteAreaTab( aNewArea.nColStart,aNewArea.nRowStart,
1686 //UNUSED2008-05                              aNewArea.nColEnd,aNewArea.nRowEnd, aNewArea.nTab, IDF_ALL );
1687 //UNUSED2008-05          pNewUndoDoc->CopyToDocument( aNewArea.nColStart, aNewArea.nRowStart, aNewArea.nTab,
1688 //UNUSED2008-05                                  aNewArea.nColEnd, aNewArea.nRowEnd, aNewArea.nTab,
1689 //UNUSED2008-05                                  IDF_ALL, sal_False, pDoc );
1690 //UNUSED2008-05      }
1691 //UNUSED2008-05      if (pOldUndoDoc)
1692 //UNUSED2008-05      {
1693 //UNUSED2008-05          pDoc->DeleteAreaTab( aOldArea.nColStart,aOldArea.nRowStart,
1694 //UNUSED2008-05                              aOldArea.nColEnd,aOldArea.nRowEnd, aOldArea.nTab, IDF_ALL );
1695 //UNUSED2008-05          pOldUndoDoc->CopyToDocument( aOldArea.nColStart, aOldArea.nRowStart, aOldArea.nTab,
1696 //UNUSED2008-05                                  aOldArea.nColEnd, aOldArea.nRowEnd, aOldArea.nTab,
1697 //UNUSED2008-05                                  IDF_ALL, sal_False, pDoc );
1698 //UNUSED2008-05      }
1699 //UNUSED2008-05
1700 //UNUSED2008-05      ScPivotCollection* pPivotCollection = pDoc->GetPivotCollection();
1701 //UNUSED2008-05      if ( pNewUndoDoc )
1702 //UNUSED2008-05      {
1703 //UNUSED2008-05          ScPivot* pNewPivot = pPivotCollection->GetPivotAtCursor(
1704 //UNUSED2008-05                                  aNewParam.nCol, aNewParam.nRow, aNewParam.nTab );
1705 //UNUSED2008-05          if (pNewPivot)
1706 //UNUSED2008-05              pPivotCollection->Free( pNewPivot );
1707 //UNUSED2008-05      }
1708 //UNUSED2008-05      if ( pOldUndoDoc )
1709 //UNUSED2008-05      {
1710 //UNUSED2008-05          ScPivot* pOldPivot = new ScPivot( pDoc );
1711 //UNUSED2008-05          pOldPivot->SetParam( aOldParam, aOldQuery, aOldSrc );
1712 //UNUSED2008-05          pOldPivot->SetName( aOldName );
1713 //UNUSED2008-05          pOldPivot->SetTag( aOldTag );
1714 //UNUSED2008-05          if (pOldPivot->CreateData())                            // Felder berechnen
1715 //UNUSED2008-05              pOldPivot->ReleaseData();
1716 //UNUSED2008-05          pPivotCollection->Insert( pOldPivot );
1717 //UNUSED2008-05      }
1718 //UNUSED2008-05
1719 //UNUSED2008-05  // erack! it's broadcasted
1720 //UNUSED2008-05  //	pDoc->SetDirty();
1721 //UNUSED2008-05      if (pNewUndoDoc)
1722 //UNUSED2008-05          pDocShell->PostPaint( aNewArea.nColStart, aNewArea.nRowStart, aNewArea.nTab,
1723 //UNUSED2008-05                                  aNewArea.nColEnd, aNewArea.nRowEnd, aNewArea.nTab,
1724 //UNUSED2008-05                                  PAINT_GRID, SC_PF_LINES );
1725 //UNUSED2008-05      if (pOldUndoDoc)
1726 //UNUSED2008-05          pDocShell->PostPaint( aOldArea.nColStart, aOldArea.nRowStart, aOldArea.nTab,
1727 //UNUSED2008-05                                  aOldArea.nColEnd, aOldArea.nRowEnd, aOldArea.nTab,
1728 //UNUSED2008-05                                  PAINT_GRID, SC_PF_LINES );
1729 //UNUSED2008-05      pDocShell->PostDataChanged();
1730 //UNUSED2008-05
1731 //UNUSED2008-05      ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1732 //UNUSED2008-05      if (pViewShell)
1733 //UNUSED2008-05      {
1734 //UNUSED2008-05          SCTAB nTab = pViewShell->GetViewData()->GetTabNo();
1735 //UNUSED2008-05          if ( pOldUndoDoc )
1736 //UNUSED2008-05          {
1737 //UNUSED2008-05              if ( nTab != aOldArea.nTab )
1738 //UNUSED2008-05                  pViewShell->SetTabNo( aOldArea.nTab );
1739 //UNUSED2008-05          }
1740 //UNUSED2008-05          else if ( pNewUndoDoc )
1741 //UNUSED2008-05          {
1742 //UNUSED2008-05              if ( nTab != aNewArea.nTab )
1743 //UNUSED2008-05                  pViewShell->SetTabNo( aNewArea.nTab );
1744 //UNUSED2008-05          }
1745 //UNUSED2008-05      }
1746 //UNUSED2008-05
1747 //UNUSED2008-05      EndUndo();
1748 //UNUSED2008-05  }
1749 //UNUSED2008-05
1750 //UNUSED2008-05  void __EXPORT ScUndoPivot::Redo()
1751 //UNUSED2008-05  {
1752 //UNUSED2008-05      BeginRedo();
1753 //UNUSED2008-05
1754 //UNUSED2008-05      ScDocument* pDoc = pDocShell->GetDocument();
1755 //UNUSED2008-05      ScPivotCollection* pPivotCollection = pDoc->GetPivotCollection();
1756 //UNUSED2008-05      ScPivot* pOldPivot = pPivotCollection->GetPivotAtCursor(
1757 //UNUSED2008-05                                              aOldParam.nCol, aOldParam.nRow, aOldParam.nTab );
1758 //UNUSED2008-05
1759 //UNUSED2008-05      ScPivot* pNewPivot = NULL;
1760 //UNUSED2008-05      if (pNewUndoDoc)
1761 //UNUSED2008-05      {
1762 //UNUSED2008-05          pNewPivot = new ScPivot( pDoc );
1763 //UNUSED2008-05          pNewPivot->SetParam( aNewParam, aNewQuery, aNewSrc );
1764 //UNUSED2008-05          pNewPivot->SetName( aNewName );
1765 //UNUSED2008-05          pNewPivot->SetTag( aNewTag );
1766 //UNUSED2008-05      }
1767 //UNUSED2008-05
1768 //UNUSED2008-05      pDocShell->PivotUpdate( pOldPivot, pNewPivot, sal_False );
1769 //UNUSED2008-05
1770 //UNUSED2008-05      EndRedo();
1771 //UNUSED2008-05  }
1772 //UNUSED2008-05
1773 //UNUSED2008-05  void __EXPORT ScUndoPivot::Repeat(SfxRepeatTarget& rTarget)
1774 //UNUSED2008-05  {
1775 //UNUSED2008-05      //  Wiederholen: nur loeschen
1776 //UNUSED2008-05
1777 //UNUSED2008-05      if ( pOldUndoDoc && !pNewUndoDoc && rTarget.ISA(ScTabViewTarget) )
1778 //UNUSED2008-05          ((ScTabViewTarget&)rTarget).GetViewShell()->DeletePivotTable();
1779 //UNUSED2008-05  }
1780 //UNUSED2008-05
1781 //UNUSED2008-05  sal_Bool __EXPORT ScUndoPivot::CanRepeat(SfxRepeatTarget& rTarget) const
1782 //UNUSED2008-05  {
1783 //UNUSED2008-05      //  Wiederholen: nur loeschen
1784 //UNUSED2008-05
1785 //UNUSED2008-05      return ( pOldUndoDoc && !pNewUndoDoc && rTarget.ISA(ScTabViewTarget) );
1786 //UNUSED2008-05  }
1787 
1788 //
1789 //		data pilot
1790 //
1791 
ScUndoDataPilot(ScDocShell * pNewDocShell,ScDocument * pOldDoc,ScDocument * pNewDoc,const ScDPObject * pOldObj,const ScDPObject * pNewObj,sal_Bool bMove)1792 ScUndoDataPilot::ScUndoDataPilot( ScDocShell* pNewDocShell,
1793 							ScDocument* pOldDoc, ScDocument* pNewDoc,
1794 							const ScDPObject* pOldObj, const ScDPObject* pNewObj, sal_Bool bMove ) :
1795 	ScSimpleUndo( pNewDocShell ),
1796 	pOldUndoDoc( pOldDoc ),
1797 	pNewUndoDoc( pNewDoc ),
1798 	pOldDPObject( NULL ),
1799 	pNewDPObject( NULL ),
1800 	bAllowMove( bMove )
1801 {
1802 	if (pOldObj)
1803 		pOldDPObject = new ScDPObject( *pOldObj );
1804 	if (pNewObj)
1805 		pNewDPObject = new ScDPObject( *pNewObj );
1806 }
1807 
~ScUndoDataPilot()1808 __EXPORT ScUndoDataPilot::~ScUndoDataPilot()
1809 {
1810 	delete pOldDPObject;
1811 	delete pNewDPObject;
1812 	delete pOldUndoDoc;
1813 	delete pNewUndoDoc;
1814 }
1815 
GetComment() const1816 String __EXPORT ScUndoDataPilot::GetComment() const
1817 {
1818 	sal_uInt16 nIndex;
1819 	if ( pOldUndoDoc && pNewUndoDoc )
1820 		nIndex = STR_UNDO_PIVOT_MODIFY;
1821 	else if ( pNewUndoDoc )
1822 		nIndex = STR_UNDO_PIVOT_NEW;
1823 	else
1824 		nIndex = STR_UNDO_PIVOT_DELETE;
1825 
1826 	return ScGlobal::GetRscString( nIndex );
1827 }
1828 
Undo()1829 void __EXPORT ScUndoDataPilot::Undo()
1830 {
1831 	BeginUndo();
1832 
1833 	ScDocument* pDoc = pDocShell->GetDocument();
1834 
1835 	ScRange aOldRange;
1836 	ScRange aNewRange;
1837 
1838 	if ( pNewDPObject && pNewUndoDoc )
1839 	{
1840 		aNewRange = pNewDPObject->GetOutRange();
1841 		pDoc->DeleteAreaTab( aNewRange, IDF_ALL );
1842 		pNewUndoDoc->CopyToDocument( aNewRange, IDF_ALL, sal_False, pDoc );
1843 	}
1844 	if ( pOldDPObject && pOldUndoDoc )
1845 	{
1846 		aOldRange = pOldDPObject->GetOutRange();
1847 		pDoc->DeleteAreaTab( aOldRange, IDF_ALL );
1848 		pOldUndoDoc->CopyToDocument( aOldRange, IDF_ALL, sal_False, pDoc );
1849 	}
1850 
1851 	//	update objects in collection
1852 
1853 	if ( pNewDPObject )
1854 	{
1855 		//	find updated object
1856 		//!	find by name!
1857 
1858 		ScDPObject* pDocObj = pDoc->GetDPAtCursor(
1859 							aNewRange.aStart.Col(), aNewRange.aStart.Row(), aNewRange.aStart.Tab() );
1860 		DBG_ASSERT(pDocObj, "DPObject not found");
1861 		if (pDocObj)
1862 		{
1863 			if ( pOldDPObject )
1864 			{
1865 				//	restore old settings
1866 				pOldDPObject->WriteSourceDataTo( *pDocObj );
1867 				ScDPSaveData* pData = pOldDPObject->GetSaveData();
1868 				if (pData)
1869 					pDocObj->SetSaveData(*pData);
1870 				pDocObj->SetOutRange( pOldDPObject->GetOutRange() );
1871 				pOldDPObject->WriteTempDataTo( *pDocObj );
1872 			}
1873 			else
1874 			{
1875 				//	delete inserted object
1876                 pDoc->GetDPCollection()->FreeTable(pDocObj);
1877 			}
1878 		}
1879 	}
1880 	else if ( pOldDPObject )
1881 	{
1882 		//	re-insert deleted object
1883 
1884 		ScDPObject* pDestObj = new ScDPObject( *pOldDPObject );
1885 		pDestObj->SetAlive(sal_True);
1886 		if ( !pDoc->GetDPCollection()->InsertNewTable(pDestObj) )
1887 		{
1888 			DBG_ERROR("cannot insert DPObject");
1889 			DELETEZ( pDestObj );
1890 		}
1891 	}
1892 
1893 	if (pNewUndoDoc)
1894 		pDocShell->PostPaint( aNewRange, PAINT_GRID, SC_PF_LINES );
1895 	if (pOldUndoDoc)
1896 		pDocShell->PostPaint( aOldRange, PAINT_GRID, SC_PF_LINES );
1897 	pDocShell->PostDataChanged();
1898 
1899 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1900 	if (pViewShell)
1901 	{
1902 		//!	set current sheet
1903 	}
1904 
1905     if (pNewDPObject)
1906     {
1907         // notify API objects
1908         pDoc->BroadcastUno( ScDataPilotModifiedHint( pNewDPObject->GetName() ) );
1909     }
1910 
1911 	EndUndo();
1912 }
1913 
Redo()1914 void __EXPORT ScUndoDataPilot::Redo()
1915 {
1916 	BeginRedo();
1917 
1918 	//!	copy output data instead of repeating the change,
1919 	//!	in case external data have changed!
1920 
1921 	ScDocument* pDoc = pDocShell->GetDocument();
1922 
1923 	ScDPObject* pSourceObj = NULL;
1924 	if ( pOldDPObject )
1925 	{
1926 		//	find object to modify
1927 		//!	find by name!
1928 
1929 		ScRange aOldRange = pOldDPObject->GetOutRange();
1930 		pSourceObj = pDoc->GetDPAtCursor(
1931 						aOldRange.aStart.Col(), aOldRange.aStart.Row(), aOldRange.aStart.Tab() );
1932 		DBG_ASSERT(pSourceObj, "DPObject not found");
1933 	}
1934 
1935 	ScDBDocFunc aFunc( *pDocShell );
1936 	aFunc.DataPilotUpdate( pSourceObj, pNewDPObject, sal_False, sal_False, bAllowMove );	// no new undo action
1937 
1938 	EndRedo();
1939 }
1940 
Repeat(SfxRepeatTarget &)1941 void __EXPORT ScUndoDataPilot::Repeat(SfxRepeatTarget& /* rTarget */)
1942 {
1943 	//!	allow deletion
1944 }
1945 
CanRepeat(SfxRepeatTarget &) const1946 sal_Bool __EXPORT ScUndoDataPilot::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1947 {
1948 	//!	allow deletion
1949 	return sal_False;
1950 }
1951 
1952 
1953 //
1954 //		Konsolidieren
1955 //
1956 
ScUndoConsolidate(ScDocShell * pNewDocShell,const ScArea & rArea,const ScConsolidateParam & rPar,ScDocument * pNewUndoDoc,sal_Bool bReference,SCROW nInsCount,ScOutlineTable * pTab,ScDBData * pData)1957 ScUndoConsolidate::ScUndoConsolidate( ScDocShell* pNewDocShell, const ScArea& rArea,
1958 					const ScConsolidateParam& rPar, ScDocument* pNewUndoDoc,
1959 					sal_Bool bReference, SCROW nInsCount, ScOutlineTable* pTab,
1960 					ScDBData* pData ) :
1961 	ScSimpleUndo( pNewDocShell ),
1962 	aDestArea( rArea ),
1963 	pUndoDoc( pNewUndoDoc ),
1964 	aParam( rPar ),
1965 	bInsRef( bReference ),
1966 	nInsertCount( nInsCount ),
1967 	pUndoTab( pTab ),
1968 	pUndoData( pData )
1969 {
1970 }
1971 
~ScUndoConsolidate()1972 __EXPORT ScUndoConsolidate::~ScUndoConsolidate()
1973 {
1974 	delete pUndoDoc;
1975 	delete pUndoTab;
1976 	delete pUndoData;
1977 }
1978 
GetComment() const1979 String __EXPORT ScUndoConsolidate::GetComment() const
1980 {
1981 	return ScGlobal::GetRscString( STR_UNDO_CONSOLIDATE );
1982 }
1983 
Undo()1984 void __EXPORT ScUndoConsolidate::Undo()
1985 {
1986 	BeginUndo();
1987 
1988 	ScDocument* pDoc = pDocShell->GetDocument();
1989 	SCTAB nTab = aDestArea.nTab;
1990 
1991 	ScRange aOldRange;
1992 	if (pUndoData)
1993 		pUndoData->GetArea(aOldRange);
1994 
1995 	if (bInsRef)
1996 	{
1997 		//	Zeilen loeschen
1998 		pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, aDestArea.nRowStart, nInsertCount );
1999 
2000 		//	Outlines
2001 		pDoc->SetOutlineTable( nTab, pUndoTab );
2002 
2003 		//	Zeilenstatus
2004 		pUndoDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, sal_False, pDoc );
2005 
2006 		//	Daten & Referenzen
2007 		pDoc->DeleteAreaTab( 0,aDestArea.nRowStart, MAXCOL,aDestArea.nRowEnd, nTab, IDF_ALL );
2008 		pUndoDoc->UndoToDocument( 0, aDestArea.nRowStart, nTab,
2009 									MAXCOL, aDestArea.nRowEnd, nTab,
2010 									IDF_ALL, sal_False, pDoc );
2011 
2012 		//	Original-Bereich
2013 		if (pUndoData)
2014 		{
2015 			pDoc->DeleteAreaTab(aOldRange, IDF_ALL);
2016 			pUndoDoc->CopyToDocument(aOldRange, IDF_ALL, sal_False, pDoc);
2017 		}
2018 
2019 		pDocShell->PostPaint( 0,aDestArea.nRowStart,nTab, MAXCOL,MAXROW,nTab,
2020 								PAINT_GRID | PAINT_LEFT | PAINT_SIZE );
2021 	}
2022 	else
2023 	{
2024 		pDoc->DeleteAreaTab( aDestArea.nColStart,aDestArea.nRowStart,
2025 								aDestArea.nColEnd,aDestArea.nRowEnd, nTab, IDF_ALL );
2026 		pUndoDoc->CopyToDocument( aDestArea.nColStart, aDestArea.nRowStart, nTab,
2027 									aDestArea.nColEnd, aDestArea.nRowEnd, nTab,
2028 									IDF_ALL, sal_False, pDoc );
2029 
2030 		//	Original-Bereich
2031 		if (pUndoData)
2032 		{
2033 			pDoc->DeleteAreaTab(aOldRange, IDF_ALL);
2034 			pUndoDoc->CopyToDocument(aOldRange, IDF_ALL, sal_False, pDoc);
2035 		}
2036 
2037 		SCCOL nEndX = aDestArea.nColEnd;
2038 		SCROW nEndY = aDestArea.nRowEnd;
2039 		if ( pUndoData )
2040 		{
2041 			if ( aOldRange.aEnd.Col() > nEndX )
2042 				nEndX = aOldRange.aEnd.Col();
2043 			if ( aOldRange.aEnd.Row() > nEndY )
2044 				nEndY = aOldRange.aEnd.Row();
2045 		}
2046 		pDocShell->PostPaint( aDestArea.nColStart, aDestArea.nRowStart, nTab,
2047 									nEndX, nEndY, nTab, PAINT_GRID );
2048 	}
2049 
2050 	//	DB-Bereich wieder anpassen
2051 	if (pUndoData)
2052 	{
2053 		ScDBCollection*	pColl = pDoc->GetDBCollection();
2054 		if (pColl)
2055 		{
2056 			sal_uInt16 nIndex;
2057 			if (pColl->SearchName( pUndoData->GetName(), nIndex ))
2058 			{
2059 				ScDBData* pDocData = (*pColl)[nIndex];
2060 				if (pDocData)
2061 					*pDocData = *pUndoData;
2062 			}
2063 			else
2064 			{
2065 				DBG_ERROR("alte DB-Daten nicht gefunden");
2066 			}
2067 		}
2068 	}
2069 
2070 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2071 	if (pViewShell)
2072 	{
2073 		SCTAB nViewTab = pViewShell->GetViewData()->GetTabNo();
2074 		if ( nViewTab != nTab )
2075 			pViewShell->SetTabNo( nTab );
2076 	}
2077 
2078 	EndUndo();
2079 }
2080 
Redo()2081 void __EXPORT ScUndoConsolidate::Redo()
2082 {
2083 	BeginRedo();
2084 
2085 	pDocShell->DoConsolidate( aParam, sal_False );
2086 
2087 	ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
2088 	if (pViewShell)
2089 	{
2090 		SCTAB nViewTab = pViewShell->GetViewData()->GetTabNo();
2091 		if ( nViewTab != aParam.nTab )
2092 			pViewShell->SetTabNo( aParam.nTab );
2093 	}
2094 
2095 	EndRedo();
2096 }
2097 
Repeat(SfxRepeatTarget &)2098 void __EXPORT ScUndoConsolidate::Repeat(SfxRepeatTarget& /* rTarget */)
2099 {
2100 }
2101 
CanRepeat(SfxRepeatTarget &) const2102 sal_Bool __EXPORT ScUndoConsolidate::CanRepeat(SfxRepeatTarget& /* rTarget */) const
2103 {
2104 	return sal_False;
2105 }
2106 
2107 
2108 //
2109 //		Quell-Daten von Chart aendern
2110 //
2111 
Init()2112 void ScUndoChartData::Init()
2113 {
2114 	ScDocument* pDoc = pDocShell->GetDocument();
2115     aOldRangeListRef = new ScRangeList;
2116     pDoc->GetOldChartParameters( aChartName, *aOldRangeListRef, bOldColHeaders, bOldRowHeaders );
2117 }
2118 
ScUndoChartData(ScDocShell * pNewDocShell,const String & rName,const ScRange & rNew,sal_Bool bColHdr,sal_Bool bRowHdr,sal_Bool bAdd)2119 ScUndoChartData::ScUndoChartData( ScDocShell* pNewDocShell, const String& rName,
2120 									const ScRange& rNew, sal_Bool bColHdr, sal_Bool bRowHdr,
2121 									sal_Bool bAdd ) :
2122 	ScSimpleUndo( pNewDocShell ),
2123 	aChartName( rName ),
2124 	bNewColHeaders( bColHdr ),
2125 	bNewRowHeaders( bRowHdr ),
2126 	bAddRange( bAdd )
2127 {
2128 	aNewRangeListRef = new ScRangeList;
2129 	aNewRangeListRef->Append( rNew );
2130 
2131 	Init();
2132 }
2133 
ScUndoChartData(ScDocShell * pNewDocShell,const String & rName,const ScRangeListRef & rNew,sal_Bool bColHdr,sal_Bool bRowHdr,sal_Bool bAdd)2134 ScUndoChartData::ScUndoChartData( ScDocShell* pNewDocShell, const String& rName,
2135 									const ScRangeListRef& rNew, sal_Bool bColHdr, sal_Bool bRowHdr,
2136 									sal_Bool bAdd ) :
2137 	ScSimpleUndo( pNewDocShell ),
2138 	aChartName( rName ),
2139 	aNewRangeListRef( rNew ),
2140 	bNewColHeaders( bColHdr ),
2141 	bNewRowHeaders( bRowHdr ),
2142 	bAddRange( bAdd )
2143 {
2144 	Init();
2145 }
2146 
~ScUndoChartData()2147 __EXPORT ScUndoChartData::~ScUndoChartData()
2148 {
2149 }
2150 
GetComment() const2151 String __EXPORT ScUndoChartData::GetComment() const
2152 {
2153 	return ScGlobal::GetRscString( STR_UNDO_CHARTDATA );
2154 }
2155 
Undo()2156 void __EXPORT ScUndoChartData::Undo()
2157 {
2158 	BeginUndo();
2159 
2160 	pDocShell->GetDocument()->UpdateChartArea( aChartName, aOldRangeListRef,
2161 								bOldColHeaders, bOldRowHeaders, sal_False );
2162 
2163 	EndUndo();
2164 }
2165 
Redo()2166 void __EXPORT ScUndoChartData::Redo()
2167 {
2168 	BeginRedo();
2169 
2170 	pDocShell->GetDocument()->UpdateChartArea( aChartName, aNewRangeListRef,
2171 								bNewColHeaders, bNewRowHeaders, bAddRange );
2172 
2173 	EndRedo();
2174 }
2175 
Repeat(SfxRepeatTarget &)2176 void __EXPORT ScUndoChartData::Repeat(SfxRepeatTarget& /* rTarget */)
2177 {
2178 }
2179 
CanRepeat(SfxRepeatTarget &) const2180 sal_Bool __EXPORT ScUndoChartData::CanRepeat(SfxRepeatTarget& /* rTarget */) const
2181 {
2182 	return sal_False;
2183 }
2184 
2185 
2186 
2187 
2188 
2189 
2190