sw/inc/ndarr.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: ndarr.hxx,v $
  10  * $Revision: 1.20 $
  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 #ifndef _NDARR_HXX
  32 #define _NDARR_HXX
  33
  34 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  35 #include <svtools/svarray.hxx>
  36
  37 #ifndef _BPARR_HXX
  38 #include <bparr.hxx>
  39 #endif
  40 #include <ndtyp.hxx>
  41
  42 #include <svtools/embedhlp.hxx>
  43 #include <vector>
  44
  45 class Graphic;
  46 class GraphicObject;
  47 class String;
  48 class SwAttrSet;
  49 class SfxItemSet;
  50 class SwCntntNode;
  51 class SwDoc;
  52 class SwGrfFmtColl;
  53 class SwGrfNode;
  54 class SwHistory;
  55 class SwNode;
  56 class SwNodeIndex;
  57 class SwNodeRange;
  58 class SwOLENode;
  59 class SwOutlineNodes;
  60 class SwPaM;
  61 class SwSection;
  62 class SwSectionFmt;
  63 class SwSectionNode;
  64 class SwStartNode;
  65 class SwTableBoxFmt;
  66 class SwTableFmt;
  67 class SwTableLine;
  68 class SwTableLineFmt;
  69 class SwTableNode;
  70 class SwTblToTxtSaves;
  71 class SwTxtFmtColl;
  72 class SwTxtNode;
  73 class SwUndoTblToTxt;
  74 class SwUndoTxtToTbl;
  75 struct SwPosition;
  76
  77
  78 // --------------------
  79 // class SwNodes
  80 // --------------------
  81
  82 typedef SwNode * SwNodePtr;
  83 typedef BOOL (*FnForEach_SwNodes)( const SwNodePtr&, void* pArgs );
  84
  85 SV_DECL_PTRARR_SORT( SwOutlineNodes, SwNodePtr, 0, 10 )
  86
  87 class SW_DLLPUBLIC SwNodes: private BigPtrArray
  88 {
  89     friend class SwDoc;
  90     friend class SwNode;
  91     friend class SwNodeIndex;
  92
  93     SwNodeIndex* pRoot;                                 // Liste aller Indizies auf Nodes
  94
  95     // --> OD 2008-05-14 #refactorlists# - removed <bSyncNumberAndNumRule>
  96     void InsertNode( const SwNodePtr pNode,
  97                      const SwNodeIndex& rPos );
  98     void InsertNode( const SwNodePtr pNode,
  99                      ULONG nPos );
 100     // <--
 101
 102
 103     SwDoc* pMyDoc;                                              // in diesem Doc ist das Nodes-Array
 104
 105     SwNode *pEndOfPostIts, *pEndOfInserts,      // das sind die festen Bereiche
 106            *pEndOfAutotext, *pEndOfRedlines,
 107            *pEndOfContent;
 108
 109     mutable SwOutlineNodes* pOutlineNds;                // Array aller GliederiungsNodes
 110
 111     BOOL bInNodesDel : 1;                               // falls rekursiv aufgerufen wird
 112                                         // Num/Outline nicht aktualisierem
 113     BOOL bInDelUpdOutl : 1;                             // Flags fuers aktualisieren von Outl.
 114     BOOL bInDelUpdNum : 1;                              // Flags fuers aktualisieren von Outl.
 115
 116     // fuer dier Verwaltung der Indizies
 117     void RegisterIndex( SwNodeIndex& rIdx );
 118     void DeRegisterIndex( SwNodeIndex& rIdx );
 119     void RemoveNode( ULONG nDelPos, ULONG nLen, BOOL bDel );
 120
 121     // Aktionen auf die Nodes
 122     void SectionUpDown( const SwNodeIndex & aStart, const SwNodeIndex & aEnd );
 123     void DelNodes( const SwNodeIndex& rStart, ULONG nCnt = 1 );
 124
 125     void ChgNode( SwNodeIndex& rDelPos, ULONG nSize,
 126                   SwNodeIndex& rInsPos, BOOL bNewFrms );
 127
 128     void UpdtOutlineIdx( const SwNode& );       // Update ab Node alle OutlineNodes
 129
 130     void _CopyNodes( const SwNodeRange&, const SwNodeIndex&,
 131                     BOOL bNewFrms = TRUE, BOOL bTblInsDummyNode = FALSE ) const;
 132     void _DelDummyNodes( const SwNodeRange& rRg );
 133
 134 protected:
 135     SwNodes( SwDoc* pDoc );
 136
 137 public:
 138     ~SwNodes();
 139
 140     SwNodePtr operator[]( ULONG n ) const
 141         { return (SwNodePtr)BigPtrArray::operator[] ( n ); }
 142
 143 //JP 29.09.97: impl. steht im ndindex.hxx - sollte moeglichst bald auf die
 144 //                              neue Schnittstelle angepasst werden
 145     inline SwNodePtr operator[]( const SwNodeIndex& rIdx ) const;
 146
 147     ULONG Count() const { return BigPtrArray::Count(); }
 148     void ForEach( FnForEach_SwNodes fnForEach, void* pArgs = 0 )
 149     {
 150         BigPtrArray::ForEach( 0, BigPtrArray::Count(),
 151                                 (FnForEach) fnForEach, pArgs );
 152     }
 153     void ForEach( ULONG nStt, ULONG nEnd, FnForEach_SwNodes fnForEach, void* pArgs = 0 )
 154     {
 155         BigPtrArray::ForEach( nStt, nEnd, (FnForEach) fnForEach, pArgs );
 156     }
 157     void ForEach( const SwNodeIndex& rStart, const SwNodeIndex& rEnd,
 158                     FnForEach_SwNodes fnForEach, void* pArgs = 0 );
 159
 160     // eine noch leere Section
 161     SwNode& GetEndOfPostIts() const     { return *pEndOfPostIts; }
 162     // Section fuer alle Fussnoten
 163     SwNode& GetEndOfInserts() const     { return *pEndOfInserts; }
 164     // Section fuer alle Flys/Header/Footers
 165     SwNode& GetEndOfAutotext() const    { return *pEndOfAutotext; }
 166     // Section fuer alle Redlines
 167     SwNode& GetEndOfRedlines() const    { return *pEndOfRedlines; }
 168     // das ist der letzte EndNode einer SonderSection. Hier nach kommt nur
 169     // noch die normale ContentSection (also der BodyText)
 170     SwNode& GetEndOfExtras() const              { return *pEndOfRedlines; }
 171     // die normale ContentSection (also der BodyText)
 172     SwNode& GetEndOfContent() const             { return *pEndOfContent; }
 173
 174     // ist das NodesArray das normale vom Doc? (nicht das UndoNds, .. )
 175     // Implementierung steht im doc.hxx (weil man dazu Doc kennen muss) !
 176     BOOL IsDocNodes() const;
 177
 178     USHORT GetSectionLevel(const SwNodeIndex &rIndex) const;
 179     void Delete(const SwNodeIndex &rPos, ULONG nNodes = 1);
 180
 181     BOOL _MoveNodes( const SwNodeRange&, SwNodes& rNodes, const SwNodeIndex&,
 182                 BOOL bNewFrms = TRUE );
 183     void MoveRange( SwPaM&, SwPosition&, SwNodes& rNodes );
 184
 185     void _Copy( const SwNodeRange& rRg, const SwNodeIndex& rInsPos,
 186                 BOOL bNewFrms = TRUE ) const
 187         {   _CopyNodes( rRg, rInsPos, bNewFrms ); }
 188
 189     void SectionUp( SwNodeRange *);
 190     void SectionDown( SwNodeRange *pRange, SwStartNodeType = SwNormalStartNode );
 191
 192     BOOL CheckNodesRange( const SwNodeIndex& rStt, const SwNodeIndex& rEnd ) const;
 193
 194     void GoStartOfSection(SwNodeIndex *) const;
 195     void GoEndOfSection(SwNodeIndex *) const;
 196
 197     SwCntntNode* GoNext(SwNodeIndex *) const;
 198     SwCntntNode* GoPrevious(SwNodeIndex *) const;
 199
 200     //Gehe zum naechsten/vorherigen Cntnt/Tabellennode, fuer den
 201     //es LayoutFrames gibt, dabei Kopf-/Fusszeilen/Rahmen etc. nicht verlassen
 202     SwNode* GoNextWithFrm(SwNodeIndex *) const;
 203     SwNode* GoPreviousWithFrm(SwNodeIndex *) const;
 204
 205     // zum naechsten Content-Node, der nicht geschuetzt oder versteckt ist
 206     // (beides auf FALSE ==> GoNext/GoPrevious!!!)
 207     SwCntntNode* GoNextSection( SwNodeIndex *, int bSkipHidden  = TRUE,
 208                                            int bSkipProtect = TRUE ) const;
 209     SwCntntNode* GoPrevSection( SwNodeIndex *, int bSkipHidden  = TRUE,
 210                                            int bSkipProtect = TRUE ) const;
 211
 212     // erzeuge ein leere Section von Start und EndNode. Darf nur gerufen
 213     // werden, wenn eine neue Section mit Inhalt erzeugt werden soll.
 214     // Zum Beispiel bei den Filtern/Undo/...
 215     SwStartNode* MakeEmptySection( const SwNodeIndex& rIdx,
 216                                     SwStartNodeType = SwNormalStartNode );
 217
 218     // die Impl. von "Make...Node" stehen in den angegebenen .ccx-Files
 219     SwTxtNode *MakeTxtNode( const SwNodeIndex & rWhere,
 220                             SwTxtFmtColl *pColl,
 221                             SwAttrSet* pAutoAttr = 0 ); // in ndtxt.cxx
 222     SwStartNode* MakeTextSection( const SwNodeIndex & rWhere,
 223                             SwStartNodeType eSttNdTyp,
 224                             SwTxtFmtColl *pColl,
 225                             SwAttrSet* pAutoAttr = 0 );
 226
 227     SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
 228                             const String& rGrfName,
 229                             const String& rFltName,
 230                             const Graphic* pGraphic,
 231                             SwGrfFmtColl *pColl,
 232                             SwAttrSet* pAutoAttr = 0,
 233                             BOOL bDelayed = FALSE );    // in ndgrf.cxx
 234
 235     SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
 236                             const GraphicObject& rGrfObj,
 237                             SwGrfFmtColl *pColl,
 238                             SwAttrSet* pAutoAttr = 0 ); // in ndgrf.cxx
 239
 240     SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
 241                             const svt::EmbeddedObjectRef&,
 242                             SwGrfFmtColl *pColl,
 243                             SwAttrSet* pAutoAttr = 0 ); // in ndole.cxx
 244     SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
 245                             const String &rName,
 246                             sal_Int64 nAspect,
 247                             SwGrfFmtColl *pColl,
 248                             SwAttrSet* pAutoAttr );     // in ndole.cxx
 249
 250         // Array aller GliederiungsNodes;
 251     const SwOutlineNodes& GetOutLineNds() const;
 252
 253     //void UpdateOutlineNode( const SwNode&, BYTE nOldLevel, BYTE nNewLevel );//#outline level,removed by zhaojianwei
 254         // alle Nodes Updaten - Rule/Format-Aenderung
 255     void UpdateOutlineNode(SwNode & rNd);
 256
 257         // fuege die Nodes fuer die Tabelle ein
 258         // wenn Lines angegeben, erzeuge die Matrix aus Lines & Boxen
 259         // ansonsten nur die Anzahl von Boxen.
 260     /* #109161#
 261
 262        New parameter pAttrSet: If pAttrSet is non-null and contains an
 263        adjust item it is propagated to the table cells. If there is an
 264        adjust in pCntntTxtColl or pHeadlineTxtColl this adjust item
 265        overrides the item in pAttrSet.
 266
 267      */
 268     SwTableNode* InsertTable( const SwNodeIndex& rNdIdx,
 269                         USHORT nBoxes, SwTxtFmtColl* pCntntTxtColl,
 270                         USHORT nLines = 0, USHORT nRepeat = 0,
 271                         SwTxtFmtColl* pHeadlineTxtColl = 0,
 272                         const SwAttrSet * pAttrSet = 0);
 273
 274         // erzeuge aus dem makierten Bereich eine ausgeglichene Tabelle
 275     SwTableNode* TextToTable( const SwNodeRange& rRange, sal_Unicode cCh,
 276                                 SwTableFmt* pTblFmt,
 277                                 SwTableLineFmt* pLineFmt,
 278                                 SwTableBoxFmt* pBoxFmt,
 279                                 SwTxtFmtColl* pTxtColl,
 280                                 SwUndoTxtToTbl* pUndo = 0 );
 281     //create a table from a vector of NodeRanges - API support
 282     SwTableNode* TextToTable( const std::vector< std::vector<SwNodeRange> >& rTableNodes,
 283                                 SwTableFmt* pTblFmt,
 284                                 SwTableLineFmt* pLineFmt,
 285                                 SwTableBoxFmt* pBoxFmt,
 286                                 SwTxtFmtColl* pTxtColl
 287                                 /*, SwUndo... pUndo*/ );
 288
 289         // erzeuge aus der Tabelle wieder normalen Text
 290     BOOL TableToText( const SwNodeRange& rRange, sal_Unicode cCh,
 291                         SwUndoTblToTxt* = 0 );
 292         // steht im untbl.cxx und darf nur vom Undoobject gerufen werden
 293     SwTableNode* UndoTableToText( ULONG nStt, ULONG nEnd,
 294                         const SwTblToTxtSaves& rSavedData );
 295
 296         // fuege in der Line, vor der InsPos eine neue Box ein. Das Format
 297         // wird von der nachfolgenden (vorhergenden;wenn an Ende) genommen
 298         // in der Line muss schon eine Box vorhanden sein !
 299     BOOL InsBoxen( SwTableNode*, SwTableLine*, SwTableBoxFmt*,
 300                         // Formate fuer den TextNode der Box
 301                         SwTxtFmtColl*, const SfxItemSet* pAutoAttr,
 302                         USHORT nInsPos, USHORT nCnt = 1 );
 303         // Splittet eine Tabelle in der Grund-Zeile, in der der Index steht.
 304         // Alle GrundZeilen dahinter wandern in eine neue Tabelle/-Node.
 305         // Ist das Flag bCalcNewSize auf TRUE, wird fuer beide neuen Tabellen
 306         // die neue SSize aus dem Max der Boxen errechnet; vorrausgesetzt,
 307         // die SSize ist "absolut" gesetzt (LONG_MAX)
 308         // (Wird zur Zeit nur fuer den RTF-Parser benoetigt)
 309     SwTableNode* SplitTable( const SwNodeIndex& rPos, BOOL bAfter = TRUE,
 310                                 BOOL bCalcNewSize = FALSE );
 311         // fuegt 2 Tabellen, die hintereinander stehen, wieder zusammen
 312     BOOL MergeTable( const SwNodeIndex& rPos, BOOL bWithPrev = TRUE,
 313                     USHORT nMode = 0, SwHistory* pHistory = 0 );
 314
 315         // fuege eine neue SwSection ein
 316     SwSectionNode* InsertSection( const SwNodeIndex& rNdIdx,
 317                                 SwSectionFmt& rSectionFmt,
 318                                 const SwSection&,
 319                                 const SwNodeIndex* pEnde,
 320                                 BOOL bInsAtStart = TRUE,
 321                                 BOOL bCreateFrms = TRUE );
 322
 323         // in welchem Doc steht das Nodes-Array ?
 324             SwDoc* GetDoc()                     { return pMyDoc; }
 325     const       SwDoc* GetDoc() const   { return pMyDoc; }
 326
 327         // suche den vorhergehenden [/nachfolgenden ] ContentNode oder
 328         // TabellenNode mit Frames. Wird kein Ende angeben, dann wird mit
 329         // dem FrameIndex begonnen; ansonsten, wird mit dem vor rFrmIdx und
 330         // dem hintern pEnd die Suche gestartet. Sollte kein gueltiger Node
 331         // gefunden werden, wird 0 returnt. rFrmIdx zeigt auf dem Node mit
 332         // Frames
 333     SwNode* FindPrvNxtFrmNode( SwNodeIndex& rFrmIdx,
 334                                 const SwNode* pEnd = 0 ) const;
 335
 336     //-> #112139#
 337     SwNode * DocumentSectionStartNode(SwNode * pNode) const;
 338     SwNode * DocumentSectionEndNode(SwNode * pNode) const;
 339     //<- #112139#
 340 private:
 341     // privater Constructor, weil nie kopiert werden darf !!
 342     SwNodes( const SwNodes & rNodes );
 343 };
 344
 345
 346
 347 #endif