sw/inc/node.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef SW_NODE_HXX
  21 #define SW_NODE_HXX
  22
  23 #include <vector>
  24
  25 #include <boost/utility.hpp>
  26 #include <boost/shared_ptr.hpp>
  27
  28 #include <sal/types.h>
  29 #include <tools/mempool.hxx>
  30
  31 #include "swdllapi.h"
  32 #include <ndarr.hxx>
  33 #include <ndtyp.hxx>
  34 #include <index.hxx>
  35 #include <fmtcol.hxx>
  36
  37 // ---------------------
  38 // forward declarations
  39 // ---------------------
  40
  41 class SwCntntFrm;
  42 class SwCntntNode;
  43 class SwDoc;
  44 class SwEndNode;
  45 class SwFrm;
  46 class SwFrmFmt;
  47 class SwGrfNode;
  48 class SwNoTxtNode;
  49 class SwNodeIndex;
  50 class SwOLENode;
  51 class SwRect;
  52 class SwSection;
  53 class SwSectionFmt;
  54 class SwTOXBase;
  55 class SwSectionNode;
  56 class SwStartNode;
  57 class SwTabFrm;
  58 class SwRootFrm;
  59 class SwTable;
  60 class SwTableNode;
  61 class SwTableBox;
  62 class SwTxtNode;
  63 class SwPageDesc;
  64 class ViewShell;
  65 struct SwPosition;
  66 class IStyleAccess;
  67 class IDocumentSettingAccess;
  68 class IDocumentDeviceAccess;
  69 class IDocumentMarkAccess;
  70 class IDocumentRedlineAccess;
  71 class IDocumentStylePoolAccess;
  72 class IDocumentLineNumberAccess;
  73 class IDocumentLinksAdministration;
  74 class IDocumentFieldsAccess;
  75 class IDocumentContentOperations;
  76 class IDocumentListItems;
  77 class SwOLENodes;
  78 class Point;
  79
  80 /// Base class of the Writer document model elements.
  81 class SW_DLLPUBLIC SwNode
  82     : private BigPtrEntry
  83 {
  84     friend class SwNodes;
  85
  86     sal_uInt8 nNodeType;
  87
  88     /// For text nodes: level of auto format. Was put here because we had still free bits.
  89     sal_uInt8 nAFmtNumLvl : 3;
  90     bool bSetNumLSpace : 1;         ///< For numbering: TRUE: set indent.
  91     bool bIgnoreDontExpand : 1;     ///< for Text Attributes - ignore the flag
  92
  93 #ifdef DBG_UTIL
  94     static long s_nSerial;
  95     long m_nSerial;
  96 #endif
  97
  98 protected:
  99     SwStartNode* pStartOfSection;
 100
 101     SwNode( const SwNodeIndex &rWhere, const sal_uInt8 nNodeId );
 102
 103     /// for the initial StartNode
 104     SwNode( SwNodes& rNodes, sal_uLong nPos, const sal_uInt8 nNodeId );
 105
 106 public:
 107     /** the = 0 forces the class to be an abstract base class, but the dtor can be still called
 108        from subclasses */
 109     virtual ~SwNode() = 0;
 110
 111 #ifdef DBG_UTIL
 112     long GetSerial() const { return m_nSerial; }
 113 #endif
 114
 115     sal_uInt16 GetSectionLevel() const;
 116
 117     inline sal_uLong StartOfSectionIndex() const;
 118     inline const SwStartNode* StartOfSectionNode() const { return pStartOfSection; }
 119     inline       SwStartNode* StartOfSectionNode() { return pStartOfSection; }
 120
 121     inline sal_uLong EndOfSectionIndex() const;
 122     inline const SwEndNode* EndOfSectionNode() const;
 123     inline         SwEndNode* EndOfSectionNode();
 124
 125     inline sal_uInt8 GetAutoFmtLvl() const     { return nAFmtNumLvl; }
 126     inline void SetAutoFmtLvl( sal_uInt8 nVal )      { nAFmtNumLvl = nVal; }
 127
 128     inline bool IsSetNumLSpace() const  { return bSetNumLSpace; }
 129     inline void SetNumLSpace( bool bFlag )        { bSetNumLSpace = bFlag; }
 130
 131     inline bool IsIgnoreDontExpand() const  { return bIgnoreDontExpand; }
 132     inline void SetIgnoreDontExpand( bool bNew )  { bIgnoreDontExpand = bNew; }
 133
 134     sal_uInt8   GetNodeType() const { return nNodeType; }
 135
 136     inline       SwStartNode *GetStartNode();
 137     inline const SwStartNode *GetStartNode() const;
 138     inline       SwCntntNode *GetCntntNode();
 139     inline const SwCntntNode *GetCntntNode() const;
 140     inline       SwEndNode   *GetEndNode();
 141     inline const SwEndNode   *GetEndNode() const;
 142     inline       SwTxtNode   *GetTxtNode();
 143     inline const SwTxtNode   *GetTxtNode() const;
 144     inline       SwOLENode   *GetOLENode();
 145     inline const SwOLENode   *GetOLENode() const;
 146     inline       SwNoTxtNode *GetNoTxtNode();
 147     inline const SwNoTxtNode *GetNoTxtNode() const;
 148     inline       SwGrfNode   *GetGrfNode();
 149     inline const SwGrfNode   *GetGrfNode() const;
 150     inline       SwTableNode *GetTableNode();
 151     inline const SwTableNode *GetTableNode() const;
 152     inline       SwSectionNode *GetSectionNode();
 153     inline const SwSectionNode *GetSectionNode() const;
 154
 155     inline sal_Bool IsStartNode() const;
 156     inline sal_Bool IsCntntNode() const;
 157     inline sal_Bool IsEndNode() const;
 158     inline sal_Bool IsTxtNode() const;
 159     inline sal_Bool IsTableNode() const;
 160     inline sal_Bool IsSectionNode() const;
 161     inline sal_Bool IsOLENode() const;
 162     inline sal_Bool IsNoTxtNode() const;
 163     inline sal_Bool IsGrfNode() const;
 164
 165     /**
 166        Checks if this node is in redlines.
 167
 168        @retval sal_True       this node is in redlines
 169        @retval sal_False      else
 170      */
 171     sal_Bool IsInRedlines() const;
 172
 173     /** Search table node, in which it is. If it is in no table
 174        @return 0. */
 175                     SwTableNode *FindTableNode();
 176     inline const  SwTableNode *FindTableNode() const;
 177
 178     /** Search section node, in which it is. If it is in no section
 179        @return 0. */
 180                     SwSectionNode *FindSectionNode();
 181     inline    const   SwSectionNode *FindSectionNode() const;
 182
 183     SwStartNode* FindSttNodeByType( SwStartNodeType eTyp );
 184     inline const SwStartNode* FindSttNodeByType( SwStartNodeType eTyp ) const;
 185
 186     const SwStartNode* FindTableBoxStartNode() const
 187                         { return FindSttNodeByType( SwTableBoxStartNode ); }
 188     const SwStartNode* FindFlyStartNode() const
 189                         { return FindSttNodeByType( SwFlyStartNode ); }
 190     const SwStartNode* FindFootnoteStartNode() const
 191                         { return FindSttNodeByType( SwFootnoteStartNode ); }
 192     const SwStartNode* FindHeaderStartNode() const
 193                         { return FindSttNodeByType( SwHeaderStartNode ); }
 194     const SwStartNode* FindFooterStartNode() const
 195                         { return FindSttNodeByType( SwFooterStartNode ); }
 196
 197     /// Node is in which nodes-array/doc?
 198     inline          SwNodes& GetNodes();
 199     inline const  SwNodes& GetNodes() const;
 200     inline            SwDoc* GetDoc();
 201     inline const  SwDoc* GetDoc() const;
 202
 203     /** Provides access to the document setting interface
 204      */
 205     const IDocumentSettingAccess* getIDocumentSettingAccess() const;
 206
 207     /** Provides access to the document device interface
 208      */
 209     const IDocumentDeviceAccess* getIDocumentDeviceAccess() const;
 210
 211     /** Provides access to the document bookmark interface
 212      */
 213     const IDocumentMarkAccess* getIDocumentMarkAccess() const;
 214
 215     /** Provides access to the document redline interface
 216      */
 217     const IDocumentRedlineAccess* getIDocumentRedlineAccess() const;
 218
 219     /** Provides access to the document style pool interface
 220      */
 221     const IDocumentStylePoolAccess* getIDocumentStylePoolAccess() const;
 222
 223     /** Provides access to the document line number information interface
 224      */
 225     const IDocumentLineNumberAccess* getIDocumentLineNumberAccess() const;
 226
 227     /** Provides access to the document draw model interface
 228      */
 229     const IDocumentDrawModelAccess* getIDocumentDrawModelAccess() const;
 230
 231     /** Provides access to the document layout interface
 232      */
 233     const IDocumentLayoutAccess* getIDocumentLayoutAccess() const;
 234           IDocumentLayoutAccess* getIDocumentLayoutAccess();
 235
 236     /** Provides access to the document links administration interface
 237      */
 238     const IDocumentLinksAdministration* getIDocumentLinksAdministration() const;
 239           IDocumentLinksAdministration* getIDocumentLinksAdministration();
 240
 241     /** Provides access to the document fields administration interface
 242      */
 243     const IDocumentFieldsAccess* getIDocumentFieldsAccess() const;
 244           IDocumentFieldsAccess* getIDocumentFieldsAccess();
 245
 246     /** Provides access to the document content operations interface
 247      */
 248           IDocumentContentOperations* getIDocumentContentOperations();
 249
 250     /** Provides access to the document automatic styles interface
 251      */
 252           IStyleAccess& getIDocumentStyleAccess();
 253
 254     /** Provides access to the document's numbered items interface
 255
 256         @author OD
 257     */
 258     IDocumentListItems& getIDocumentListItems();
 259
 260     /// Is node in the visible area of the Shell?
 261     sal_Bool IsInVisibleArea( ViewShell* pSh = 0 ) const;
 262     /// Is node in an protected area?
 263     bool IsInProtectSect() const;
 264     /**  Is node in something that is protected (range, frame,
 265         table cells ... including anchor in case of frames or footnotes)? */
 266     sal_Bool IsProtect() const;
 267
 268     /** Search PageDesc with which this node is formated. If layout is existent
 269        search over layout, else only the hard way is left: search over the nodes
 270        to the front!! */
 271     const SwPageDesc* FindPageDesc( sal_Bool bCalcLay, sal_uInt32* pPgDescNdIdx = 0 ) const;
 272
 273     /// If node is in a fly return the respective format.
 274     SwFrmFmt* GetFlyFmt() const;
 275
 276     /// If node is in a table return the respective table box.
 277     SwTableBox* GetTblBox() const;
 278
 279     inline sal_uLong GetIndex() const { return GetPos(); }
 280
 281     const SwTxtNode* FindOutlineNodeOfLevel( sal_uInt8 nLvl ) const;
 282
 283     sal_uInt8 HasPrevNextLayNode() const;
 284
 285     /**
 286      * Dumps the node structure to the given destination (file nodes.xml in the current directory by default)
 287      * @since 3.5
 288      */
 289     virtual void dumpAsXml( xmlTextWriterPtr writer = NULL );
 290
 291 private:
 292     /// Private constructor because copying is never allowed!!
 293     SwNode( const SwNode & rNodes );
 294     SwNode & operator= ( const SwNode & rNodes );
 295 };
 296
 297 /// Starts a section of nodes in the document model.
 298 class SwStartNode: public SwNode
 299 {
 300     friend class SwNode;
 301     friend class SwNodes;
 302     friend class SwEndNode;     ///< to set the theEndOfSection !!
 303
 304     SwEndNode* pEndOfSection;
 305     SwStartNodeType eSttNdTyp;
 306
 307     /// for the initial StartNode
 308     SwStartNode( SwNodes& rNodes, sal_uLong nPos );
 309
 310 protected:
 311     SwStartNode( const SwNodeIndex &rWhere,
 312                  const sal_uInt8 nNodeType = ND_STARTNODE,
 313                  SwStartNodeType = SwNormalStartNode );
 314 public:
 315     DECL_FIXEDMEMPOOL_NEWDEL(SwStartNode)
 316
 317     SwStartNodeType GetStartNodeType() const        { return eSttNdTyp; }
 318
 319     /// Call ChkCondcoll to all ContentNodes of section.
 320     void CheckSectionCondColl() const;
 321
 322     virtual void dumpAsXml( xmlTextWriterPtr writer = NULL );
 323
 324 private:
 325     /// Private constructor because copying is never allowed!!
 326     SwStartNode( const SwStartNode & rNode );
 327     SwStartNode & operator= ( const SwStartNode & rNode );
 328 };
 329
 330
 331 /// Ends a section of nodes in the document model.
 332 class SwEndNode : public SwNode
 333 {
 334     friend class SwNodes;
 335     friend class SwTableNode;       ///< To enable creation of its EndNote.
 336     friend class SwSectionNode;     ///< To enable creation of its EndNote.
 337
 338     /// for the initial StartNode
 339     SwEndNode( SwNodes& rNodes, sal_uLong nPos, SwStartNode& rSttNd );
 340
 341 protected:
 342     SwEndNode( const SwNodeIndex &rWhere, SwStartNode& rSttNd );
 343
 344     DECL_FIXEDMEMPOOL_NEWDEL(SwEndNode)
 345
 346 private:
 347     /// Private constructor because copying is never allowed!!
 348     SwEndNode( const SwEndNode & rNode );
 349     SwEndNode & operator= ( const SwEndNode & rNode );
 350 };
 351
 352
 353 // --------------------
 354 // SwCntntNode
 355 // --------------------
 356 class SW_DLLPUBLIC SwCntntNode: public SwModify, public SwNode, public SwIndexReg
 357 {
 358
 359 //FEATURE::CONDCOLL
 360     SwDepend* pCondColl;
 361 //FEATURE::CONDCOLL
 362     mutable bool mbSetModifyAtAttr;
 363
 364 protected:
 365     SwCntntNode( const SwNodeIndex &rWhere, const sal_uInt8 nNodeType,
 366                 SwFmtColl *pFmtColl );
 367     /** the = 0 forces the class to be an abstract base class, but the dtor can be still called
 368        from subclasses */
 369     virtual ~SwCntntNode() = 0;
 370
 371     /**  Attribute-set for all auto attributes of a CntntNode.
 372       (e.g. TxtNode or NoTxtNode). */
 373     boost::shared_ptr<const SfxItemSet> mpAttrSet;
 374
 375     /// Make respective nodes create the specific AttrSets.
 376     virtual void NewAttrSet( SwAttrPool& ) = 0;
 377
 378     /** There some functions that like to remove items from the internal
 379        SwAttrSet (handle): */
 380     sal_uInt16 ClearItemsFromAttrSet( const std::vector<sal_uInt16>& rWhichIds );
 381
 382    virtual void Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew);
 383
 384 public:
 385     TYPEINFO();     /// Already contained in base class Client.
 386
 387     /** MakeFrm will be called for a certain layout
 388        pSib is another SwFrm of the same layout (e.g. the SwRootFrm itself, a sibling, the parent) */
 389     virtual SwCntntFrm *MakeFrm( SwFrm* pSib ) = 0;
 390
 391     virtual SwCntntNode *SplitCntntNode(const SwPosition & ) = 0;
 392
 393     virtual SwCntntNode *JoinNext();
 394     virtual SwCntntNode *JoinPrev();
 395     /** Is it possible to join two nodes?
 396        In pIdx the second position can be returned. */
 397     int CanJoinNext( SwNodeIndex* pIdx =0 ) const;
 398     int CanJoinPrev( SwNodeIndex* pIdx =0 ) const;
 399
 400     void MakeStartIndex( SwIndex * pIdx )   { pIdx->Assign( this, 0 ); }
 401     void MakeEndIndex( SwIndex * pIdx )     { pIdx->Assign( this, Len() ); }
 402
 403     sal_Bool GoNext(SwIndex *, sal_uInt16 nMode ) const;
 404     sal_Bool GoPrevious(SwIndex *, sal_uInt16 nMode ) const;
 405
 406     /// Replacement for good old GetFrm(..):
 407     SwCntntFrm *getLayoutFrm( const SwRootFrm*,
 408                         const Point* pDocPos = 0,
 409                         const SwPosition *pPos = 0,
 410                         const sal_Bool bCalcFrm = sal_True ) const;
 411     /** @return the real size of the frame or an empty rectangle if
 412        no layout exists. Needed for export filters. */
 413     SwRect FindLayoutRect( const sal_Bool bPrtArea = sal_False,
 414                             const Point* pPoint = 0,
 415                             const sal_Bool bCalcFrm = sal_False  ) const;
 416     SwRect FindPageFrmRect( const sal_Bool bPrtArea = sal_False,
 417                             const Point* pPoint = 0,
 418                             const sal_Bool bCalcFrm = sal_False  ) const;
 419
 420     /** Method creates all views of document for given node. The content
 421        frames that are created are put in the respective layout. */
 422     void MakeFrms( SwCntntNode& rNode );
 423
 424     /** Method deletes all views of document for the node. The content-
 425        frames are removed from the respective layout. */
 426     void DelFrms();
 427
 428     /** @return count of elements of node content. Default is 1.
 429        There are differences between text node and formula node. */
 430     virtual xub_StrLen Len() const;
 431
 432     virtual SwCntntNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const = 0;
 433
 434     /// Get information from Client.
 435     virtual bool GetInfo( SfxPoolItem& ) const;
 436
 437     /// SS for PoolItems: hard attributation.
 438
 439     /// If bInParent is FALSE search for attribute only in this node.
 440     const SfxPoolItem& GetAttr( sal_uInt16 nWhich, sal_Bool bInParent=sal_True ) const;
 441     sal_Bool GetAttr( SfxItemSet& rSet, sal_Bool bInParent=sal_True ) const;
 442     /// made virtual
 443     virtual sal_Bool SetAttr( const SfxPoolItem& );
 444     virtual sal_Bool SetAttr( const SfxItemSet& rSet );
 445     virtual sal_Bool ResetAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 = 0 );
 446     virtual sal_Bool ResetAttr( const std::vector<sal_uInt16>& rWhichArr );
 447     virtual sal_uInt16 ResetAllAttr();
 448
 449     /// Obtains attribute that is not delivered via conditional style!
 450     const SfxPoolItem* GetNoCondAttr( sal_uInt16 nWhich, sal_Bool bInParents ) const;
 451
 452     /** Does node has already its own auto-attributes?
 453      Access to SwAttrSet. */
 454     inline const SwAttrSet &GetSwAttrSet() const;
 455     inline const SwAttrSet *GetpSwAttrSet() const { return static_cast<const SwAttrSet*>(mpAttrSet.get()); }
 456     inline sal_Bool  HasSwAttrSet() const { return mpAttrSet ? sal_True : sal_False; }
 457
 458     virtual SwFmtColl* ChgFmtColl( SwFmtColl* );
 459     SwFmtColl* GetFmtColl() const { return (SwFmtColl*)GetRegisteredIn(); }
 460
 461 //FEATURE::CONDCOLL
 462     inline SwFmtColl& GetAnyFmtColl() const;
 463     void SetCondFmtColl( SwFmtColl* );
 464     inline SwFmtColl* GetCondFmtColl() const;
 465
 466     sal_Bool IsAnyCondition( SwCollCondition& rTmp ) const;
 467     void ChkCondColl();
 468 //FEATURE::CONDCOLL
 469
 470     /** Invalidates NumRule at the node. NumRule is updated
 471        on EndAction of a Shell at the latest. */
 472     sal_Bool InvalidateNumRule();
 473
 474     /** determines the text direction for a certain
 475        position. @return -1, if text direction could *not* be determined. */
 476     short GetTextDirection( const SwPosition& rPos,
 477                             const Point* pPt ) const;
 478
 479     inline void SetModifyAtAttr( bool bSetModifyAtAttr ) const { mbSetModifyAtAttr = bSetModifyAtAttr; }
 480     inline bool GetModifyAtAttr() const { return mbSetModifyAtAttr; }
 481
 482     static SwOLENodes* CreateOLENodesArray( const SwFmtColl& rColl, bool bOnlyWithInvalidSize );
 483
 484 private:
 485     /// Private constructor because copying is never allowed!!
 486     SwCntntNode( const SwCntntNode & rNode );
 487     SwCntntNode & operator= ( const SwCntntNode & rNode );
 488 };
 489
 490
 491
 492 //---------
 493 // SwTableNode
 494 //---------
 495 class SW_DLLPUBLIC SwTableNode : public SwStartNode, public SwModify
 496 {
 497     friend class SwNodes;
 498     SwTable* pTable;
 499 protected:
 500     virtual ~SwTableNode();
 501
 502 public:
 503     SwTableNode( const SwNodeIndex & );
 504
 505     const SwTable& GetTable() const { return *pTable; }
 506     SwTable& GetTable() { return *pTable; }
 507     SwTabFrm *MakeFrm( SwFrm* );
 508
 509     /// Creates the frms for the table node (i.e. the TabFrms).
 510     void MakeFrms( SwNodeIndex* pIdxBehind );
 511
 512     /** Method deletes all views of document for the node.
 513        The content frames are removed from the respective layout. */
 514     void DelFrms();
 515
 516     /** Method creates all views of the document for the previous node.
 517        The content frames that are created are put into the respective layout. */
 518     void MakeFrms( const SwNodeIndex & rIdx );
 519
 520     SwTableNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const;
 521     void SetNewTable( SwTable* , sal_Bool bNewFrames=sal_True );
 522
 523 private:
 524     /// Private constructor because copying is never allowed!!
 525     SwTableNode( const SwTableNode & rNode );
 526     SwTableNode & operator= ( const SwTableNode & rNode );
 527 };
 528
 529
 530 //---------
 531 // SwSectionNode
 532 //---------
 533 class SwSectionNode
 534     : public SwStartNode
 535     , private ::boost::noncopyable
 536 {
 537     friend class SwNodes;
 538
 539 private:
 540     ::std::auto_ptr<SwSection> const m_pSection;
 541
 542 protected:
 543     virtual ~SwSectionNode();
 544
 545 public:
 546     SwSectionNode(SwNodeIndex const&,
 547         SwSectionFmt & rFmt, SwTOXBase const*const pTOXBase);
 548
 549     const SwSection& GetSection() const { return *m_pSection; }
 550           SwSection& GetSection()       { return *m_pSection; }
 551
 552     SwFrm *MakeFrm( SwFrm* );
 553
 554     /** Creates the frms for the SectionNode (i.e. the SectionFrms).
 555        On default the frames are created until the end of the range.
 556        When another NodeIndex pEnd is passed a MakeFrms is called up to it.
 557        Used by TableToText. */
 558     void MakeFrms( SwNodeIndex* pIdxBehind, SwNodeIndex* pEnd = NULL );
 559
 560     /** Method deletes all views of document for the node. The
 561      content frames are removed from the respective layout. */
 562     void DelFrms();
 563
 564     /** Method creates all views of document for the previous node.
 565        The content frames created are put into the respective layout. */
 566     void MakeFrms( const SwNodeIndex & rIdx );
 567
 568     SwSectionNode* MakeCopy( SwDoc*, const SwNodeIndex& ) const;
 569
 570     /// Set pointer in format of section on itself.
 571     void NodesArrChgd();
 572
 573     /** Check for not hidden areas whether there is content that is not in
 574        a hidden sub-area. */
 575     sal_Bool IsCntntHidden() const;
 576
 577
 578 };
 579
 580
 581 //----------------
 582 // SwDummySectionNode
 583 //----------------
 584
 585 /** This class is internal. And quite frankly I don't know what ND_SECTIONDUMMY is for,
 586    the class has been merely created to replace "SwNode( ND_SECTIONDUMMY )", the only case
 587    of instantiating SwNode directly. Now SwNode can be an abstract base class. */
 588 class SwDummySectionNode
 589     : private SwNode
 590 {
 591 private:
 592     friend class SwNodes;
 593     SwDummySectionNode( const SwNodeIndex &rWhere );
 594 };
 595
 596
 597 inline       SwEndNode   *SwNode::GetEndNode()
 598 {
 599      return ND_ENDNODE == nNodeType ? (SwEndNode*)this : 0;
 600 }
 601 inline const SwEndNode   *SwNode::GetEndNode() const
 602 {
 603      return ND_ENDNODE == nNodeType ? (const SwEndNode*)this : 0;
 604 }
 605 inline       SwStartNode *SwNode::GetStartNode()
 606 {
 607      return ND_STARTNODE & nNodeType ? (SwStartNode*)this : 0;
 608 }
 609 inline const SwStartNode *SwNode::GetStartNode() const
 610 {
 611      return ND_STARTNODE & nNodeType ? (const SwStartNode*)this : 0;
 612 }
 613 inline       SwTableNode *SwNode::GetTableNode()
 614 {
 615      return ND_TABLENODE == nNodeType ? (SwTableNode*)this : 0;
 616 }
 617 inline const SwTableNode *SwNode::GetTableNode() const
 618 {
 619      return ND_TABLENODE == nNodeType ? (const SwTableNode*)this : 0;
 620 }
 621 inline       SwSectionNode *SwNode::GetSectionNode()
 622 {
 623      return ND_SECTIONNODE == nNodeType ? (SwSectionNode*)this : 0;
 624 }
 625 inline const SwSectionNode *SwNode::GetSectionNode() const
 626 {
 627      return ND_SECTIONNODE == nNodeType ? (const SwSectionNode*)this : 0;
 628 }
 629 inline       SwCntntNode *SwNode::GetCntntNode()
 630 {
 631      return ND_CONTENTNODE & nNodeType ? (SwCntntNode*)this : 0;
 632 }
 633 inline const SwCntntNode *SwNode::GetCntntNode() const
 634 {
 635      return ND_CONTENTNODE & nNodeType ? (const SwCntntNode*)this : 0;
 636 }
 637
 638
 639 inline sal_Bool SwNode::IsStartNode() const
 640 {
 641     return ND_STARTNODE & nNodeType  ? sal_True : sal_False;
 642 }
 643 inline sal_Bool SwNode::IsCntntNode() const
 644 {
 645     return ND_CONTENTNODE & nNodeType  ? sal_True : sal_False;
 646 }
 647 inline sal_Bool SwNode::IsEndNode() const
 648 {
 649     return ND_ENDNODE == nNodeType  ? sal_True : sal_False;
 650 }
 651 inline sal_Bool SwNode::IsTxtNode() const
 652 {
 653     return ND_TEXTNODE == nNodeType  ? sal_True : sal_False;
 654 }
 655 inline sal_Bool SwNode::IsTableNode() const
 656 {
 657     return ND_TABLENODE == nNodeType  ? sal_True : sal_False;
 658 }
 659 inline sal_Bool SwNode::IsSectionNode() const
 660 {
 661     return ND_SECTIONNODE == nNodeType  ? sal_True : sal_False;
 662 }
 663 inline sal_Bool SwNode::IsNoTxtNode() const
 664 {
 665     return ND_NOTXTNODE & nNodeType  ? sal_True : sal_False;
 666 }
 667 inline sal_Bool SwNode::IsOLENode() const
 668 {
 669     return ND_OLENODE == nNodeType  ? sal_True : sal_False;
 670 }
 671 inline sal_Bool SwNode::IsGrfNode() const
 672 {
 673     return ND_GRFNODE == nNodeType  ? sal_True : sal_False;
 674 }
 675
 676 inline const SwStartNode* SwNode::FindSttNodeByType( SwStartNodeType eTyp ) const
 677 {
 678     return ((SwNode*)this)->FindSttNodeByType( eTyp );
 679 }
 680 inline const SwTableNode* SwNode::FindTableNode() const
 681 {
 682     return ((SwNode*)this)->FindTableNode();
 683 }
 684 inline const SwSectionNode* SwNode::FindSectionNode() const
 685 {
 686     return ((SwNode*)this)->FindSectionNode();
 687 }
 688 inline sal_uLong SwNode::StartOfSectionIndex() const
 689 {
 690     return pStartOfSection->GetIndex();
 691 }
 692 inline sal_uLong SwNode::EndOfSectionIndex() const
 693 {
 694     const SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 695     return pStNd->pEndOfSection->GetIndex();
 696 }
 697 inline const SwEndNode* SwNode::EndOfSectionNode() const
 698 {
 699     const SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 700     return pStNd->pEndOfSection;
 701 }
 702 inline SwEndNode* SwNode::EndOfSectionNode()
 703 {
 704     SwStartNode* pStNd = IsStartNode() ? (SwStartNode*)this : pStartOfSection;
 705     return pStNd->pEndOfSection;
 706 }
 707
 708 inline SwNodes& SwNode::GetNodes()
 709 {
 710     return (SwNodes&)GetArray();
 711 }
 712 inline const SwNodes& SwNode::GetNodes() const
 713 {
 714     return (SwNodes&)GetArray();
 715 }
 716
 717 inline SwDoc* SwNode::GetDoc()
 718 {
 719     return GetNodes().GetDoc();
 720 }
 721 inline const SwDoc* SwNode::GetDoc() const
 722 {
 723     return GetNodes().GetDoc();
 724 }
 725
 726 inline SwFmtColl* SwCntntNode::GetCondFmtColl() const
 727 {
 728     return pCondColl ? (SwFmtColl*)pCondColl->GetRegisteredIn() : 0;
 729 }
 730
 731
 732 inline SwFmtColl& SwCntntNode::GetAnyFmtColl() const
 733 {
 734     return pCondColl && pCondColl->GetRegisteredIn()
 735                 ? *(SwFmtColl*)pCondColl->GetRegisteredIn()
 736                 : *(SwFmtColl*)GetRegisteredIn();
 737 }
 738
 739 inline const SwAttrSet& SwCntntNode::GetSwAttrSet() const
 740 {
 741     return mpAttrSet ? *GetpSwAttrSet() : GetAnyFmtColl().GetAttrSet();
 742 }
 743
 744 //FEATURE::CONDCOLL
 745
 746 inline const SfxPoolItem& SwCntntNode::GetAttr( sal_uInt16 nWhich,
 747                                                 sal_Bool bInParents ) const
 748 {
 749     return GetSwAttrSet().Get( nWhich, bInParents );
 750 }
 751
 752 inline SwDummySectionNode::SwDummySectionNode( const SwNodeIndex &rWhere )
 753     : SwNode( rWhere, ND_SECTIONDUMMY )
 754 {
 755 }
 756
 757 #endif
 758
 759 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */