binfilter/inc/bf_sw/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.9 $
  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
  35 #ifndef _SVMEMPOOL_HXX //autogen
  36 #include <tools/mempool.hxx>
  37 #endif
  38 #ifndef _GEN_HXX //autogen
  39 #include <tools/gen.hxx>
  40 #endif
  41
  42 #ifndef _NDARR_HXX
  43 #include <ndarr.hxx>
  44 #endif
  45 #ifndef _NDTYP_HXX
  46 #include <ndtyp.hxx>
  47 #endif
  48 #ifndef _INDEX_HXX
  49 #include <index.hxx>
  50 #endif
  51 #ifndef _FMTCOL_HXX
  52 #include <fmtcol.hxx>
  53 #endif
  54 namespace binfilter {
  55 class SvUShorts;
  56 class SwCntntFrm;
  57 class SwCntntNode;
  58 class SwDoc;
  59 class SwEndNode;
  60 class SwFrm;
  61 class SwFrmFmt;
  62 class SwGrfNode;
  63 class SwNoTxtNode;
  64 class SwNodeIndex;
  65 class SwNodeRange;
  66 class SwOLENode;
  67 class SwRect;
  68 class SwSection;
  69 class SwSectionFmt;
  70 class SwSectionNode;
  71 class SwStartNode;
  72 class SwTabFrm;
  73 class SwTable;
  74 class SwTableNode;
  75 class SwTableBox;
  76 class SwTxtNode;
  77 class SwPageDesc;
  78 class ViewShell;
  79 struct SwPosition;
  80
  81 #if defined(MACOSX) && ( __GNUC__ < 3 )
  82 #define INLINE /* GrP revisit with gcc3 */
  83 #else
  84 #define INLINE inline
  85 #endif
  86
  87 // --------------------
  88 // class SwNode
  89 // --------------------
  90 class SwNode : private /* public*/ BigPtrEntry
  91 {
  92     friend class SwNodes;
  93
  94     BYTE nNodeType;
  95     BOOL bWrongDirty : 1;               // Ist das Wrong-Feld auf invalid? (nur TxtNodes)
  96     BOOL bACmplWrdDirty : 1;    // die ACompl-Liste muss angepasst werden (erstmal nur TxtNodes)
  97
  98     // JP 28.03.96
  99     // fuer Textnodes: Stufungslevel der Autoformatierung. Ist erstmal hier
 100     //                                  gelandet, weil noch Bits frei sind
 101     BYTE nAFmtNumLvl : 3;
 102     BOOL bSetNumLSpace : 1;                     // fuer Numerierung: TRUE Einzug setzen
 103     BOOL bIgnoreDontExpand : 1;         // for Text Attributes - ignore the flag
 104
 105 protected:
 106     SwStartNode* pStartOfSection;
 107
 108     SwNode( const SwNodeIndex &rWhere, const BYTE nNodeId );
 109
 110     // fuer den initialen StartNode
 111     SwNode( SwNodes& rNodes, ULONG nPos, const BYTE nNodeId );
 112
 113 public:
 114     virtual ~SwNode();
 115
 116     inline ULONG StartOfSectionIndex() const;
 117     inline const SwStartNode* StartOfSectionNode() const;
 118     inline               SwStartNode* StartOfSectionNode();
 119     inline ULONG EndOfSectionIndex() const;
 120     inline const SwEndNode* EndOfSectionNode() const;
 121     inline               SwEndNode* EndOfSectionNode();
 122
 123     inline const BOOL IsWrongDirty() const              { return bWrongDirty; }
 124     inline void SetWrongDirty( BOOL bNew )              { bWrongDirty = bNew; }
 125
 126     inline const BOOL IsAutoCompleteWordDirty() const   { return bACmplWrdDirty; }
 127     inline void SetAutoCompleteWordDirty( BOOL bNew )   { bACmplWrdDirty = bNew; }
 128
 129     inline const BYTE GetAutoFmtLvl() const             { return nAFmtNumLvl; }
 130     inline void SetAutoFmtLvl( BYTE nVal )              { nAFmtNumLvl = nVal; }
 131
 132     inline const BOOL IsSetNumLSpace() const    { return bSetNumLSpace; }
 133     inline void SetNumLSpace( BOOL bFlag )              { bSetNumLSpace = bFlag; }
 134
 135     inline const BOOL IsIgnoreDontExpand() const        { return bIgnoreDontExpand; }
 136     inline void SetIgnoreDontExpand( BOOL bNew )        { bIgnoreDontExpand = bNew; }
 137
 138     BYTE        GetNodeType() const { return nNodeType; }
 139
 140     inline       SwStartNode *GetStartNode();
 141     inline const SwStartNode *GetStartNode() const;
 142     inline       SwCntntNode *GetCntntNode();
 143     inline const SwCntntNode *GetCntntNode() const;
 144     inline       SwEndNode   *GetEndNode();
 145     inline const SwEndNode   *GetEndNode() const;
 146 #ifndef  ICC
 147   INLINE
 148 #endif
 149     SwTxtNode   *GetTxtNode();
 150
 151 #ifndef  ICC
 152   INLINE
 153 #endif
 154     const SwTxtNode   *GetTxtNode() const;
 155 #ifndef COMPACT
 156     INLINE        SwOLENode   *GetOLENode();
 157     INLINE  const SwOLENode   *GetOLENode() const;
 158     INLINE        SwNoTxtNode *GetNoTxtNode();
 159     INLINE  const SwNoTxtNode *GetNoTxtNode() const;
 160     INLINE        SwGrfNode   *GetGrfNode();
 161     INLINE  const SwGrfNode   *GetGrfNode() const;
 162 #endif
 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 #ifndef COMPACT
 175     inline BOOL IsOLENode() const;
 176     inline BOOL IsNoTxtNode() const;
 177     inline BOOL IsGrfNode() const;
 178 #endif
 179
 180     // suche den TabellenNode, in dem dieser steht. Wenn in keiner
 181     // Tabelle wird 0 returnt.
 182                     SwTableNode *FindTableNode();
 183     inline const        SwTableNode *FindTableNode() const;
 184
 185     // suche den SectionNode, in dem dieser steht. Wenn es in keiner
 186     // Section steht wird 0 returnt.
 187                     SwSectionNode *FindSectionNode();
 188     inline      const   SwSectionNode *FindSectionNode() const;
 189
 190     const       SwStartNode *FindStartNode() const      { return pStartOfSection; }
 191             SwStartNode *FindStartNode()                { return pStartOfSection; }
 192
 193     SwStartNode* FindSttNodeByType( SwStartNodeType eTyp );
 194     inline const SwStartNode* FindSttNodeByType( SwStartNodeType eTyp ) const;
 195
 196     const SwStartNode* FindTableBoxStartNode() const
 197                         { return FindSttNodeByType( SwTableBoxStartNode ); }
 198     const SwStartNode* FindFlyStartNode() const
 199                         { return FindSttNodeByType( SwFlyStartNode ); }
 200     const SwStartNode* FindFootnoteStartNode() const
 201                         { return FindSttNodeByType( SwFootnoteStartNode ); }
 202     const SwStartNode* FindHeaderStartNode() const
 203                         { return FindSttNodeByType( SwHeaderStartNode ); }
 204     const SwStartNode* FindFooterStartNode() const
 205                         { return FindSttNodeByType( SwFooterStartNode ); }
 206
 207         // in welchem Nodes-Array/Doc steht der Node ?
 208     inline                SwNodes& GetNodes();
 209     inline const  SwNodes& GetNodes() const;
 210     inline                      SwDoc* GetDoc();
 211     inline const        SwDoc* GetDoc() const;
 212
 213     // liegt der Node im Sichtbarenbereich der Shell ?
 214     // befindet sich der Node in einem geschuetzten Bereich?
 215     BOOL IsInProtectSect() const;
 216     // befindet sich der Node in irgendetwas geschuetzten ?
 217     // (Bereich/Rahmen/Tabellenzellen/... incl. des Ankers bei
 218     //  Rahmen/Fussnoten/..)
 219     BOOL IsProtect() const;
 220     // suche den PageDesc, mit dem dieser Node formatiert ist. Wenn das
 221     // Layout vorhanden ist wird ueber das gesucht, ansonsten gibt es nur
 222     // die harte Tour ueber die Nodes nach vorne suchen!!
 223     // OD 18.03.2003 #106326#
 224
 225     // falls der Node in einem Fly steht, dann wird das entsprechende Format
 226     // returnt
 227     SwFrmFmt* GetFlyFmt() const;
 228
 229     // liefert das Format, an dem die LayoutFrames des StartNodes registriert sind,
 230     // wird von SwSectionNode::MakeFrms benutzt
 231
 232     // falls der Node in einer Tabelle steht, dann wird die entsprechende
 233     // TabellenBox returnt
 234     SwTableBox* GetTblBox() const;
 235
 236     inline ULONG GetIndex() const { return GetPos(); }
 237
 238     const SwTxtNode* FindOutlineNodeOfLevel( BYTE nLvl ) const;
 239
 240
 241 private:
 242     // privater Constructor, weil nie kopiert werden darf !!
 243     SwNode( const SwNode & rNodes );
 244 };
 245
 246 // --------------------
 247 // class SwStartNode
 248 // --------------------
 249 class SwStartNode: public SwNode
 250 {
 251     friend class SwNode;
 252     friend class SwNodes;
 253     friend class SwEndNode;             // um theEndOfSection zu setzen !!
 254
 255     SwEndNode* pEndOfSection;
 256     SwStartNodeType eSttNdTyp;
 257
 258     // fuer den initialen StartNode
 259     SwStartNode( SwNodes& rNodes, ULONG nPos );
 260
 261 protected:
 262     SwStartNode( const SwNodeIndex &rWhere,
 263                  const BYTE nNodeType = ND_STARTNODE,
 264                  SwStartNodeType = SwNormalStartNode );
 265 public:
 266     DECL_FIXEDMEMPOOL_NEWDEL(SwStartNode)
 267
 268     SwStartNodeType GetStartNodeType() const            { return eSttNdTyp; }
 269
 270     // an alle ContentNodes der Section das ChkCondColl rufen
 271     void CheckSectionCondColl() const;
 272
 273 private:
 274     // privater Constructor, weil nie kopiert werden darf !!
 275     SwStartNode( const SwStartNode & rNode );
 276 };
 277
 278
 279 // --------------------
 280 // class SwEndNode
 281 // --------------------
 282 class SwEndNode : public SwNode
 283 {
 284     friend class SwNodes;
 285     friend class SwTableNode;           // um seinen EndNode anlegen zukoennen
 286     friend class SwSectionNode;         // um seinen EndNode anlegen zukoennen
 287
 288     // fuer den initialen StartNode
 289     SwEndNode( SwNodes& rNodes, ULONG nPos, SwStartNode& rSttNd );
 290
 291 protected:
 292     SwEndNode( const SwNodeIndex &rWhere, SwStartNode& rSttNd );
 293
 294     DECL_FIXEDMEMPOOL_NEWDEL(SwEndNode)
 295
 296 private:
 297     // privater Constructor, weil nie kopiert werden darf !!
 298     SwEndNode( const SwEndNode & rNode );
 299 };
 300
 301
 302 // --------------------
 303 // SwCntntNode
 304 // --------------------
 305 class SwCntntNode: public SwModify, public SwNode, public SwIndexReg
 306 {
 307     // Der Reader darf NewAttrSet() aufrufen!
 308     friend class SwSwgReader;
 309     friend class Sw3IoImp;
 310
 311 //FEATURE::CONDCOLL
 312     SwDepend* pCondColl;
 313 //FEATURE::CONDCOLL
 314
 315 protected:
 316     SwCntntNode( const SwNodeIndex &rWhere, const BYTE nNodeType,
 317                 SwFmtColl *pFmtColl );
 318     virtual ~SwCntntNode();
 319
 320     // Attribut-Set fuer alle AUTO-Attribute eines CntntNodes
 321     //  ( z.B: TxtNode oder NoTxtNode
 322     SwAttrSet *pAttrSet;
 323     // lasse von den entsprechenden Nodes die spz. AttrSets anlegen
 324     virtual void NewAttrSet( SwAttrPool& ) = 0;
 325
 326 public:
 327     TYPEINFO();         //Bereits in Basisklasse Client drin.
 328
 329     virtual void Modify( SfxPoolItem *pOld, SfxPoolItem *pNew);
 330
 331     virtual SwCntntFrm *MakeFrm() = 0;
 332      virtual SwCntntNode *SplitNode(const SwPosition & ) = 0;
 333     virtual SwCntntNode *JoinNext();
 334     virtual SwCntntNode *JoinPrev();
 335     // koennen 2 Nodes zusammengefasst werden ?
 336     // in pIdx kann die 2. Position returnt werden.
 337     int CanJoinNext( SwNodeIndex* pIdx =0 ) const;
 338     int CanJoinPrev( SwNodeIndex* pIdx =0 ) const;
 339
 340     void MakeStartIndex( SwIndex * pIdx )       { pIdx->Assign( this, 0 ); }
 341     void MakeEndIndex( SwIndex * pIdx )         { pIdx->Assign( this, Len() ); }
 342
 343     BOOL GoNext(SwIndex *, USHORT nMode ) const;
 344     BOOL GoPrevious(SwIndex *, USHORT nMode ) const;
 345
 346     SwCntntFrm *GetFrm( const Point* pDocPos = 0,
 347                         const SwPosition *pPos = 0,
 348                         const BOOL bCalcFrm = TRUE ) const;
 349     // Gibt die tatsaechlcheGroesse des Frames zurueck bzw. ein leeres
 350     // Rechteck, wenn kein Layout existiert.
 351     // Wird fuer die Export Filter benoetigt.
 352     /*
 353      * Methode erzeugt fuer den angegebenen Node alle Ansichten vom
 354      * Dokument. Die erzeugten Contentframes werden in das entsprechende
 355      * Layout gehaengt.
 356      */
 357     void MakeFrms( SwCntntNode& rNode );
 358     /*
 359      * Methode loescht fuer den Node alle Ansichten vom
 360      * Dokument. Die Contentframes werden aus dem entsprechenden
 361      * Layout ausgehaengt.
 362      */
 363     void DelFrms();
 364
 365     /*
 366      * liefert die Anzahl der Elemente des Inhalts des Nodes;
 367      * Default ist 1, Unterschiede gibt es beim TextNode und beim
 368      * Formelnode.
 369      */
 370     virtual xub_StrLen Len() const;
 371
 372     virtual SwCntntNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const = 0;
 373         // erfrage vom Client Informationen
 374     virtual BOOL GetInfo( SfxPoolItem& ) const;
 375
 376     // SS fuer die PoolItems: (Harte-(Fmt)Attrbutierung)
 377
 378     // Ist bInParent FALSE, wird nur in diesem Node nach dem Attribut gesucht.
 379     const SfxPoolItem& GetAttr( USHORT nWhich, BOOL bInParent=TRUE ) const;
 380     BOOL GetAttr( SfxItemSet& rSet, BOOL bInParent=TRUE ) const;
 381     BOOL SetAttr( const SfxPoolItem& );
 382     BOOL SetAttr( const SfxItemSet& rSet );
 383     BOOL ResetAttr( USHORT nWhich1, USHORT nWhich2 = 0 );
 384     USHORT ResetAllAttr();
 385     // liefert das Attribut, das nicht ueber die bedingte Vorlage kommt!
 386     const SfxPoolItem* GetNoCondAttr( USHORT nWhich, BOOL bInParents ) const;
 387
 388     // hat der Node schon eigene Auto-Attribute ?
 389     // Zugriff auf SwAttrSet
 390     inline               SwAttrSet &GetSwAttrSet();
 391     inline const SwAttrSet &GetSwAttrSet() const;
 392     inline               SwAttrSet *GetpSwAttrSet() { return pAttrSet; }
 393     inline const SwAttrSet *GetpSwAttrSet() const { return pAttrSet; }
 394     inline BOOL  HasSwAttrSet() const { return pAttrSet ? TRUE : FALSE; }
 395
 396     virtual SwFmtColl* ChgFmtColl( SwFmtColl* );
 397     SwFmtColl* GetFmtColl() const { return (SwFmtColl*)GetRegisteredIn(); }
 398
 399 //FEATURE::CONDCOLL
 400     inline SwFmtColl& GetAnyFmtColl() const;
 401     void SetCondFmtColl( SwFmtColl* );
 402     inline SwFmtColl* GetCondFmtColl() const;
 403
 404     BOOL IsAnyCondition( SwCollCondition& rTmp ) const;
 405     void ChkCondColl();
 406 //FEATURE::CONDCOLL
 407
 408     // invalidiert die am Node gesetzte NumRule. Diese wird
 409     // spaetestend in EndAction einer Shell geupdatet
 410     BOOL InvalidateNumRule();
 411
 412 private:
 413     // privater Constructor, weil nie kopiert werden darf !!
 414     SwCntntNode( const SwCntntNode & rNode );
 415 };
 416
 417
 418
 419 //---------
 420 // SwTableNode
 421 //---------
 422 class SwTableNode : public SwStartNode
 423 {
 424     friend class SwNodes;
 425     SwTable* pTable;
 426 protected:
 427     virtual ~SwTableNode();
 428
 429 public:
 430     SwTableNode( const SwNodeIndex & );
 431
 432     const SwTable& GetTable() const { return *pTable; }
 433     SwTable& GetTable() { return *pTable; }
 434     SwTabFrm *MakeFrm();
 435
 436     //Legt die Frms fuer den TableNode (also die TabFrms) an.
 437     void MakeFrms( SwNodeIndex* pIdxBehind );
 438
 439     //Methode loescht fuer den Node alle Ansichten vom
 440     //Dokument. Die Contentframes werden aus dem entsprechenden
 441     //Layout ausgehaengt.
 442     void DelFrms();
 443
 444     SwTableNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const;
 445      void SetNewTable( SwTable* , BOOL bNewFrames=TRUE );
 446
 447 private:
 448     // privater Constructor, weil nie kopiert werden darf !!
 449     SwTableNode( const SwTableNode & rNode );
 450 };
 451
 452
 453 //---------
 454 // SwSectionNode
 455 //---------
 456 class SwSectionNode : public SwStartNode
 457 {
 458     friend class SwNodes;
 459     SwSection* pSection;
 460 protected:
 461     virtual ~SwSectionNode();
 462
 463 public:
 464     SwSectionNode( const SwNodeIndex&, SwSectionFmt& rFmt );
 465
 466     const SwSection& GetSection() const { return *pSection; }
 467     SwSection& GetSection() { return *pSection; }
 468
 469     // setze ein neues SectionObject. Erstmal nur gedacht fuer die
 470     // neuen VerzeichnisSections. Der geht ueber in den Besitz des Nodes!
 471     void SetNewSection( SwSection* pNewSection );
 472
 473     SwFrm *MakeFrm();
 474
 475     //Legt die Frms fuer den SectionNode (also die SectionFrms) an.
 476     //Im Defaultfall wird bis die Frames bis zum Ende des Bereichs angelegt,
 477     //uebergibt man einen weiteren NodeIndex pEnd, so wird bis zu diesem
 478     //ein MakeFrms gerufen, genutzt wird dies von TableToText
 479     void MakeFrms( SwNodeIndex* pIdxBehind, SwNodeIndex* pEnd = NULL );
 480
 481     //Methode loescht fuer den Node alle Ansichten vom
 482     //Dokument. Die Contentframes werden aus dem entsprechenden
 483     //Layout ausgehaengt.
 484     void DelFrms();
 485
 486 private:
 487     // privater Constructor, weil nie kopiert werden darf !!
 488     SwSectionNode( const SwSection& rNode );
 489 };
 490
 491
 492
 493 // ---------------------- einige Inline Methoden ----------------------
 494 inline       SwEndNode   *SwNode::GetEndNode()
 495 {
 496      return ND_ENDNODE == nNodeType ? (SwEndNode*)this : 0;
 497 }
 498 inline const SwEndNode   *SwNode::GetEndNode() const
 499 {
 500      return ND_ENDNODE == nNodeType ? (const SwEndNode*)this : 0;
 501 }
 502 inline       SwStartNode *SwNode::GetStartNode()
 503 {
 504      return ND_STARTNODE & nNodeType ? (SwStartNode*)this : 0;
 505 }
 506 inline const SwStartNode *SwNode::GetStartNode() const
 507 {
 508      return ND_STARTNODE & nNodeType ? (const SwStartNode*)this : 0;
 509 }
 510 inline       SwTableNode *SwNode::GetTableNode()
 511 {
 512      return ND_TABLENODE == nNodeType ? (SwTableNode*)this : 0;
 513 }
 514 inline const SwTableNode *SwNode::GetTableNode() const
 515 {
 516      return ND_TABLENODE == nNodeType ? (const SwTableNode*)this : 0;
 517 }
 518 inline       SwSectionNode *SwNode::GetSectionNode()
 519 {
 520      return ND_SECTIONNODE == nNodeType ? (SwSectionNode*)this : 0;
 521 }
 522 inline const SwSectionNode *SwNode::GetSectionNode() const
 523 {
 524      return ND_SECTIONNODE == nNodeType ? (const SwSectionNode*)this : 0;
 525 }
 526 inline       SwCntntNode *SwNode::GetCntntNode()
 527 {
 528      return ND_CONTENTNODE & nNodeType ? (SwCntntNode*)this : 0;
 529 }
 530 inline const SwCntntNode *SwNode::GetCntntNode() const
 531 {
 532      return ND_CONTENTNODE & nNodeType ? (const SwCntntNode*)this : 0;
 533 }
 534
 535
 536 inline BOOL SwNode::IsStartNode() const
 537 {
 538     return ND_STARTNODE & nNodeType  ? TRUE : FALSE;
 539 }
 540 inline BOOL SwNode::IsCntntNode() const
 541 {
 542     return ND_CONTENTNODE & nNodeType  ? TRUE : FALSE;
 543 }
 544 inline BOOL SwNode::IsEndNode() const
 545 {
 546     return ND_ENDNODE == nNodeType  ? TRUE : FALSE;
 547 }
 548 inline BOOL SwNode::IsTxtNode() const
 549 {
 550     return ND_TEXTNODE == nNodeType  ? TRUE : FALSE;
 551 }
 552 inline BOOL SwNode::IsTableNode() const
 553 {
 554     return ND_TABLENODE == nNodeType  ? TRUE : FALSE;
 555 }
 556 inline BOOL SwNode::IsSectionNode() const
 557 {
 558     return ND_SECTIONNODE == nNodeType  ? TRUE : FALSE;
 559 }
 560 #ifndef COMPACT
 561 inline BOOL SwNode::IsNoTxtNode() const
 562 {
 563     return ND_NOTXTNODE & nNodeType  ? TRUE : FALSE;
 564 }
 565 inline BOOL SwNode::IsOLENode() const
 566 {
 567     return ND_OLENODE == nNodeType  ? TRUE : FALSE;
 568 }
 569 inline BOOL SwNode::IsGrfNode() const
 570 {
 571     return ND_GRFNODE == nNodeType  ? TRUE : FALSE;
 572 }
 573 #endif
 574
 575 inline const SwStartNode* SwNode::FindSttNodeByType( SwStartNodeType eTyp ) const
 576 {
 577     return ((SwNode*)this)->FindSttNodeByType( eTyp );
 578 }
 579 inline const SwTableNode* SwNode::FindTableNode() const
 580 {
 581     return ((SwNode*)this)->FindTableNode();
 582 }
 583 inline const SwSectionNode* SwNode::FindSectionNode() const
 584 {
 585     return ((SwNode*)this)->FindSectionNode();
 586 }
 587 inline ULONG SwNode::StartOfSectionIndex() const
 588 {
 589     return pStartOfSection->GetIndex();
 590 }
 591 inline const SwStartNode* SwNode::StartOfSectionNode() const
 592 {
 593     return pStartOfSection;
 594 }
 595 inline SwStartNode* SwNode::StartOfSectionNode()
 596 {
 597     return pStartOfSection;
 598 }
 599 inline ULONG SwNode::EndOfSectionIndex() const
 600 {
 601     const SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 602     return pStNd->pEndOfSection->GetIndex();
 603 }
 604 inline const SwEndNode* SwNode::EndOfSectionNode() const
 605 {
 606     const SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 607     return pStNd->pEndOfSection;
 608 }
 609 inline SwEndNode* SwNode::EndOfSectionNode()
 610 {
 611     SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 612     return pStNd->pEndOfSection;
 613 }
 614
 615 inline SwNodes& SwNode::GetNodes()
 616 {
 617     return (SwNodes&)GetArray();
 618 }
 619 inline const SwNodes& SwNode::GetNodes() const
 620 {
 621     return (SwNodes&)GetArray();
 622 }
 623
 624 inline SwDoc* SwNode::GetDoc()
 625 {
 626     return GetNodes().GetDoc();
 627 }
 628 inline const SwDoc* SwNode::GetDoc() const
 629 {
 630     return GetNodes().GetDoc();
 631 }
 632
 633 inline SwFmtColl* SwCntntNode::GetCondFmtColl() const
 634 {
 635     return pCondColl ? (SwFmtColl*)pCondColl->GetRegisteredIn() : 0;
 636 }
 637
 638
 639 inline SwFmtColl& SwCntntNode::GetAnyFmtColl() const
 640 {
 641     return pCondColl && pCondColl->GetRegisteredIn()
 642                 ? *(SwFmtColl*)pCondColl->GetRegisteredIn()
 643                 : *(SwFmtColl*)GetRegisteredIn();
 644 }
 645
 646 inline SwAttrSet& SwCntntNode::GetSwAttrSet()
 647 {
 648     return pAttrSet ? ( (SwAttrSet &) ( *pAttrSet ) )
 649                     : ( (SwAttrSet &) ( GetAnyFmtColl().GetAttrSet() ) );
 650 }
 651 inline const SwAttrSet& SwCntntNode::GetSwAttrSet() const
 652 {
 653     return pAttrSet ? ( (SwAttrSet &) ( *pAttrSet ) )
 654                     : ( (SwAttrSet &) ( GetAnyFmtColl().GetAttrSet() ) );
 655 }
 656 //FEATURE::CONDCOLL
 657
 658 inline const SfxPoolItem& SwCntntNode::GetAttr( USHORT nWhich,
 659                                                 BOOL bInParents ) const
 660 {
 661     return GetSwAttrSet().Get( nWhich, bInParents );
 662 }
 663
 664
 665 #undef INLINE
 666
 667 } //namespace binfilter
 668 #endif