binfilter/inc/bf_sw/undobj.hxx

   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: undobj.hxx,v $
  10  * $Revision: 1.11 $
  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 #ifndef _UNDOBJ_HXX
  31 #define _UNDOBJ_HXX
  32
  33 #ifndef _SVMEMPOOL_HXX //autogen
  34 #include <tools/mempool.hxx>
  35 #endif
  36 #ifndef _SVSTDARR_HXX
  37 #define _SVSTDARR_USHORTS
  38 #define _SVSTDARR_ULONGS
  39 #define _SVSTDARR_BOOLS
  40 #define _SVSTDARR_BYTES
  41 #define _SVSTDARR_USHORTSSORT
  42 #include <bf_svtools/svstdarr.hxx>
  43 #endif
  44 #ifndef _SFXITEMSET_HXX //autogen
  45 #include <bf_svtools/itemset.hxx>
  46 #endif
  47 #ifndef _COM_SUN_STAR_UNO_SEQUENCE_H_
  48 #include <com/sun/star/uno/Sequence.h>
  49 #endif
  50 #ifndef _NUMRULE_HXX
  51 #include <numrule.hxx>
  52 #endif
  53 #ifndef _REDLENUM_HXX
  54 #include <redlenum.hxx>
  55 #endif
  56 class Graphic;
  57 namespace binfilter {
  58
  59 class SwUndoIter;
  60 class SwHistory;
  61 class SwIndex;
  62 class SwPaM;
  63 struct SwPosition;
  64 class SwDoc;
  65 class SwNodes;
  66 class SwFmt;
  67 class SwFmtColl;
  68 class SwTxtFmtColl;
  69 class SwTxtNode;
  70 class SwpHints;
  71 class SwBookmark;
  72 class SwTableNode;
  73 class SwTable;
  74 class SwTableBox;
  75 struct SwSortOptions;
  76 class SwFrmFmt;
  77 class SwHstryBookmark;
  78 class SwSection;
  79 class SwSectionFmt;
  80 class SvxTabStopItem;
  81 class SwNumSection;
  82 class SwDDEFieldType;
  83
  84 class SwGrfNode;
  85 class SwUndos;
  86 class SwUndoRange;
  87 class SwFtnInfo;
  88 class SwEndNoteInfo;
  89 class SwNodeIndex;
  90 class SwNodeRange;
  91 class SwFmtAnchor;
  92 struct SwUndoGroupObjImpl;
  93 class SdrMark;
  94 class SdrMarkList;
  95 class SdrObject;
  96 class SdrObjGroup;
  97 class SdrUndoAction;
  98 class SwDrawFrmFmt;
  99 class _SaveTable;
 100 class SwTableAutoFmt;
 101 class SwSelBoxes;
 102 class SwTableSortBoxes;
 103 class SwUndoSaveSections;
 104 class SwUndoMoves;
 105 class SwStartNode;
 106 class _SaveFlyArr;
 107 class SwTblToTxtSaves;
 108 class SwRedlineData;
 109 class SwRedlineSaveData;
 110 class SwRedline;
 111 class SwSectionNode;
 112
 113 namespace utl {
 114     class TransliterationWrapper;
 115 }//STRIP008 ;
 116
 117 #ifndef PRODUCT
 118 class Writer;
 119 class SwUndo;
 120 #define OUT_UNDOBJ( name )      \
 121     friend Writer& OutUndo_ ## name( Writer&, const SwUndo& );
 122 #else
 123 #define OUT_UNDOBJ( name )
 124 #endif
 125
 126
 127 typedef SwRedlineSaveData* SwRedlineSaveDataPtr;
 128 SV_DECL_PTRARR_DEL( SwRedlineSaveDatas, SwRedlineSaveDataPtr, 8, 8 )
 129
 130 class SwUndo
 131 {
 132     USHORT nId;
 133     USHORT nOrigRedlineMode;
 134 protected:
 135
 136     void SetId( USHORT nNew ) { nId = nNew; }
 137
 138 public:
 139     SwUndo( USHORT nI ) { nId = nI; nOrigRedlineMode = REDLINE_NONE; }
 140     virtual ~SwUndo();
 141
 142     USHORT GetId() const { return nId; }
 143
 144         // das UndoObject merkt sich, welcher Mode eingeschaltet war.
 145         // In Undo/Redo/Repeat wird dann immer auf diesen zurueck geschaltet
 146     USHORT GetRedlineMode() const { return nOrigRedlineMode; }
 147     void SetRedlineMode( USHORT eMode ) { nOrigRedlineMode = eMode; }
 148
 149         // sicher und setze die RedlineDaten
 150     static BOOL FillSaveData( const SwPaM& rRange, SwRedlineSaveDatas& rSData,
 151                             BOOL bDelRange = TRUE, BOOL bCopyNext = TRUE );
 152 };
 153
 154
 155 // diese Klasse muss in ein Undo-Object vererbt werden, wenn dieses Inhalt
 156 // fuers Redo/Undo ... speichert
 157 class SwUndoSaveCntnt
 158 {
 159 protected:
 160
 161     SwHistory* pHistory;
 162
 163     // wird fuer das loeschen von Inhalt benoetigt. Fuer das ReDo werden
 164     // Inhalte in das UndoNodesArray verschoben. Diese Methoden fuegen
 165     // am Ende eines TextNodes ein Trenner fuer die Attribute. Damit werden
 166     // Attribute nicht expandiert.
 167     // MoveTo..         verschiebt aus dem NodesArray in das UndoNodesArray
 168     // MoveFrom..       verschiebt aus dem UndoNodesArray in das NodesArray
 169     void MoveToUndoNds( SwPaM& rPam,
 170                         SwNodeIndex* pNodeIdx = 0, SwIndex* pCntIdx = 0,
 171                         ULONG* pEndNdIdx = 0, xub_StrLen * pEndCntIdx = 0 );
 172
 173     // diese beiden Methoden bewegen den SPoint vom Pam zurueck/vor. Damit
 174     // kann fuer ein Undo/Redo ein Bereich aufgespannt werden. (Der
 175     // SPoint liegt dann vor dem manipuliertem Bereich !!)
 176     // Das Flag gibt an, ob noch vorm SPoint Inhalt steht.
 177
 178     // vor dem Move ins UndoNodes-Array muss dafuer gesorgt werden, das
 179     // die Inhaltstragenden Attribute aus dem Nodes-Array entfernt werden.
 180     enum DelCntntType{  DELCNT_FTN = 0x01,
 181                         DELCNT_FLY = 0x02,
 182                         DELCNT_TOC = 0x04,
 183                         DELCNT_BKM = 0x08,
 184                         DELCNT_ALL = 0x0F,
 185                         DELCNT_CHKNOCNTNT = 0x80        // nur den NodeIndex beachten
 186                     };
 187     void DelCntntIndex( const SwPosition& pMark, const SwPosition& pPoint,
 188                         DelCntntType nDelCntntType = DELCNT_ALL );
 189
 190 public:
 191     SwUndoSaveCntnt();
 192     ~SwUndoSaveCntnt();
 193     OUT_UNDOBJ( SaveCntnt )
 194 };
 195
 196
 197 // sicher eine vollstaendige Section im Nodes-Array
 198 class SwUndoSaveSection : private SwUndoSaveCntnt
 199 {
 200     SwNodeIndex *pMvStt;
 201     SwRedlineSaveDatas* pRedlSaveData;
 202     ULONG nMvLen;                       // Index ins UndoNodes-Array
 203     ULONG nStartPos;
 204
 205 protected:
 206     SwNodeIndex* GetMvSttIdx() const { return pMvStt; }
 207     ULONG GetMvNodeCnt() const { return nMvLen; }
 208
 209 public:
 210     SwUndoSaveSection();
 211     ~SwUndoSaveSection();
 212
 213     void SaveSection( SwDoc* pDoc, const SwNodeIndex& rSttIdx );
 214     void SaveSection( SwDoc* pDoc, const SwNodeRange& rRange );
 215
 216     const SwHistory* GetHistory() const { return pHistory; }
 217           SwHistory* GetHistory()               { return pHistory; }
 218     OUT_UNDOBJ( SaveSection )
 219 };
 220
 221
 222 // Diese Klasse speichert den Pam als USHORT's und kann diese wieder zu
 223 // einem PaM zusammensetzen
 224 class SwUndRng
 225 {
 226 public:
 227     ULONG nSttNode, nEndNode;
 228     xub_StrLen nSttCntnt, nEndCntnt;
 229
 230     SwUndRng( const SwPaM& );
 231
 232     void SetValues( const SwPaM& rPam );
 233 };
 234
 235
 236 class SwUndoStart: public SwUndo
 237 {
 238     // Um innerhalb von Undo zuerkennen, wann ein Start vorliegt, gibt
 239     // GetId() immer die UNDO_START zurueck. Die UserId kann ueber
 240     // GetUserId() erfragt werden.
 241     USHORT nUserId;
 242     // fuer die "Verpointerung" von Start- und End-Undos
 243     USHORT nEndOffset;
 244 public:
 245     SwUndoStart( USHORT nId );
 246     USHORT GetUserId() const { return nUserId; }
 247     // Setzen vom End-Undo-Offset geschieht im Doc::EndUndo
 248     USHORT GetEndOffset() const { return nEndOffset; }
 249     void SetEndOffset( USHORT n ) { nEndOffset = n; }
 250     OUT_UNDOBJ( Start )
 251 };
 252
 253 class SwUndoEnd: public SwUndo
 254 {
 255     // Um innerhalb von Undo zuerkennen, wann ein Ende vorliegt, gibt
 256     // GetId() immer die UNDO_END zurueck. Die UserId kann ueber
 257     // GetUserId() erfragt werden.
 258     USHORT nUserId;
 259     // fuer die "Verpointerung" von Start- und End-Undos
 260     USHORT nSttOffset;
 261 public:
 262     SwUndoEnd( USHORT nId );
 263     USHORT GetUserId() const { return nUserId; }
 264     // Setzen vom Start-Undo-Offset geschieht im Doc::EndUndo
 265     USHORT GetSttOffset() const { return nSttOffset; }
 266     void SetSttOffset( USHORT n ) { nSttOffset = n; }
 267     OUT_UNDOBJ( End )
 268 };
 269
 270 class SwUndoInsert: public SwUndo, private SwUndoSaveCntnt
 271 {
 272     SwPosition *pPos;                                   // Inhalt fuers Redo
 273     String* pTxt;
 274     SwRedlineData* pRedlData;
 275     ULONG nNode;
 276     xub_StrLen nCntnt, nLen;
 277     BOOL bIsWordDelim : 1;
 278     BOOL bIsAppend : 1;
 279
 280     friend class SwDoc;         // eigentlich nur SwDoc::Insert( String )
 281     BOOL CanGrouping( sal_Unicode cIns );
 282     BOOL CanGrouping( const SwPosition& rPos );
 283
 284 public:
 285     SwUndoInsert( const SwNodeIndex& rNode, xub_StrLen nCntnt, xub_StrLen nLen,
 286                   BOOL bWDelim = TRUE );
 287     SwUndoInsert( const SwNodeIndex& rNode );
 288     virtual ~SwUndoInsert();
 289
 290     BOOL CanGrouping( const SwPosition&, sal_Unicode cIns );
 291     OUT_UNDOBJ( Insert )
 292
 293     DECL_FIXEDMEMPOOL_NEWDEL(SwUndoInsert)
 294 };
 295
 296
 297 class SwUndoDelete: public SwUndo, private SwUndRng, private SwUndoSaveCntnt
 298 {
 299     SwNodeIndex* pMvStt;                        // Position der Nodes im UndoNodes-Array
 300     String *pSttStr, *pEndStr;
 301     SwRedlineData* pRedlData;
 302     SwRedlineSaveDatas* pRedlSaveData;
 303
 304     ULONG nNode;
 305     ULONG nNdDiff;                              // Differenz von Nodes vor-nach Delete
 306     ULONG nSectDiff;                    // Diff. von Nodes vor/nach Move mit SectionNodes
 307     USHORT nSetPos;
 308
 309     BOOL bGroup : 1;    // TRUE: ist schon eine Gruppe; wird in CanGrouping() ausgwertet !!
 310     BOOL bBackSp : 1;   // TRUE: wenn Gruppierung und der Inhalt davor geloescht wird
 311     BOOL bJoinNext: 1;  // TRUE: wenn der Bereich von Oben nach unten geht
 312     BOOL bSectNdFnd : 1;        // TRUE: Sonderbehandlung fuer SectionNodes
 313     BOOL bMvAroundSectNd :1;// TRUE: Sonderbehandlung fuer SectionNodes
 314     BOOL bTblDelLastNd : 1;     // TRUE: TextNode hinter der Tabelle einf./loeschen
 315     BOOL bDelFullPara : 1;      // TRUE: gesamte Nodes wurden geloescht
 316     BOOL bResetPgDesc : 1;      // TRUE: am nachfolgenden Node das PgDsc zuruecksetzen
 317     BOOL bResetPgBrk : 1;       // TRUE: am nachfolgenden Node das PgBreak zuruecksetzen
 318
 319     BOOL SaveCntnt( const SwPosition* pStt, const SwPosition* pEnd,
 320                     SwTxtNode* pSttTxtNd, SwTxtNode* pEndTxtNd );
 321 public:
 322     SwUndoDelete( SwPaM&, BOOL bFullPara = FALSE );
 323     virtual ~SwUndoDelete();
 324     BOOL CanGrouping( SwDoc*, const SwPaM& );
 325
 326     void SetTblDelLastNd()              { bTblDelLastNd = TRUE; }
 327
 328     // fuer die PageDesc/PageBreak Attribute einer Tabelle
 329     void SetPgBrkFlags( BOOL bPageBreak, BOOL bPageDesc )
 330         { bResetPgDesc = bPageDesc; bResetPgBrk = bPageBreak; }
 331
 332     OUT_UNDOBJ( Delete )
 333
 334     DECL_FIXEDMEMPOOL_NEWDEL(SwUndoDelete)
 335 };
 336
 337
 338
 339
 340 class SwUndoSplitNode: public SwUndo
 341 {
 342     SwHistory* pHistory;
 343     SwRedlineData* pRedlData;
 344     ULONG nNode;
 345     xub_StrLen nCntnt;
 346     BOOL bTblFlag : 1;
 347     BOOL bChkTblStt : 1;
 348 public:
 349     SwUndoSplitNode( SwDoc* pDoc, const SwPosition& rPos, BOOL bChkTbl );
 350     virtual ~SwUndoSplitNode();
 351     void SetTblFlag()           { bTblFlag = TRUE; }
 352     OUT_UNDOBJ( SplitNode )
 353 };
 354
 355
 356
 357
 358 class SwUndoAttr : public SwUndo, private SwUndRng
 359 {
 360     SfxItemSet aSet;                            // Attribute fuers Redo
 361     SwHistory* pHistory;                        // History fuers Undo
 362     SwRedlineData* pRedlData;           // Redlining
 363     SwRedlineSaveDatas* pRedlSaveData;
 364     ULONG nNdIdx;                                       // fuers Redlining - Offset
 365     USHORT nInsFlags;                           // Einfuege Flags
 366
 367 public:
 368     SwUndoAttr( const SwPaM&, const SfxItemSet&, USHORT nFlags = 0  );
 369     SwUndoAttr( const SwPaM&, const SfxPoolItem&, USHORT nFlags = 0 );
 370     virtual ~SwUndoAttr();
 371     SwHistory* GetHistory() { return pHistory; }
 372
 373     OUT_UNDOBJ( InsAttr )
 374 };
 375
 376
 377
 378 class SwUndoFmtAttr : public SwUndo
 379 {
 380     friend class SwUndoDefaultAttr;
 381     SwFmt* pFmt;
 382     SfxItemSet* pOldSet;                        // die alten Attribute
 383     ULONG nNode;
 384     USHORT nFmtWhich;
 385     BOOL bSaveDrawPt;
 386
 387     void SaveFlyAnchor( BOOL bSaveDrawPt = FALSE );
 388     void Init();
 389
 390 public:
 391     // meldet sich im Format an und sichert sich die alten Attribute
 392     SwUndoFmtAttr( const SfxItemSet& rOldSet, SwFmt& rFmt,
 393                     BOOL bSaveDrawPt = TRUE );
 394     virtual ~SwUndoFmtAttr();
 395     OUT_UNDOBJ( InsFmtAttr )
 396
 397 };
 398
 399
 400 // Hilfs-Klasse, um die geaenderten Sets zu "empfangen"
 401 struct _UndoFmtAttr : public SwClient
 402 {
 403     SwUndoFmtAttr* pUndo;
 404     BOOL bSaveDrawPt;
 405
 406     _UndoFmtAttr( SwFmt& rFmt, BOOL bSaveDrawPt = TRUE );
 407     virtual void Modify( SfxPoolItem*, SfxPoolItem* );
 408 };
 409
 410
 411 class SwUndoFmtColl : public SwUndo, private SwUndRng
 412 {
 413     SwHistory* pHistory;
 414     SwFmtColl* pFmtColl;
 415 public:
 416     SwUndoFmtColl( const SwPaM&, SwFmtColl* );
 417     virtual ~SwUndoFmtColl();
 418     SwHistory* GetHistory() { return pHistory; }
 419     OUT_UNDOBJ( SetFmtColl )
 420 };
 421
 422
 423
 424 // Basis-Klasse fuer Insert von Dokument, Glossaries und Kopieren
 425
 426 class SwUndoInsDoc //STRIP001 : public SwUndoInserts
 427 {
 428 public:
 429     SwUndoInsDoc( const SwPaM& ){DBG_BF_ASSERT(0, "STRIP");} //STRIP001 SwUndoInsDoc( const SwPaM& );
 430 };
 431
 432
 433 class SwUndoInsTbl : public SwUndo
 434 {
 435     String sTblNm;
 436     SwDDEFieldType* pDDEFldType;
 437     SvUShorts* pColWidth;
 438     SwRedlineData*      pRedlData;
 439     SwTableAutoFmt* pAutoFmt;
 440     ULONG nSttNode;
 441     USHORT nRows, nCols;
 442     USHORT nAdjust;
 443     USHORT nInsTblFlags;
 444
 445 public:
 446     SwUndoInsTbl( const SwPosition&, USHORT nCols, USHORT nRows,
 447                     USHORT eAdjust, USHORT nInsert,
 448                     const SwTableAutoFmt* pTAFmt, const SvUShorts* pColArr );
 449     virtual ~SwUndoInsTbl();
 450     OUT_UNDOBJ( InsTable )
 451 };
 452
 453 class SwUndoTblNdsChg : public SwUndo
 454 {
 455     _SaveTable* pSaveTbl;
 456     SvULongs aBoxes;
 457
 458     union {
 459         SvULongs* pNewSttNds;
 460         SwUndoSaveSections* pDelSects;
 461     } Ptrs;
 462     SvBools aMvBoxes;       // fuers SplitRow (aufgeteilte Nodes einer Box)
 463
 464     ULONG nSttNode, nCurrBox;
 465     USHORT nCount, nRelDiff, nAbsDiff, nSetColType;
 466     BOOL bFlag;
 467     BOOL bSameHeight;                   // only used for SplitRow
 468 public:
 469     SwUndoTblNdsChg( USHORT UndoId, const SwSelBoxes& rBoxes,
 470                     const SwTableNode& rTblNd );
 471     virtual ~SwUndoTblNdsChg();
 472 //STRIP001     virtual void Undo( SwUndoIter& );
 473 //STRIP001     virtual void Redo( SwUndoIter& );
 474
 475     void SaveSection( SwStartNode* pSttNd );
 476
 477     void SetColWidthParam( ULONG nBoxIdx, USHORT nMode, USHORT nType,
 478                             SwTwips nAbsDif, SwTwips nRelDif )
 479     {
 480         nCurrBox = nBoxIdx;
 481         nCount = nMode;
 482         nSetColType = nType;
 483         nAbsDiff = (USHORT)nAbsDif;
 484         nRelDiff = (USHORT)nRelDif;
 485     }
 486     OUT_UNDOBJ( TblNodesChg )
 487 };
 488
 489  class SwUndoTblMerge : public SwUndo, private SwUndRng
 490  {
 491     ULONG nTblNode;
 492             SvULongs aBoxes;
 493             SvULongs  aNewSttNds;
 494     SwHistory* pHistory;
 495
 496 public:
 497     SwUndoTblMerge( const SwPaM& rTblSel );
 498     virtual ~SwUndoTblMerge();
 499     void SetSelBoxes( const SwSelBoxes& rBoxes );
 500     void AddNewBox( ULONG nSttNdIdx )
 501         { aNewSttNds.Insert( nSttNdIdx, aNewSttNds.Count() ); }
 502 };
 503
 504
 505
 506 class _UndoTblCpyTbl_Entries;
 507
 508
 509 class SwUndoCpyTbl : public SwUndo
 510 {
 511     SwUndoDelete* pDel;
 512     ULONG nTblNode;
 513 public:
 514     SwUndoCpyTbl();
 515     virtual ~SwUndoCpyTbl();
 516     virtual void Undo( SwUndoIter& );
 517     virtual void Redo( SwUndoIter& );
 518
 519     void SetTableSttIdx( ULONG nIdx )                   { nTblNode = nIdx; }
 520     OUT_UNDOBJ( CpyTbl )
 521 };
 522
 523
 524
 525
 526 class SwUndoBookmark : public SwUndo
 527 {
 528     SwHstryBookmark* pHBookmark;
 529 protected:
 530     SwUndoBookmark( USHORT nUndoId, const SwBookmark& );
 531
 532
 533 public:
 534     virtual ~SwUndoBookmark();
 535 };
 536
 537
 538
 539 class SwUndoInsBookmark : public SwUndoBookmark
 540 {
 541 public:
 542     SwUndoInsBookmark( const SwBookmark& );
 543     OUT_UNDOBJ( InsBookmark )
 544 };
 545
 546
 547 /*--------------------------------------------------------------------
 548     Beschreibung: Undo auf Sorting
 549  --------------------------------------------------------------------*/
 550
 551
 552
 553
 554
 555
 556 //--------------------------------------------------------------------
 557
 558 class SwUndoFlyBase : public SwUndo, private SwUndoSaveSection
 559 {
 560 protected:
 561     SwFrmFmt* pFrmFmt;                                  // das gespeicherte FlyFormat
 562     ULONG nNdPgPos;
 563     xub_StrLen nCntPos;                                 // Seite/am Absatz/im Absatz
 564     USHORT nRndId;
 565     BOOL bDelFmt;                                               // loesche das gespeicherte Format
 566
 567
 568     SwUndoFlyBase( SwFrmFmt* pFormat, USHORT nUndoId );
 569
 570     SwNodeIndex* GetMvSttIdx() const { return SwUndoSaveSection::GetMvSttIdx(); }
 571     ULONG GetMvNodeCnt() const { return SwUndoSaveSection::GetMvNodeCnt(); }
 572
 573 public:
 574     virtual ~SwUndoFlyBase();
 575
 576     OUT_UNDOBJ( FlyBase )
 577 };
 578
 579 class SwUndoInsLayFmt : public SwUndoFlyBase
 580 {
 581 public:
 582     SwUndoInsLayFmt( SwFrmFmt* pFormat );
 583
 584     OUT_UNDOBJ( InsLayFmt )
 585 };
 586
 587 class SwUndoDelLayFmt : public SwUndoFlyBase
 588 {
 589     BOOL bShowSelFrm;
 590     SwUndoDelLayFmt( SwFrmFmt* pFormat );
 591 };
 592
 593
 594 class SwUndoSetFlyFmt : public SwUndo, public SwClient
 595 {
 596     SwFrmFmt* pFrmFmt;                                  // das gespeicherte FlyFormat
 597     SwFrmFmt* pOldFmt;                                  // die alte Fly Vorlage
 598     SwFrmFmt* pNewFmt;                                  // die neue Fly Vorlage
 599     SfxItemSet* pItemSet;                               // die zurueck-/ gesetzten Attribute
 600     ULONG nOldNode, nNewNode;
 601     xub_StrLen nOldCntnt, nNewCntnt;
 602     USHORT nOldAnchorTyp, nNewAnchorTyp;
 603     BOOL bAnchorChgd;
 604
 605
 606 public:
 607     SwUndoSetFlyFmt( SwFrmFmt& rFlyFmt, SwFrmFmt& rNewFrmFmt );
 608     virtual ~SwUndoSetFlyFmt();
 609
 610 };
 611
 612 //--------------------------------------------------------------------
 613
 614 class _UnReplaceData;
 615 SV_DECL_PTRARR_DEL( _UnReplaceDatas, _UnReplaceData*, 10, 25 )//STRIP008 ;
 616
 617
 618
 619 //--------------------------------------------------------------------
 620
 621
 622
 623
 624 //------------ Undo von Insert-/Delete-Sections ----------------------
 625
 626 class SwUndoInsSection : public SwUndo, private SwUndRng
 627 {
 628     SwHistory* pHistory;
 629     SwSection* pSection;
 630     SwRedlineData* pRedlData;
 631     SfxItemSet* pAttr;
 632     ULONG nSectNodePos;
 633     BOOL bSplitAtStt : 1;
 634     BOOL bSplitAtEnd : 1;
 635     BOOL bUpdateFtn : 1;
 636
 637
 638 public:
 639     SwUndoInsSection( const SwPaM&, const SwSection&,
 640                         const SfxItemSet* pSet );
 641     virtual ~SwUndoInsSection();
 642     OUT_UNDOBJ( SwUndoInsSection )
 643
 644     void SetSectNdPos( ULONG nPos )             { nSectNodePos = nPos; }
 645     void SaveSplitNode( SwTxtNode* pTxtNd, BOOL bAtStt );
 646     void SetUpdtFtnFlag( BOOL bFlag )           { bUpdateFtn = bFlag; }
 647 };
 648
 649
 650 class SwUndoChgSection : public SwUndo
 651 {
 652     ULONG nSttNd;
 653     SwSection* pSection;
 654     SfxItemSet* pAttr;
 655     BOOL bOnlyAttrChgd;
 656 public:
 657     SwUndoChgSection( const SwSectionFmt&, BOOL bOnlyAttrChgd );
 658     virtual ~SwUndoChgSection();
 659 };
 660
 661 class SwUndoChgSectPsswd : public SwUndo
 662 {
 663     ::com::sun::star::uno::Sequence <sal_Int8> aPasswd;
 664     ULONG nSectNd;
 665 public:
 666     SwUndoChgSectPsswd(
 667                 const ::com::sun::star::uno::Sequence <sal_Int8> & rOld,
 668                 const SwSectionNode* pSectNd = 0 );
 669     virtual void Undo( SwUndoIter& );
 670     virtual void Redo( SwUndoIter& );
 671     OUT_UNDOBJ( SwUndoChgSectPsswd )
 672 };
 673
 674 //------------ Undo von verschieben/stufen von Gliederung ----------------
 675
 676
 677 //--------------------------------------------------------------------
 678
 679 class SwUndoDefaultAttr : public SwUndo
 680 {
 681     SfxItemSet* pOldSet;                        // die alten Attribute
 682     SvxTabStopItem* pTabStop;
 683 public:
 684     // meldet sich im Format an und sichert sich die alten Attribute
 685     SwUndoDefaultAttr( const SfxItemSet& rOldSet );
 686     virtual ~SwUndoDefaultAttr();
 687     OUT_UNDOBJ( DefaultAttr )
 688 };
 689
 690 //--------------------------------------------------------------------
 691 // ---------- Undo fuer Numerierung ----------------------------------
 692
 693 class SwUndoInsNum : public SwUndo, private SwUndRng
 694 {
 695     SwNumRule aNumRule;
 696     SwHistory* pHistory;
 697     ULONG nSttSet;
 698     SwNumRule* pOldNumRule;
 699     String sReplaceRule;
 700     USHORT nLRSavePos;
 701 public:
 702     SwUndoInsNum( const SwPaM& rPam, const SwNumRule& rRule );
 703     virtual ~SwUndoInsNum();
 704
 705     void SetSttNum( ULONG nNdIdx ) { nSttSet = nNdIdx; }
 706
 707
 708     OUT_UNDOBJ( InsNum )
 709 };
 710
 711
 712
 713 class SwUndoNumUpDown : public SwUndo, private SwUndRng
 714 {
 715     short nOffset;
 716 public:
 717     SwUndoNumUpDown( const SwPaM& rPam, short nOffset );
 718     OUT_UNDOBJ( NumUpDown )
 719 };
 720
 721
 722 class SwUndoNumRuleStart : public SwUndo
 723 {
 724     ULONG nIdx;
 725     USHORT nOldStt, nNewStt;
 726     BOOL bSetSttValue : 1;
 727     BOOL bFlag : 1;
 728 public:
 729     SwUndoNumRuleStart( const SwPosition& rPos, USHORT nStt );
 730     OUT_UNDOBJ( NumRuleStart )
 731 };
 732
 733 //--------------------------------------------------------------------
 734 // ---------- Undo fuer DrawObjecte ----------------------------------
 735
 736
 737
 738
 739
 740 //--------------------------------------------------------------------
 741
 742
 743 //--------------------------------------------------------------------
 744
 745
 746 //--------------------------------------------------------------------
 747
 748 class SwUndoChgFtn : public SwUndo, private SwUndRng
 749 {
 750     SwHistory* pHistory;
 751     String sTxt;
 752     USHORT nNo;
 753     BOOL bEndNote;
 754 public:
 755     SwUndoChgFtn( const SwPaM& rRange, const String& rTxt,
 756                     USHORT nNum, BOOL bIsEndNote );
 757     virtual ~SwUndoChgFtn();
 758
 759
 760     SwHistory* GetHistory() { return pHistory; }
 761 };
 762
 763
 764
 765
 766 //--------------------------------------------------------------------
 767
 768
 769 //--------------------------------------------------------------------
 770
 771
 772
 773
 774
 775
 776 //--------------------------------------------------------------------
 777
 778
 779
 780 //--------------------------------------------------------------------
 781
 782 // Object der als Iterator durch die Undo-Liste laeuft, bis die
 783 // letze oder die angegebene Klammerung/Id erreicht ist.
 784
 785
 786
 787
 788
 789 }
 790 #endif