sw/inc/node.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: node.hxx,v $
  10  * $Revision: 1.22.144.1 $
  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 _NODE_HXX
  32 #define _NODE_HXX
  33
  34 #include <tools/mempool.hxx>
  35 #include <tools/gen.hxx>
  36 #include "swdllapi.h"
  37 #include <ndarr.hxx>
  38 #include <ndtyp.hxx>
  39 #include <index.hxx>
  40 #include <fmtcol.hxx>
  41 #include <boost/shared_ptr.hpp>
  42 #include <vector>
  43 // ---------------------
  44 // forward Deklarationen
  45 // ---------------------
  46
  47 class SvUShorts;
  48 class SwCntntFrm;
  49 class SwCntntNode;
  50 class SwDoc;
  51 class SwEndNode;
  52 class SwFrm;
  53 class SwFrmFmt;
  54 class SwGrfNode;
  55 class SwNoTxtNode;
  56 class SwNodeIndex;
  57 class SwOLENode;
  58 class SwRect;
  59 class SwSection;
  60 class SwSectionFmt;
  61 class SwSectionNode;
  62 class SwStartNode;
  63 class SwTabFrm;
  64 class SwTable;
  65 class SwTableNode;
  66 class SwTableBox;
  67 class SwTxtNode;
  68 class SwPageDesc;
  69 class ViewShell;
  70 struct SwPosition;
  71 class IStyleAccess;
  72 class IDocumentSettingAccess;
  73 class IDocumentDeviceAccess;
  74 class IDocumentMarkAccess;
  75 class IDocumentRedlineAccess;
  76 class IDocumentStylePoolAccess;
  77 class IDocumentLineNumberAccess;
  78 class IDocumentLinksAdministration;
  79 class IDocumentFieldsAccess;
  80 class IDocumentContentOperations;
  81 // --> OD 2007-10-31 #i83479#
  82 class IDocumentListItems;
  83 // <--
  84
  85 // --------------------
  86 // class SwNode
  87 // --------------------
  88 class SW_DLLPUBLIC SwNode : private /* public*/ BigPtrEntry
  89 {
  90     friend class SwNodes;
  91
  92 #ifndef PRODUCT
  93     static long nSerial;
  94     long nMySerial;
  95 #endif
  96
  97     BYTE nNodeType;
  98
  99     // JP 28.03.96
 100     // fuer Textnodes: Stufungslevel der Autoformatierung. Ist erstmal hier
 101     //                                  gelandet, weil noch Bits frei sind
 102     BYTE nAFmtNumLvl : 3;
 103     BOOL bSetNumLSpace : 1;                     // fuer Numerierung: TRUE Einzug setzen
 104     BOOL bIgnoreDontExpand : 1;         // for Text Attributes - ignore the flag
 105
 106 protected:
 107     SwStartNode* pStartOfSection;
 108
 109     SwNode( const SwNodeIndex &rWhere, const BYTE nNodeId );
 110
 111     // fuer den initialen StartNode
 112     SwNode( SwNodes& rNodes, ULONG nPos, const BYTE nNodeId );
 113
 114 public:
 115     virtual ~SwNode();
 116
 117 #ifndef PRODUCT
 118     long int GetSerial() const { return nMySerial; }
 119 #endif
 120
 121     USHORT GetSectionLevel() const;
 122
 123     inline ULONG StartOfSectionIndex() const;
 124     inline const SwStartNode* StartOfSectionNode() const { return pStartOfSection; }
 125     inline       SwStartNode* StartOfSectionNode() { return pStartOfSection; }
 126
 127     inline ULONG EndOfSectionIndex() const;
 128     inline const SwEndNode* EndOfSectionNode() const;
 129     inline         SwEndNode* EndOfSectionNode();
 130
 131     inline BYTE GetAutoFmtLvl() const     { return nAFmtNumLvl; }
 132     inline void SetAutoFmtLvl( BYTE nVal )      { nAFmtNumLvl = nVal; }
 133
 134     inline BOOL IsSetNumLSpace() const  { return bSetNumLSpace; }
 135     inline void SetNumLSpace( BOOL bFlag )        { bSetNumLSpace = bFlag; }
 136
 137     inline BOOL IsIgnoreDontExpand() const  { return bIgnoreDontExpand; }
 138     inline void SetIgnoreDontExpand( BOOL bNew )  { bIgnoreDontExpand = bNew; }
 139
 140     BYTE        GetNodeType() const { return nNodeType; }
 141
 142     inline       SwStartNode *GetStartNode();
 143     inline const SwStartNode *GetStartNode() const;
 144     inline       SwCntntNode *GetCntntNode();
 145     inline const SwCntntNode *GetCntntNode() const;
 146     inline       SwEndNode   *GetEndNode();
 147     inline const SwEndNode   *GetEndNode() const;
 148 #ifndef  ICC
 149   inline
 150 #endif
 151     SwTxtNode   *GetTxtNode();
 152
 153 #ifndef  ICC
 154   inline
 155 #endif
 156     const SwTxtNode   *GetTxtNode() const;
 157     inline        SwOLENode   *GetOLENode();
 158     inline  const SwOLENode   *GetOLENode() const;
 159     inline        SwNoTxtNode *GetNoTxtNode();
 160     inline  const SwNoTxtNode *GetNoTxtNode() const;
 161     inline        SwGrfNode   *GetGrfNode();
 162     inline  const SwGrfNode   *GetGrfNode() const;
 163     inline       SwTableNode *GetTableNode();
 164     inline const SwTableNode *GetTableNode() const;
 165     inline       SwSectionNode *GetSectionNode();
 166     inline const SwSectionNode *GetSectionNode() const;
 167
 168     inline BOOL IsStartNode() const;
 169     inline BOOL IsCntntNode() const;
 170     inline BOOL IsEndNode() const;
 171     inline BOOL IsTxtNode() const;
 172     inline BOOL IsTableNode() const;
 173     inline BOOL IsSectionNode() const;
 174     inline BOOL IsOLENode() const;
 175     inline BOOL IsNoTxtNode() const;
 176     inline BOOL IsGrfNode() const;
 177
 178     /**
 179        Checks if this node is in redlines.
 180
 181        @retval TRUE       this node is in redlines
 182        @retval FALSE      else
 183      */
 184     BOOL IsInRedlines() const;
 185
 186     // suche den TabellenNode, in dem dieser steht. Wenn in keiner
 187     // Tabelle wird 0 returnt.
 188                     SwTableNode *FindTableNode();
 189     inline const  SwTableNode *FindTableNode() const;
 190
 191     // suche den SectionNode, in dem dieser steht. Wenn es in keiner
 192     // Section steht wird 0 returnt.
 193                     SwSectionNode *FindSectionNode();
 194     inline    const   SwSectionNode *FindSectionNode() const;
 195
 196     SwStartNode* FindSttNodeByType( SwStartNodeType eTyp );
 197     inline const SwStartNode* FindSttNodeByType( SwStartNodeType eTyp ) const;
 198
 199     const SwStartNode* FindTableBoxStartNode() const
 200                         { return FindSttNodeByType( SwTableBoxStartNode ); }
 201     const SwStartNode* FindFlyStartNode() const
 202                         { return FindSttNodeByType( SwFlyStartNode ); }
 203     const SwStartNode* FindFootnoteStartNode() const
 204                         { return FindSttNodeByType( SwFootnoteStartNode ); }
 205     const SwStartNode* FindHeaderStartNode() const
 206                         { return FindSttNodeByType( SwHeaderStartNode ); }
 207     const SwStartNode* FindFooterStartNode() const
 208                         { return FindSttNodeByType( SwFooterStartNode ); }
 209
 210         // in welchem Nodes-Array/Doc steht der Node ?
 211     inline          SwNodes& GetNodes();
 212     inline const  SwNodes& GetNodes() const;
 213     inline            SwDoc* GetDoc();
 214     inline const  SwDoc* GetDoc() const;
 215
 216     /** Provides access to the document setting interface
 217      */
 218     const IDocumentSettingAccess* getIDocumentSettingAccess() const;
 219
 220     /** Provides access to the document device interface
 221      */
 222     const IDocumentDeviceAccess* getIDocumentDeviceAccess() const;
 223
 224     /** Provides access to the document bookmark interface
 225      */
 226     const IDocumentMarkAccess* getIDocumentMarkAccess() const;
 227
 228     /** Provides access to the document redline interface
 229      */
 230     const IDocumentRedlineAccess* getIDocumentRedlineAccess() const;
 231
 232     /** Provides access to the document style pool interface
 233      */
 234     const IDocumentStylePoolAccess* getIDocumentStylePoolAccess() const;
 235
 236     /** Provides access to the document line number information interface
 237      */
 238     const IDocumentLineNumberAccess* getIDocumentLineNumberAccess() const;
 239
 240     /** Provides access to the document draw model interface
 241      */
 242     const IDocumentDrawModelAccess* getIDocumentDrawModelAccess() const;
 243
 244     /** Provides access to the document layout interface
 245      */
 246     const IDocumentLayoutAccess* getIDocumentLayoutAccess() const;
 247           IDocumentLayoutAccess* getIDocumentLayoutAccess();
 248
 249     /** Provides access to the document links administration interface
 250      */
 251     const IDocumentLinksAdministration* getIDocumentLinksAdministration() const;
 252           IDocumentLinksAdministration* getIDocumentLinksAdministration();
 253
 254     /** Provides access to the document fields administration interface
 255      */
 256     const IDocumentFieldsAccess* getIDocumentFieldsAccess() const;
 257           IDocumentFieldsAccess* getIDocumentFieldsAccess();
 258
 259     /** Provides access to the document content operations interface
 260      */
 261           IDocumentContentOperations* getIDocumentContentOperations();
 262
 263     /** Provides access to the document automatic styles interface
 264      */
 265           IStyleAccess& getIDocumentStyleAccess();
 266
 267     /** Provides access to the document's numbered items interface
 268
 269         OD 2007-10-31 #i83479#
 270
 271         @author OD
 272     */
 273     IDocumentListItems& getIDocumentListItems();
 274
 275     // liegt der Node im Sichtbarenbereich der Shell ?
 276     BOOL IsInVisibleArea( ViewShell* pSh = 0 ) const;
 277     // befindet sich der Node in einem geschuetzten Bereich?
 278     BOOL IsInProtectSect() const;
 279     // befindet sich der Node in irgendetwas geschuetzten ?
 280     // (Bereich/Rahmen/Tabellenzellen/... incl. des Ankers bei
 281     //  Rahmen/Fussnoten/..)
 282     BOOL IsProtect() const;
 283     // suche den PageDesc, mit dem dieser Node formatiert ist. Wenn das
 284     // Layout vorhanden ist wird ueber das gesucht, ansonsten gibt es nur
 285     // die harte Tour ueber die Nodes nach vorne suchen!!
 286     // OD 18.03.2003 #106326#
 287     const SwPageDesc* FindPageDesc( BOOL bCalcLay, sal_uInt32* pPgDescNdIdx = 0 ) const;
 288
 289     // falls der Node in einem Fly steht, dann wird das entsprechende Format
 290     // returnt
 291     SwFrmFmt* GetFlyFmt() const;
 292
 293     // falls der Node in einer Tabelle steht, dann wird die entsprechende
 294     // TabellenBox returnt
 295     SwTableBox* GetTblBox() const;
 296
 297     inline ULONG GetIndex() const { return GetPos(); }
 298
 299     const SwTxtNode* FindOutlineNodeOfLevel( BYTE nLvl ) const;
 300
 301     BYTE HasPrevNextLayNode() const;
 302
 303 private:
 304     // privater Constructor, weil nie kopiert werden darf !!
 305     SwNode( const SwNode & rNodes );
 306     SwNode & operator= ( const SwNode & rNodes );
 307 };
 308
 309 // --------------------
 310 // class SwStartNode
 311 // --------------------
 312 class SwStartNode: public SwNode
 313 {
 314     friend class SwNode;
 315     friend class SwNodes;
 316     friend class SwEndNode;             // um theEndOfSection zu setzen !!
 317
 318     SwEndNode* pEndOfSection;
 319     SwStartNodeType eSttNdTyp;
 320
 321     // fuer den initialen StartNode
 322     SwStartNode( SwNodes& rNodes, ULONG nPos );
 323
 324 protected:
 325     SwStartNode( const SwNodeIndex &rWhere,
 326                  const BYTE nNodeType = ND_STARTNODE,
 327                  SwStartNodeType = SwNormalStartNode );
 328 public:
 329     DECL_FIXEDMEMPOOL_NEWDEL(SwStartNode)
 330
 331     SwStartNodeType GetStartNodeType() const            { return eSttNdTyp; }
 332
 333     // an alle ContentNodes der Section das ChkCondColl rufen
 334     void CheckSectionCondColl() const;
 335
 336 private:
 337     // privater Constructor, weil nie kopiert werden darf !!
 338     SwStartNode( const SwStartNode & rNode );
 339     SwStartNode & operator= ( const SwStartNode & rNode );
 340 };
 341
 342
 343 // --------------------
 344 // class SwEndNode
 345 // --------------------
 346 class SwEndNode : public SwNode
 347 {
 348     friend class SwNodes;
 349     friend class SwTableNode;           // um seinen EndNode anlegen zukoennen
 350     friend class SwSectionNode;         // um seinen EndNode anlegen zukoennen
 351
 352     // fuer den initialen StartNode
 353     SwEndNode( SwNodes& rNodes, ULONG nPos, SwStartNode& rSttNd );
 354
 355 protected:
 356     SwEndNode( const SwNodeIndex &rWhere, SwStartNode& rSttNd );
 357
 358     DECL_FIXEDMEMPOOL_NEWDEL(SwEndNode)
 359
 360 private:
 361     // privater Constructor, weil nie kopiert werden darf !!
 362     SwEndNode( const SwEndNode & rNode );
 363     SwEndNode & operator= ( const SwEndNode & rNode );
 364 };
 365
 366
 367 // --------------------
 368 // SwCntntNode
 369 // --------------------
 370 class SW_DLLPUBLIC SwCntntNode: public SwModify, public SwNode, public SwIndexReg
 371 {
 372     // Der Reader darf NewAttrSet() aufrufen!
 373 //  friend class SwSwgReader;
 374 //  friend class Sw3IoImp;
 375
 376 //FEATURE::CONDCOLL
 377     SwDepend* pCondColl;
 378 //FEATURE::CONDCOLL
 379     mutable bool mbSetModifyAtAttr;
 380
 381 protected:
 382     SwCntntNode( const SwNodeIndex &rWhere, const BYTE nNodeType,
 383                 SwFmtColl *pFmtColl );
 384     virtual ~SwCntntNode();
 385
 386     // Attribut-Set fuer alle AUTO-Attribute eines CntntNodes
 387     //  ( z.B: TxtNode oder NoTxtNode
 388     boost::shared_ptr<const SfxItemSet> mpAttrSet;
 389
 390     // lasse von den entsprechenden Nodes die spz. AttrSets anlegen
 391     virtual void NewAttrSet( SwAttrPool& ) = 0;
 392
 393     // There some functions that like to remove items from the internal
 394     // SwAttrSet (handle):
 395     USHORT ClearItemsFromAttrSet( const std::vector<USHORT>& rWhichIds );
 396
 397 public:
 398     TYPEINFO();         //Bereits in Basisklasse Client drin.
 399
 400     virtual void Modify( SfxPoolItem *pOld, SfxPoolItem *pNew);
 401
 402     virtual SwCntntFrm *MakeFrm() = 0;
 403     virtual SwCntntNode *SplitCntntNode(const SwPosition & ) = 0;
 404     virtual SwCntntNode *JoinNext();
 405     virtual SwCntntNode *JoinPrev();
 406     // koennen 2 Nodes zusammengefasst werden ?
 407     // in pIdx kann die 2. Position returnt werden.
 408     int CanJoinNext( SwNodeIndex* pIdx =0 ) const;
 409     int CanJoinPrev( SwNodeIndex* pIdx =0 ) const;
 410
 411     void MakeStartIndex( SwIndex * pIdx )       { pIdx->Assign( this, 0 ); }
 412     void MakeEndIndex( SwIndex * pIdx )         { pIdx->Assign( this, Len() ); }
 413
 414     BOOL GoNext(SwIndex *, USHORT nMode ) const;
 415     BOOL GoPrevious(SwIndex *, USHORT nMode ) const;
 416
 417     SwCntntFrm *GetFrm( const Point* pDocPos = 0,
 418                         const SwPosition *pPos = 0,
 419                         const BOOL bCalcFrm = TRUE ) const;
 420     // Gibt die tatsaechlcheGroesse des Frames zurueck bzw. ein leeres
 421     // Rechteck, wenn kein Layout existiert.
 422     // Wird fuer die Export Filter benoetigt.
 423     SwRect FindLayoutRect( const BOOL bPrtArea = FALSE,
 424                             const Point* pPoint = 0,
 425                             const BOOL bCalcFrm = FALSE  ) const;
 426     SwRect FindPageFrmRect( const BOOL bPrtArea = FALSE,
 427                             const Point* pPoint = 0,
 428                             const BOOL bCalcFrm = FALSE  ) const;
 429     /*
 430      * Methode erzeugt fuer den angegebenen Node alle Ansichten vom
 431      * Dokument. Die erzeugten Contentframes werden in das entsprechende
 432      * Layout gehaengt.
 433      */
 434     void MakeFrms( SwCntntNode& rNode );
 435     /*
 436      * Methode loescht fuer den Node alle Ansichten vom
 437      * Dokument. Die Contentframes werden aus dem entsprechenden
 438      * Layout ausgehaengt.
 439      */
 440     void DelFrms();
 441
 442     /*
 443      * liefert die Anzahl der Elemente des Inhalts des Nodes;
 444      * Default ist 1, Unterschiede gibt es beim TextNode und beim
 445      * Formelnode.
 446      */
 447     virtual xub_StrLen Len() const;
 448
 449     virtual SwCntntNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const = 0;
 450         // erfrage vom Client Informationen
 451     virtual BOOL GetInfo( SfxPoolItem& ) const;
 452
 453     // SS fuer die PoolItems: (Harte-(Fmt)Attrbutierung)
 454
 455     // Ist bInParent FALSE, wird nur in diesem Node nach dem Attribut gesucht.
 456     const SfxPoolItem& GetAttr( USHORT nWhich, BOOL bInParent=TRUE ) const;
 457     BOOL GetAttr( SfxItemSet& rSet, BOOL bInParent=TRUE ) const;
 458     // --> OD 2008-03-13 #refactorlists#
 459     // made virtual
 460     virtual BOOL SetAttr( const SfxPoolItem& );
 461     virtual BOOL SetAttr( const SfxItemSet& rSet );
 462     virtual BOOL ResetAttr( USHORT nWhich1, USHORT nWhich2 = 0 );
 463     virtual BOOL ResetAttr( const SvUShorts& rWhichArr );
 464     virtual USHORT ResetAllAttr();
 465     // <--
 466
 467     // liefert das Attribut, das nicht ueber die bedingte Vorlage kommt!
 468     const SfxPoolItem* GetNoCondAttr( USHORT nWhich, BOOL bInParents ) const;
 469
 470     // hat der Node schon eigene Auto-Attribute ?
 471     // Zugriff auf SwAttrSet
 472     inline const SwAttrSet &GetSwAttrSet() const;
 473     inline const SwAttrSet *GetpSwAttrSet() const { return static_cast<const SwAttrSet*>(mpAttrSet.get()); }
 474     inline BOOL  HasSwAttrSet() const { return mpAttrSet ? TRUE : FALSE; }
 475
 476     virtual SwFmtColl* ChgFmtColl( SwFmtColl* );
 477     SwFmtColl* GetFmtColl() const { return (SwFmtColl*)GetRegisteredIn(); }
 478
 479 //FEATURE::CONDCOLL
 480     inline SwFmtColl& GetAnyFmtColl() const;
 481     void SetCondFmtColl( SwFmtColl* );
 482     inline SwFmtColl* GetCondFmtColl() const;
 483
 484     BOOL IsAnyCondition( SwCollCondition& rTmp ) const;
 485     void ChkCondColl();
 486 //FEATURE::CONDCOLL
 487
 488     // invalidiert die am Node gesetzte NumRule. Diese wird
 489     // spaetestend in EndAction einer Shell geupdatet
 490     BOOL InvalidateNumRule();
 491
 492     // --> OD 2005-02-21 #i42921# - determines the text direction for a certain
 493     // position. Return -1, if text direction could *not* be determined.
 494     short GetTextDirection( const SwPosition& rPos,
 495                             const Point* pPt ) const;
 496     // <--
 497
 498     inline void SetModifyAtAttr( bool bSetModifyAtAttr ) const { mbSetModifyAtAttr = bSetModifyAtAttr; }
 499     inline bool GetModifyAtAttr() const { return mbSetModifyAtAttr; }
 500
 501 private:
 502     // privater Constructor, weil nie kopiert werden darf !!
 503     SwCntntNode( const SwCntntNode & rNode );
 504     SwCntntNode & operator= ( const SwCntntNode & rNode );
 505
 506 };
 507
 508
 509
 510 //---------
 511 // SwTableNode
 512 //---------
 513 class SW_DLLPUBLIC SwTableNode : public SwStartNode, public SwModify
 514 {
 515     friend class SwNodes;
 516     SwTable* pTable;
 517 protected:
 518     virtual ~SwTableNode();
 519
 520 public:
 521     SwTableNode( const SwNodeIndex & );
 522
 523     const SwTable& GetTable() const { return *pTable; }
 524     SwTable& GetTable() { return *pTable; }
 525     SwTabFrm *MakeFrm();
 526
 527     //Legt die Frms fuer den TableNode (also die TabFrms) an.
 528     void MakeFrms( SwNodeIndex* pIdxBehind );
 529
 530     //Methode loescht fuer den Node alle Ansichten vom
 531     //Dokument. Die Contentframes werden aus dem entsprechenden
 532     //Layout ausgehaengt.
 533     void DelFrms();
 534
 535     //Methode erzeugt fuer den vorhergehenden Node alle Ansichten vom
 536     //Dokument. Die erzeugten Contentframes werden in das entsprechende
 537     //Layout gehaengt.
 538     void MakeFrms( const SwNodeIndex & rIdx );
 539
 540     SwTableNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const;
 541     void SetNewTable( SwTable* , BOOL bNewFrames=TRUE );
 542
 543 private:
 544     // privater Constructor, weil nie kopiert werden darf !!
 545     SwTableNode( const SwTableNode & rNode );
 546     SwTableNode & operator= ( const SwTableNode & rNode );
 547 };
 548
 549
 550 //---------
 551 // SwSectionNode
 552 //---------
 553 class SwSectionNode : public SwStartNode
 554 {
 555     friend class SwNodes;
 556     SwSection* pSection;
 557 protected:
 558     virtual ~SwSectionNode();
 559
 560 public:
 561     SwSectionNode( const SwNodeIndex&, SwSectionFmt& rFmt );
 562
 563     const SwSection& GetSection() const { return *pSection; }
 564     SwSection& GetSection() { return *pSection; }
 565
 566     // setze ein neues SectionObject. Erstmal nur gedacht fuer die
 567     // neuen VerzeichnisSections. Der geht ueber in den Besitz des Nodes!
 568     void SetNewSection( SwSection* pNewSection );
 569
 570     SwFrm *MakeFrm();
 571
 572     //Legt die Frms fuer den SectionNode (also die SectionFrms) an.
 573     //Im Defaultfall wird bis die Frames bis zum Ende des Bereichs angelegt,
 574     //uebergibt man einen weiteren NodeIndex pEnd, so wird bis zu diesem
 575     //ein MakeFrms gerufen, genutzt wird dies von TableToText
 576     void MakeFrms( SwNodeIndex* pIdxBehind, SwNodeIndex* pEnd = NULL );
 577
 578     //Methode loescht fuer den Node alle Ansichten vom
 579     //Dokument. Die Contentframes werden aus dem entsprechenden
 580     //Layout ausgehaengt.
 581     void DelFrms();
 582
 583     //Methode erzeugt fuer den vorhergehenden Node alle Ansichten vom
 584     //Dokument. Die erzeugten Contentframes werden in das entsprechende
 585     //Layout gehaengt.
 586     void MakeFrms( const SwNodeIndex & rIdx );
 587
 588     SwSectionNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const;
 589
 590     // setze den Verweis im Format der Section auf sich selbst
 591     void NodesArrChgd();
 592
 593     // ueberprueft bei _nicht_ versteckten Bereichen, ob es Inhalt gibt, der
 594     // _nicht_ in einem versteckten (Unter-)Bereich liegt
 595     BOOL IsCntntHidden() const;
 596
 597 private:
 598     // privater Constructor, weil nie kopiert werden darf !!
 599     SwSectionNode( const SwSection& rNode );
 600     SwSectionNode & operator= ( const SwSection& rNode );
 601 };
 602
 603
 604
 605 // ---------------------- einige inline Methoden ----------------------
 606 inline       SwEndNode   *SwNode::GetEndNode()
 607 {
 608      return ND_ENDNODE == nNodeType ? (SwEndNode*)this : 0;
 609 }
 610 inline const SwEndNode   *SwNode::GetEndNode() const
 611 {
 612      return ND_ENDNODE == nNodeType ? (const SwEndNode*)this : 0;
 613 }
 614 inline       SwStartNode *SwNode::GetStartNode()
 615 {
 616      return ND_STARTNODE & nNodeType ? (SwStartNode*)this : 0;
 617 }
 618 inline const SwStartNode *SwNode::GetStartNode() const
 619 {
 620      return ND_STARTNODE & nNodeType ? (const SwStartNode*)this : 0;
 621 }
 622 inline       SwTableNode *SwNode::GetTableNode()
 623 {
 624      return ND_TABLENODE == nNodeType ? (SwTableNode*)this : 0;
 625 }
 626 inline const SwTableNode *SwNode::GetTableNode() const
 627 {
 628      return ND_TABLENODE == nNodeType ? (const SwTableNode*)this : 0;
 629 }
 630 inline       SwSectionNode *SwNode::GetSectionNode()
 631 {
 632      return ND_SECTIONNODE == nNodeType ? (SwSectionNode*)this : 0;
 633 }
 634 inline const SwSectionNode *SwNode::GetSectionNode() const
 635 {
 636      return ND_SECTIONNODE == nNodeType ? (const SwSectionNode*)this : 0;
 637 }
 638 inline       SwCntntNode *SwNode::GetCntntNode()
 639 {
 640      return ND_CONTENTNODE & nNodeType ? (SwCntntNode*)this : 0;
 641 }
 642 inline const SwCntntNode *SwNode::GetCntntNode() const
 643 {
 644      return ND_CONTENTNODE & nNodeType ? (const SwCntntNode*)this : 0;
 645 }
 646
 647
 648 inline BOOL SwNode::IsStartNode() const
 649 {
 650     return ND_STARTNODE & nNodeType  ? TRUE : FALSE;
 651 }
 652 inline BOOL SwNode::IsCntntNode() const
 653 {
 654     return ND_CONTENTNODE & nNodeType  ? TRUE : FALSE;
 655 }
 656 inline BOOL SwNode::IsEndNode() const
 657 {
 658     return ND_ENDNODE == nNodeType  ? TRUE : FALSE;
 659 }
 660 inline BOOL SwNode::IsTxtNode() const
 661 {
 662     return ND_TEXTNODE == nNodeType  ? TRUE : FALSE;
 663 }
 664 inline BOOL SwNode::IsTableNode() const
 665 {
 666     return ND_TABLENODE == nNodeType  ? TRUE : FALSE;
 667 }
 668 inline BOOL SwNode::IsSectionNode() const
 669 {
 670     return ND_SECTIONNODE == nNodeType  ? TRUE : FALSE;
 671 }
 672 inline BOOL SwNode::IsNoTxtNode() const
 673 {
 674     return ND_NOTXTNODE & nNodeType  ? TRUE : FALSE;
 675 }
 676 inline BOOL SwNode::IsOLENode() const
 677 {
 678     return ND_OLENODE == nNodeType  ? TRUE : FALSE;
 679 }
 680 inline BOOL SwNode::IsGrfNode() const
 681 {
 682     return ND_GRFNODE == nNodeType  ? TRUE : FALSE;
 683 }
 684
 685 inline const SwStartNode* SwNode::FindSttNodeByType( SwStartNodeType eTyp ) const
 686 {
 687     return ((SwNode*)this)->FindSttNodeByType( eTyp );
 688 }
 689 inline const SwTableNode* SwNode::FindTableNode() const
 690 {
 691     return ((SwNode*)this)->FindTableNode();
 692 }
 693 inline const SwSectionNode* SwNode::FindSectionNode() const
 694 {
 695     return ((SwNode*)this)->FindSectionNode();
 696 }
 697 inline ULONG SwNode::StartOfSectionIndex() const
 698 {
 699     return pStartOfSection->GetIndex();
 700 }
 701 inline ULONG SwNode::EndOfSectionIndex() const
 702 {
 703     const SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 704     return pStNd->pEndOfSection->GetIndex();
 705 }
 706 inline const SwEndNode* SwNode::EndOfSectionNode() const
 707 {
 708     const SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 709     return pStNd->pEndOfSection;
 710 }
 711 inline SwEndNode* SwNode::EndOfSectionNode()
 712 {
 713     SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 714     return pStNd->pEndOfSection;
 715 }
 716
 717 inline SwNodes& SwNode::GetNodes()
 718 {
 719     return (SwNodes&)GetArray();
 720 }
 721 inline const SwNodes& SwNode::GetNodes() const
 722 {
 723     return (SwNodes&)GetArray();
 724 }
 725
 726 inline SwDoc* SwNode::GetDoc()
 727 {
 728     return GetNodes().GetDoc();
 729 }
 730 inline const SwDoc* SwNode::GetDoc() const
 731 {
 732     return GetNodes().GetDoc();
 733 }
 734
 735 inline SwFmtColl* SwCntntNode::GetCondFmtColl() const
 736 {
 737     return pCondColl ? (SwFmtColl*)pCondColl->GetRegisteredIn() : 0;
 738 }
 739
 740
 741 inline SwFmtColl& SwCntntNode::GetAnyFmtColl() const
 742 {
 743     return pCondColl && pCondColl->GetRegisteredIn()
 744                 ? *(SwFmtColl*)pCondColl->GetRegisteredIn()
 745                 : *(SwFmtColl*)GetRegisteredIn();
 746 }
 747
 748 inline const SwAttrSet& SwCntntNode::GetSwAttrSet() const
 749 {
 750     return mpAttrSet ? *GetpSwAttrSet() : GetAnyFmtColl().GetAttrSet();
 751 }
 752
 753 //FEATURE::CONDCOLL
 754
 755 inline const SfxPoolItem& SwCntntNode::GetAttr( USHORT nWhich,
 756                                                 BOOL bInParents ) const
 757 {
 758     return GetSwAttrSet().Get( nWhich, bInParents );
 759 }
 760 #endif