Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #ifndef _SVDUNDO_HXX
21 : #define _SVDUNDO_HXX
22 :
23 : #include <svl/solar.hrc>
24 : #include <svl/undo.hxx>
25 : #include <svl/style.hxx>
26 : #include <tools/gen.hxx>
27 : #include <svx/svdtypes.hxx> // for enum RepeatFuncts
28 : #include <svx/svdsob.hxx>
29 : #include "svx/svxdllapi.h"
30 :
31 : class SfxItemSet;
32 : class SfxStyleSheet;
33 : class SdrView;
34 : class SdrPageView;
35 : class SdrModel;
36 : class SdrObject;
37 : class SdrPage;
38 : class SdrObjList;
39 : class SdrLayer;
40 : class SdrLayerAdmin;
41 : class SdrObjGeoData;
42 : class OutlinerParaObject;
43 :
44 : //************************************************************
45 : // SdrUndoAction
46 : //
47 : // Abstrakte Basisklasse fuer alle UndoActions der DrawingEngine
48 : //
49 : //************************************************************
50 :
51 : class SVX_DLLPUBLIC SdrUndoAction : public SfxUndoAction
52 : {
53 : protected:
54 : SdrModel& rMod;
55 :
56 : protected:
57 6757 : SdrUndoAction(SdrModel& rNewMod)
58 6757 : : rMod(rNewMod)
59 6757 : {}
60 :
61 : public:
62 : TYPEINFO();
63 : virtual ~SdrUndoAction();
64 :
65 : virtual bool CanRepeat(SfxRepeatTarget& rView) const;
66 : virtual void Repeat(SfxRepeatTarget& rView);
67 :
68 : virtual OUString GetRepeatComment(SfxRepeatTarget& rView) const;
69 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
70 :
71 : virtual bool CanSdrRepeat(SdrView& rView) const;
72 : virtual void SdrRepeat(SdrView& rView);
73 : };
74 :
75 : //************************************************************
76 : // SdrUndoGroup
77 : //
78 : // Zusammenfassung beliebig vieler einzelner UndoActions zu einer einzigen
79 : // UndoAction. Beim Undo() werden die Einzelactions rueckwaets aufgerufen
80 : // (die zuletzt angehaengte zuerst...), beim Redo() dagegen entspricht die
81 : // Aufrufreihenfolge der Einfuegereihenfolge.
82 : //
83 : //************************************************************
84 :
85 : class SVX_DLLPUBLIC SdrUndoGroup : public SdrUndoAction
86 : {
87 : protected:
88 : std::vector<SdrUndoAction*> aBuf;
89 :
90 : // Beschreibung der Action, nicht expandiert (beinhaltet %O)
91 : OUString aComment;
92 : OUString aObjDescription;
93 :
94 : SdrRepeatFunc eFunction;
95 :
96 : public:
97 : SdrUndoGroup(SdrModel& rNewMod);
98 : virtual ~SdrUndoGroup();
99 :
100 : void Clear();
101 836 : sal_uIntPtr GetActionCount() const { return aBuf.size(); }
102 328 : SdrUndoAction* GetAction(sal_uIntPtr nNum) const { return aBuf[nNum]; }
103 : void AddAction(SdrUndoAction* pAct);
104 :
105 230 : void SetComment(const OUString& rStr) { aComment=rStr; }
106 6 : void SetObjDescription(const OUString& rStr) { aObjDescription=rStr; }
107 : virtual OUString GetComment() const;
108 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
109 :
110 : virtual void Undo();
111 : virtual void Redo();
112 :
113 : virtual bool CanSdrRepeat(SdrView& rView) const;
114 : virtual void SdrRepeat(SdrView& rView);
115 4 : void SetRepeatFunction(SdrRepeatFunc eFunc) { eFunction=eFunc; }
116 : SdrRepeatFunc GetRepeatFunction() const { return eFunction; }
117 : };
118 :
119 : //************************************************************
120 : // SdrUndoObj
121 : //
122 : // Abstrakte Basisklasse fuer alle UndoActions die mit Objekten zu tun haben.
123 : //
124 : //************************************************************
125 :
126 426 : class SVX_DLLPUBLIC SdrUndoObj : public SdrUndoAction
127 : {
128 : protected:
129 : SdrObject* pObj;
130 :
131 : protected:
132 : SdrUndoObj(SdrObject& rNewObj);
133 :
134 : void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, bool bRepeat = false) const;
135 :
136 : static void GetDescriptionStringForObject( const SdrObject& _rForObject, sal_uInt16 nStrCacheID, String& rStr, bool bRepeat = false );
137 :
138 : // #94278# new method for evtl. PageChange at UNDO/REDO
139 : void ImpShowPageOfThisObject();
140 : };
141 :
142 : //************************************************************
143 : // SdrUndoAttrObj
144 : //
145 : // Aenderung der Objektattribute.
146 : // Action direkt vor dem Setzen der neuen Attribute konstruieren.
147 : // Auch fuer StyleSheets
148 : //
149 : //************************************************************
150 :
151 : class SVX_DLLPUBLIC SdrUndoAttrObj : public SdrUndoObj
152 : {
153 : protected:
154 : SfxItemSet* pUndoSet;
155 : SfxItemSet* pRedoSet;
156 : SfxItemSet* pRepeatSet;
157 :
158 : // oder besser den StyleSheetNamen merken?
159 : rtl::Reference< SfxStyleSheetBase > mxUndoStyleSheet;
160 : rtl::Reference< SfxStyleSheetBase > mxRedoStyleSheet;
161 : bool bStyleSheet;
162 : bool bHaveToTakeRedoSet;
163 :
164 : // Bei Zuweisung von TextItems auf ein Zeichenobjekt mit Text:
165 : OutlinerParaObject* pTextUndo;
166 : // #i8508#
167 : // The text rescue mechanism needs also to be implemented for redo actions.
168 : OutlinerParaObject* pTextRedo;
169 :
170 : // Wenn sich um ein Gruppenobjekt handelt:
171 : SdrUndoGroup* pUndoGroup;
172 :
173 : // helper to ensure StyleSheet is in pool (provided by SdrModel from SdrObject)
174 : void ensureStyleSheetInStyleSheetPool(SfxStyleSheetBasePool& rStyleSheetPool, SfxStyleSheet& rSheet);
175 :
176 : public:
177 : SdrUndoAttrObj(SdrObject& rNewObj, bool bStyleSheet1 = false, bool bSaveText = false);
178 : virtual ~SdrUndoAttrObj();
179 : virtual void Undo();
180 : virtual void Redo();
181 :
182 : virtual OUString GetComment() const;
183 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
184 :
185 : virtual void SdrRepeat(SdrView& rView);
186 : virtual bool CanSdrRepeat(SdrView& rView) const;
187 : };
188 :
189 : //************************************************************
190 : // SdrUndoMoveObj
191 : //
192 : // Blosses verschieben eines Objektes.
193 : // Action direkt vor dem Verschieben konstruieren.
194 : //
195 : //************************************************************
196 :
197 : class SVX_DLLPUBLIC SdrUndoMoveObj : public SdrUndoObj
198 : {
199 : protected:
200 : Size aDistance; // Entfernung, um die verschoben wird
201 :
202 : public:
203 0 : SdrUndoMoveObj(SdrObject& rNewObj): SdrUndoObj(rNewObj) {}
204 0 : SdrUndoMoveObj(SdrObject& rNewObj, const Size& rDist): SdrUndoObj(rNewObj),aDistance(rDist) {}
205 : virtual ~SdrUndoMoveObj();
206 :
207 : void SetDistance(const Size& rDist) { aDistance=rDist; }
208 : const Size& GetDistance() const { return aDistance; }
209 :
210 : virtual void Undo();
211 : virtual void Redo();
212 :
213 : virtual OUString GetComment() const;
214 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
215 :
216 : virtual void SdrRepeat(SdrView& rView);
217 : virtual bool CanSdrRepeat(SdrView& rView) const;
218 : };
219 :
220 : //************************************************************
221 : // SdrUndoGeoObj
222 : //
223 : // Aenderung der Geometrie eines Objektes.
224 : // Action direkt vor der geometrischen Transformation konstruieren.
225 : //
226 : //************************************************************
227 :
228 : class SVX_DLLPUBLIC SdrUndoGeoObj : public SdrUndoObj
229 : {
230 : protected:
231 : SdrObjGeoData* pUndoGeo;
232 : SdrObjGeoData* pRedoGeo;
233 : // Wenn sich um ein Gruppenobjekt handelt:
234 : SdrUndoGroup* pUndoGroup;
235 :
236 : public:
237 : SdrUndoGeoObj(SdrObject& rNewObj);
238 : virtual ~SdrUndoGeoObj();
239 :
240 : virtual void Undo();
241 : virtual void Redo();
242 :
243 : virtual OUString GetComment() const;
244 : };
245 :
246 : //************************************************************
247 : // SdrUndoObjList
248 : //
249 : // Manipulationen an einer ObjList: Neues Obj, DeleteObj, SetObjZLevel, Grouping, ...
250 : // Abstrakte Basisklasse.
251 : //
252 : //************************************************************
253 :
254 : class SVX_DLLPUBLIC SdrUndoObjList : public SdrUndoObj {
255 : class ObjListListener;
256 : friend class ObjListListener;
257 :
258 : private:
259 : bool bOwner;
260 :
261 : protected:
262 : SdrObjList* pObjList;
263 : SdrView* pView; // um bei ObjDel, Undo die
264 : SdrPageView* pPageView; // Selektion widerherstellen zu koennen
265 : sal_uInt32 nOrdNum;
266 : // Bei einem Undo/Redo findet moeglicherweise Uebereignung des Objektes
267 : // statt. Im Dtor wird das Obj deleted, wenn bOwner==TRUE
268 : ObjListListener* m_pListener;
269 :
270 : protected:
271 : SdrUndoObjList(SdrObject& rNewObj, bool bOrdNumDirect = false);
272 : virtual ~SdrUndoObjList();
273 :
274 : void SetView(SdrView* pView1, SdrPageView* pPageView1) { pView=pView1; pPageView=pPageView1; }
275 210 : bool IsOwner() { return bOwner; }
276 : void SetOwner(bool bNew);
277 :
278 : private:
279 : sal_uInt32 GetOrdNum() const;
280 : void SetOrdNum(sal_uInt32 nOrdNum_);
281 : };
282 :
283 : //************************************************************
284 : // SdrUndoRemoveObj
285 : //
286 : // Entfernen Objekts aus einer Objektliste. Innerhalb einer UndoGroup
287 : // mit korrospondierenden Inserts zu verwenden.
288 : // Action vor dem entfernen aus der ObjList konstruieren.
289 : //
290 : //************************************************************
291 :
292 103 : class SVX_DLLPUBLIC SdrUndoRemoveObj : public SdrUndoObjList
293 : {
294 : public:
295 79 : SdrUndoRemoveObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
296 79 : : SdrUndoObjList(rNewObj,bOrdNumDirect) {}
297 :
298 : virtual void Undo();
299 : virtual void Redo();
300 : };
301 :
302 : //************************************************************
303 : // SdrUndoInsertObj
304 : //
305 : // Einfuegen Objekts in eine Objektliste. Innerhalb einer UndoGroup
306 : // mit korrospondierenden Removes zu verwenden.
307 : // Action vor dem entfernen aus der ObjList konstruieren.
308 : //
309 : //************************************************************
310 :
311 183 : class SVX_DLLPUBLIC SdrUndoInsertObj : public SdrUndoObjList
312 : {
313 : public:
314 131 : SdrUndoInsertObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
315 131 : : SdrUndoObjList(rNewObj,bOrdNumDirect) {}
316 :
317 : virtual void Undo();
318 : virtual void Redo();
319 : };
320 :
321 : //************************************************************
322 : // SdrUndoDelObj
323 : //
324 : // Loeschen eines Objekts.
325 : // Action vor dem entfernen aus der ObjList konstruieren.
326 : //
327 : //************************************************************
328 :
329 40 : class SVX_DLLPUBLIC SdrUndoDelObj : public SdrUndoRemoveObj
330 : {
331 : public:
332 35 : SdrUndoDelObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
333 35 : : SdrUndoRemoveObj(rNewObj,bOrdNumDirect) { SetOwner(sal_True); }
334 :
335 : virtual void Undo();
336 : virtual void Redo();
337 :
338 : virtual OUString GetComment() const;
339 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
340 :
341 : virtual void SdrRepeat(SdrView& rView);
342 : virtual bool CanSdrRepeat(SdrView& rView) const;
343 : };
344 :
345 : //************************************************************
346 : // SdrUndoNewObj
347 : //
348 : // Einfuegen eines neuen Objektes.
349 : // Action nach dem einfuegen in die ObjList konstruieren.
350 : //
351 : //************************************************************
352 :
353 158 : class SVX_DLLPUBLIC SdrUndoNewObj : public SdrUndoInsertObj
354 : {
355 : public:
356 79 : SdrUndoNewObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
357 79 : : SdrUndoInsertObj(rNewObj,bOrdNumDirect) {}
358 :
359 : virtual void Undo();
360 : virtual void Redo();
361 :
362 : virtual OUString GetComment() const;
363 :
364 : static OUString GetComment(const SdrObject& _rForObject);
365 : };
366 :
367 : //************************************************************
368 : // SdrUndoReplaceObj
369 : //
370 : // Austausch eines Objektes.
371 : // Action vor dem Replace an der ObjList konstruieren.
372 : //
373 : //************************************************************
374 :
375 : class SVX_DLLPUBLIC SdrUndoReplaceObj : public SdrUndoObj
376 : {
377 : bool bOldOwner;
378 : bool bNewOwner;
379 :
380 : protected:
381 : SdrObjList* pObjList;
382 : sal_uInt32 nOrdNum;
383 : SdrObject* pNewObj;
384 :
385 : public:
386 : SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1, bool bOrdNumDirect = false);
387 : virtual ~SdrUndoReplaceObj();
388 :
389 : virtual void Undo();
390 : virtual void Redo();
391 :
392 20 : bool IsNewOwner() { return bNewOwner; }
393 : void SetNewOwner(bool bNew);
394 :
395 20 : bool IsOldOwner() { return bOldOwner; }
396 : void SetOldOwner(bool bNew);
397 : };
398 :
399 : //************************************************************
400 : // SdrUndoCopyObj
401 : //
402 : // Kopieren eines Objekts
403 : // Action nach dem einfuegen in die ObjList konstruieren.
404 : //
405 : //************************************************************
406 :
407 0 : class SdrUndoCopyObj : public SdrUndoNewObj
408 : {
409 : public:
410 0 : SdrUndoCopyObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
411 0 : : SdrUndoNewObj(rNewObj,bOrdNumDirect) {}
412 :
413 : virtual OUString GetComment() const;
414 : };
415 :
416 : //************************************************************
417 : // SdrUndoObjOrdNum
418 : //************************************************************
419 :
420 0 : class SdrUndoObjOrdNum : public SdrUndoObj
421 : {
422 : protected:
423 : sal_uInt32 nOldOrdNum;
424 : sal_uInt32 nNewOrdNum;
425 :
426 : public:
427 : SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1);
428 :
429 : virtual void Undo();
430 : virtual void Redo();
431 :
432 : virtual OUString GetComment() const;
433 : };
434 :
435 : //////////////////////////////////////////////////////////////////////////////
436 : // #i11702#
437 :
438 0 : class SVX_DLLPUBLIC SdrUndoObjectLayerChange : public SdrUndoObj
439 : {
440 : protected:
441 : SdrLayerID maOldLayer;
442 : SdrLayerID maNewLayer;
443 :
444 : public:
445 : SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer);
446 :
447 : virtual void Undo();
448 : virtual void Redo();
449 : };
450 :
451 : //************************************************************
452 : // SdrUndoObjSetText
453 : //************************************************************
454 :
455 : class SVX_DLLPUBLIC SdrUndoObjSetText : public SdrUndoObj
456 : {
457 : protected:
458 : OutlinerParaObject* pOldText;
459 : OutlinerParaObject* pNewText;
460 : bool bNewTextAvailable;
461 : sal_Bool bEmptyPresObj;
462 : sal_Int32 mnText;
463 :
464 : public:
465 : SdrUndoObjSetText(SdrObject& rNewObj, sal_Int32 nText );
466 : virtual ~SdrUndoObjSetText();
467 :
468 0 : bool IsDifferent() const { return pOldText!=pNewText; }
469 : void AfterSetText();
470 :
471 : virtual void Undo();
472 : virtual void Redo();
473 :
474 : virtual OUString GetComment() const;
475 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
476 :
477 : virtual void SdrRepeat(SdrView& rView);
478 : virtual bool CanSdrRepeat(SdrView& rView) const;
479 : };
480 :
481 : // Implement Title/Description Elements UI for Writer text frames, graphics and embedded objects (#i73249#)
482 356 : class SdrUndoObjStrAttr : public SdrUndoObj
483 : {
484 : public:
485 : enum ObjStrAttrType
486 : {
487 : OBJ_NAME,
488 : OBJ_TITLE,
489 : OBJ_DESCRIPTION
490 : };
491 :
492 : protected:
493 : const ObjStrAttrType meObjStrAttr;
494 : const String msOldStr;
495 : const String msNewStr;
496 :
497 : public:
498 : SdrUndoObjStrAttr( SdrObject& rNewObj,
499 : const ObjStrAttrType eObjStrAttr,
500 : const String& sOldStr,
501 : const String& sNewStr);
502 :
503 : virtual void Undo();
504 : virtual void Redo();
505 :
506 : virtual OUString GetComment() const;
507 : };
508 :
509 :
510 : /*
511 : * Layer
512 : */
513 :
514 : //************************************************************
515 : // SdrUndoLayer
516 : //
517 : // Abstrakte Basisklasse fuer alle UndoActions die mit SdrLayer zu tun haben.
518 : //
519 : //************************************************************
520 :
521 : class SdrUndoLayer : public SdrUndoAction
522 : {
523 : protected:
524 : SdrLayer* pLayer;
525 : SdrLayerAdmin* pLayerAdmin;
526 : sal_uInt16 nNum;
527 : bool bItsMine;
528 :
529 : protected:
530 : SdrUndoLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
531 : virtual ~SdrUndoLayer();
532 : };
533 :
534 : //************************************************************
535 : // SdrUndoNewLayer
536 : //
537 : // Einfuegen eines neuen Layer. Action nach dem Einfuegen konstruieren.
538 : //
539 : //************************************************************
540 :
541 0 : class SdrUndoNewLayer : public SdrUndoLayer
542 : {
543 : public:
544 0 : SdrUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
545 0 : : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) {}
546 :
547 : virtual void Undo();
548 : virtual void Redo();
549 :
550 : virtual OUString GetComment() const;
551 : };
552 :
553 : //************************************************************
554 : // SdrUndoDelLayer
555 : //
556 : // Loeschen eines Layer. Action vor dem Remove konstruieren
557 : //
558 : //************************************************************
559 :
560 2 : class SdrUndoDelLayer : public SdrUndoLayer
561 : {
562 : public:
563 1 : SdrUndoDelLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
564 1 : : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) { bItsMine=sal_True; }
565 :
566 : virtual void Undo();
567 : virtual void Redo();
568 :
569 : virtual OUString GetComment() const;
570 : };
571 :
572 : //************************************************************
573 : // SdrUndoMoveLayer
574 : //
575 : // Verschieben eines Layer. Action vor dem Verschieben konstruieren.
576 : //
577 : //************************************************************
578 :
579 0 : class SdrUndoMoveLayer : public SdrUndoLayer
580 : {
581 : sal_uInt16 nNeuPos;
582 :
583 : public:
584 0 : SdrUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNeuPos1)
585 0 : : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel), nNeuPos(nNeuPos1) {}
586 :
587 : virtual void Undo();
588 : virtual void Redo();
589 :
590 : virtual OUString GetComment() const;
591 : };
592 :
593 :
594 : /*
595 : * Pages
596 : */
597 :
598 : //************************************************************
599 : // SdrUndoPage
600 : //
601 : // Abstrakte Basisklasse fuer alle UndoActions die mit SdrPages zu tun haben.
602 : //
603 : //************************************************************
604 :
605 59 : class SVX_DLLPUBLIC SdrUndoPage : public SdrUndoAction
606 : {
607 : protected:
608 : SdrPage& mrPage;
609 :
610 : protected:
611 : void ImpInsertPage(sal_uInt16 nNum);
612 : void ImpRemovePage(sal_uInt16 nNum);
613 : void ImpMovePage(sal_uInt16 nOldNum, sal_uInt16 nNewNum);
614 :
615 : protected:
616 : SdrUndoPage(SdrPage& rNewPg);
617 :
618 : void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, sal_uInt16 n=0, bool bRepeat = false) const;
619 : };
620 :
621 : //************************************************************
622 : // SdrUndoPageList
623 : //
624 : // Manipulationen an einer PageList: Neue Page, DeletePage, MovePage(ChangePageNum)
625 : // Abstrakte Basisklasse.
626 : //
627 : //************************************************************
628 :
629 : class SVX_DLLPUBLIC SdrUndoPageList : public SdrUndoPage
630 : {
631 : protected:
632 : sal_uInt16 nPageNum;
633 :
634 : // Bei einem Undo/Redo findet moeglicherweise Uebereignung der Page
635 : // statt. Im Dtor wird die Page deleted, wenn bItsMine==TRUE
636 : bool bItsMine;
637 :
638 : protected:
639 : SdrUndoPageList(SdrPage& rNewPg);
640 : virtual ~SdrUndoPageList();
641 : };
642 :
643 : //************************************************************
644 : // SdrUndoDelPage
645 : //
646 : // Loeschen einer Page.
647 : // Action vor dem entfernen aus der List konstruieren.
648 : //
649 : //************************************************************
650 :
651 : class SVX_DLLPUBLIC SdrUndoDelPage : public SdrUndoPageList
652 : {
653 : // Beim loeschen einer MasterPage merke ich mir in dieser UndoGroup
654 : // alle Beziehungen der Zeichenseiten zu der geloeschten MasterPage
655 : SdrUndoGroup* pUndoGroup;
656 :
657 : public:
658 : SdrUndoDelPage(SdrPage& rNewPg);
659 : virtual ~SdrUndoDelPage();
660 :
661 : virtual void Undo();
662 : virtual void Redo();
663 :
664 : virtual OUString GetComment() const;
665 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
666 :
667 : virtual void SdrRepeat(SdrView& rView);
668 : virtual bool CanSdrRepeat(SdrView& rView) const;
669 : };
670 :
671 : //************************************************************
672 : // SdrUndoNewPage
673 : //
674 : // Einfuegen einer neuen Page.
675 : // Action nach dem einfuegen in die Liste konstruieren.
676 : //
677 : //************************************************************
678 :
679 74 : class SVX_DLLPUBLIC SdrUndoNewPage : public SdrUndoPageList
680 : {
681 : public:
682 37 : SdrUndoNewPage(SdrPage& rNewPg): SdrUndoPageList(rNewPg) {}
683 :
684 : virtual void Undo();
685 : virtual void Redo();
686 :
687 : virtual OUString GetComment() const;
688 : };
689 :
690 : //************************************************************
691 : // SdrUndoCopyPage
692 : //
693 : // Kopieren einer Page
694 : // Action nach dem einfuegen in die Liste konstruieren.
695 : //
696 : //************************************************************
697 :
698 0 : class SdrUndoCopyPage : public SdrUndoNewPage
699 : {
700 : public:
701 0 : SdrUndoCopyPage(SdrPage& rNewPg): SdrUndoNewPage(rNewPg) {}
702 :
703 : virtual OUString GetComment() const;
704 : virtual OUString GetSdrRepeatComment(SdrView& rView) const;
705 :
706 : virtual void SdrRepeat(SdrView& rView);
707 : virtual bool CanSdrRepeat(SdrView& rView) const;
708 : };
709 :
710 : //************************************************************
711 : // SdrUndoSetPageNum
712 : //
713 : // Verschieben der Page innerhalb der Liste
714 : // Action vor dem Verschieben der Page konstruieren.
715 : //
716 : //************************************************************
717 :
718 0 : class SVX_DLLPUBLIC SdrUndoSetPageNum : public SdrUndoPage
719 : {
720 : protected:
721 : sal_uInt16 nOldPageNum;
722 : sal_uInt16 nNewPageNum;
723 :
724 : public:
725 0 : SdrUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1)
726 0 : : SdrUndoPage(rNewPg),nOldPageNum(nOldPageNum1),nNewPageNum(nNewPageNum1) {}
727 :
728 : virtual void Undo();
729 : virtual void Redo();
730 :
731 : virtual OUString GetComment() const;
732 : };
733 :
734 :
735 : /*
736 : * Masterpages
737 : */
738 :
739 : //************************************************************
740 : // SdrUndoPageMasterPage
741 : //
742 : // Abstrakte Basisklasse fuer alle UndoActions die mit
743 : // MasterPage-Beziehungen zu tun haben.
744 : //
745 : //************************************************************
746 :
747 : class SdrUndoPageMasterPage : public SdrUndoPage
748 : {
749 : protected:
750 : sal_Bool mbOldHadMasterPage;
751 : SetOfByte maOldSet;
752 : sal_uInt16 maOldMasterPageNumber;
753 :
754 : protected:
755 : SdrUndoPageMasterPage(SdrPage& rChangedPage);
756 :
757 : public:
758 : SVX_DLLPUBLIC virtual ~SdrUndoPageMasterPage();
759 : };
760 :
761 : //************************************************************
762 : // SdrUndoPageRemoveMasterPage
763 : //
764 : // Entfernen einer MasterPage von einer Zeichenseite.
765 : // Action vor dem Entfernen des MasterPageDescriptors erzeugen.
766 : //
767 : //************************************************************
768 :
769 0 : class SdrUndoPageRemoveMasterPage : public SdrUndoPageMasterPage
770 : {
771 : public:
772 : SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage);
773 :
774 : virtual void Undo();
775 : virtual void Redo();
776 :
777 : virtual OUString GetComment() const;
778 : };
779 :
780 : //************************************************************
781 : // SdrUndoPageChangeMasterPage
782 : //
783 : // Aenderung des MasterPageDescriptors (z.B. Aendern der VisibleLayer).
784 : // Action vor der Aenderung am MasterPageDescriptor erzeugen.
785 : //
786 : //************************************************************
787 :
788 0 : class SVX_DLLPUBLIC SdrUndoPageChangeMasterPage : public SdrUndoPageMasterPage
789 : {
790 : protected:
791 : sal_Bool mbNewHadMasterPage;
792 : SetOfByte maNewSet;
793 : sal_uInt16 maNewMasterPageNumber;
794 :
795 : public:
796 : SdrUndoPageChangeMasterPage(SdrPage& rChangedPage);
797 :
798 : virtual void Undo();
799 : virtual void Redo();
800 :
801 : virtual OUString GetComment() const;
802 : };
803 :
804 : ///////////////////////////////////////////////////////////////////////
805 :
806 : /** the SdrUndoFactory can be set and retrieved from the SdrModel.
807 : It is used by the drawing layer implementations to create undo actions.
808 : It can be used by applications to create application specific undo actions.
809 : */
810 183 : class SVX_DLLPUBLIC SdrUndoFactory
811 : {
812 : public:
813 : // shapes
814 : virtual ~SdrUndoFactory();
815 : virtual SdrUndoAction* CreateUndoMoveObject( SdrObject& rObject );
816 : virtual SdrUndoAction* CreateUndoMoveObject( SdrObject& rObject, const Size& rDist );
817 : virtual SdrUndoAction* CreateUndoGeoObject( SdrObject& rObject );
818 : virtual SdrUndoAction* CreateUndoAttrObject( SdrObject& rObject, bool bStyleSheet1 = false, bool bSaveText = false );
819 : virtual SdrUndoAction* CreateUndoRemoveObject( SdrObject& rObject, bool bOrdNumDirect = false);
820 : virtual SdrUndoAction* CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect = false);
821 : virtual SdrUndoAction* CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect = false);
822 : virtual SdrUndoAction* CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect = false);
823 : virtual SdrUndoAction* CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect = false);
824 :
825 : virtual SdrUndoAction* CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1);
826 :
827 : virtual SdrUndoAction* CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject, bool bOrdNumDirect = false );
828 : virtual SdrUndoAction* CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer );
829 : virtual SdrUndoAction* CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText );
830 :
831 : // Implement Title/Description Elements UI for Writer text frames, graphics and embedded objects (#i73249#)
832 : virtual SdrUndoAction* CreateUndoObjectStrAttr( SdrObject& rObject,
833 : SdrUndoObjStrAttr::ObjStrAttrType eObjStrAttrType,
834 : String sOldStr,
835 : String sNewStr );
836 :
837 : // layer
838 : virtual SdrUndoAction* CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
839 : virtual SdrUndoAction* CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
840 : virtual SdrUndoAction* CreateUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNeuPos1);
841 :
842 : // page
843 : virtual SdrUndoAction* CreateUndoDeletePage(SdrPage& rPage);
844 : virtual SdrUndoAction* CreateUndoNewPage(SdrPage& rPage);
845 : virtual SdrUndoAction* CreateUndoCopyPage(SdrPage& rPage);
846 : virtual SdrUndoAction* CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1);
847 :
848 : // master page
849 : virtual SdrUndoAction* CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage);
850 : virtual SdrUndoAction* CreateUndoPageChangeMasterPage(SdrPage& rChangedPage);
851 : };
852 :
853 : #endif //_SVDUNDO_HXX
854 :
855 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
