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