node.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_SW_INC_NODE_HXX
#define INCLUDED_SW_INC_NODE_HXX
 
#include <sal/types.h>
 
#include "swdllapi.h"
#include "BorderCacheOwner.hxx"
#include "ndarr.hxx"
#include "ndtyp.hxx"
#include "contentindex.hxx"
#include "fmtcol.hxx"
#include "nodeoffset.hxx"
 
#include <sfx2/AccessibilityIssue.hxx>
 
#include <memory>
#include <vector>
 
class SwContentFrame;
class SwContentNode;
class SwDoc;
class SwEndNode;
class SwFrame;
class SwFrameFormat;
class SwGrfNode;
class SwNoTextNode;
class SwNodeIndex;
class SwOLENode;
class SwRect;
class SwSection;
class SwSectionFormat;
class SwTOXBase;
class SwSectionNode;
class SwStartNode;
class SwTabFrame;
class SwRootFrame;
class SwTable;
class SwTableNode;
class SwTableBox;
class SwTextNode;
class SwPageDesc;
class SwViewShell;
struct SwPosition;
class IStyleAccess;
class IDocumentSettingAccess;
class IDocumentDeviceAccess;
class IDocumentMarkAccess;
class IDocumentRedlineAccess;
class IDocumentStylePoolAccess;
class IDocumentLinksAdministration;
class IDocumentFieldsAccess;
class IDocumentContentOperations;
class IDocumentListItems;
class Point;
enum class SvxFrameDirection;
typedef std::vector<SwOLENode*> SwOLENodes; // docary.hxx
enum class SwCursorSkipMode;
 
namespace drawinglayer::attribute {
    class SdrAllFillAttributesHelper;
    typedef std::shared_ptr< SdrAllFillAttributesHelper > SdrAllFillAttributesHelperPtr;
}
 
// Accessibility check
 
namespace sw
{
struct AccessibilityCheckStatus
{
    std::unique_ptr<sfx::AccessibilityIssueCollection> pCollection;
    void reset();
};
 
}
 
class SW_DLLPUBLIC SwNode
    : public sw::BorderCacheOwner, private BigPtrEntry
{
    friend class SwNodes;
 
    SwNodeType m_nNodeType;
 
    sal_uInt8 m_nAFormatNumLvl : 3;
    bool m_bIgnoreDontExpand : 1;     
 
    mutable sw::AccessibilityCheckStatus m_aAccessibilityCheckStatus;
 
public:
    enum class Merge { None, First, NonFirst, Hidden };
    bool IsCreateFrameWhenHidingRedlines() const {
        return m_eMerge == Merge::None || m_eMerge == Merge::First;
    }
    void SetRedlineMergeFlag(Merge const eMerge) { m_eMerge = eMerge; }
    Merge GetRedlineMergeFlag() const { return m_eMerge; }
private:
    Merge m_eMerge;
 
#ifdef DBG_UTIL
    static tools::Long s_nSerial;
    tools::Long m_nSerial;
#endif
 
    std::vector<SwFrameFormat*> m_aAnchoredFlys;
 
protected:
    SwStartNode* m_pStartOfSection;
 
    SwNode();
 
    SwNode( const SwNode& rWhere, const SwNodeType nNodeId );
 
    SwNode( SwNodes& rNodes, SwNodeOffset nPos, const SwNodeType nNodeId );
 
public:
    virtual ~SwNode() override = 0;
 
#ifdef DBG_UTIL
    tools::Long GetSerial() const { return m_nSerial; }
#endif
 
    sal_uInt16 GetSectionLevel() const;
 
    inline SwNodeOffset StartOfSectionIndex() const;
    const SwStartNode* StartOfSectionNode() const { return m_pStartOfSection; }
    SwStartNode* StartOfSectionNode() { return m_pStartOfSection; }
 
    inline SwNodeOffset EndOfSectionIndex() const;
    inline const SwEndNode* EndOfSectionNode() const;
    inline         SwEndNode* EndOfSectionNode();
 
    sal_uInt8 GetAutoFormatLvl() const     { return m_nAFormatNumLvl; }
    void SetAutoFormatLvl( sal_uInt8 nVal )      { m_nAFormatNumLvl = nVal; }
 
    bool IsIgnoreDontExpand() const  { return m_bIgnoreDontExpand; }
    void SetIgnoreDontExpand( bool bNew )  { m_bIgnoreDontExpand = bNew; }
 
    SwNodeType   GetNodeType() const { return m_nNodeType; }
 
    inline       SwStartNode *GetStartNode();
    inline const SwStartNode *GetStartNode() const;
    inline       SwContentNode *GetContentNode();
    inline const SwContentNode *GetContentNode() const;
    inline       SwEndNode   *GetEndNode();
    inline const SwEndNode   *GetEndNode() const;
    inline       SwTextNode   *GetTextNode();
    inline const SwTextNode   *GetTextNode() const;
    inline       SwOLENode   *GetOLENode();
    inline const SwOLENode   *GetOLENode() const;
    inline       SwNoTextNode *GetNoTextNode();
    inline const SwNoTextNode *GetNoTextNode() const;
    inline       SwGrfNode   *GetGrfNode();
    inline const SwGrfNode   *GetGrfNode() const;
    inline       SwTableNode *GetTableNode();
    inline const SwTableNode *GetTableNode() const;
    inline       SwSectionNode *GetSectionNode();
    inline const SwSectionNode *GetSectionNode() const;
 
    bool IsStartNode() const { return bool(SwNodeType::Start & m_nNodeType); }
    bool IsContentNode() const { return bool(SwNodeType::ContentMask & m_nNodeType); }
    bool IsEndNode() const { return SwNodeType::End == m_nNodeType; }
    bool IsTextNode() const { return SwNodeType::Text == m_nNodeType; }
    bool IsTableNode() const { return SwNodeType::Table == m_nNodeType; }
    bool IsSectionNode() const { return SwNodeType::Section == m_nNodeType; }
    bool IsOLENode() const { return SwNodeType::Ole == m_nNodeType; }
    bool IsNoTextNode() const { return bool(SwNodeType::NoTextMask & m_nNodeType); }
    bool IsGrfNode() const { return SwNodeType::Grf == m_nNodeType; }
 
    bool IsInRedlines() const;
 
                    SwTableNode *FindTableNode();
    inline const  SwTableNode *FindTableNode() const;
 
                    SwSectionNode *FindSectionNode();
    inline    const   SwSectionNode *FindSectionNode() const;
 
    SwStartNode* FindSttNodeByType( SwStartNodeType eTyp );
    inline const SwStartNode* FindSttNodeByType( SwStartNodeType eTyp ) const;
 
    const SwStartNode* FindTableBoxStartNode() const
                        { return FindSttNodeByType( SwTableBoxStartNode ); }
    const SwStartNode* FindFlyStartNode() const
                        { return FindSttNodeByType( SwFlyStartNode ); }
    const SwStartNode* FindFootnoteStartNode() const
                        { return FindSttNodeByType( SwFootnoteStartNode ); }
    const SwStartNode* FindHeaderStartNode() const
                        { return FindSttNodeByType( SwHeaderStartNode ); }
    const SwStartNode* FindFooterStartNode() const
                        { return FindSttNodeByType( SwFooterStartNode ); }
 
    inline          SwNodes& GetNodes();
    inline const  SwNodes& GetNodes() const;
 
    SwDoc& GetDoc()
    {
        return GetNodes().GetDoc();
    }
 
    const SwDoc& GetDoc() const
    {
        return GetNodes().GetDoc();
    }
 
    const IDocumentSettingAccess* getIDocumentSettingAccess() const;
 
    const IDocumentDeviceAccess& getIDocumentDeviceAccess() const;
 
    const IDocumentMarkAccess* getIDocumentMarkAccess() const;
 
    const IDocumentRedlineAccess& getIDocumentRedlineAccess() const;
 
    const IDocumentStylePoolAccess& getIDocumentStylePoolAccess() const;
 
    const IDocumentDrawModelAccess& getIDocumentDrawModelAccess() const;
 
    const IDocumentLayoutAccess& getIDocumentLayoutAccess() const;
          IDocumentLayoutAccess& getIDocumentLayoutAccess();
 
    const IDocumentLinksAdministration& getIDocumentLinksAdministration() const;
          IDocumentLinksAdministration& getIDocumentLinksAdministration();
 
    const IDocumentFieldsAccess& getIDocumentFieldsAccess() const;
          IDocumentFieldsAccess& getIDocumentFieldsAccess();
 
          IDocumentContentOperations& getIDocumentContentOperations();
 
          IStyleAccess& getIDocumentStyleAccess();
 
    IDocumentListItems& getIDocumentListItems();
 
    bool IsInVisibleArea( SwViewShell const * pSh ) const;
    bool IsInProtectSect() const;
    bool IsProtect() const;
 
    const SwPageDesc* FindPageDesc( SwNodeOffset* pPgDescNdIdx = nullptr ) const;
 
    SwFrameFormat* GetFlyFormat() const;
 
    SwTableBox* GetTableBox() const;
 
    SwNodeOffset GetIndex() const { return SwNodeOffset(GetPos()); }
 
    const SwTextNode* FindOutlineNodeOfLevel(sal_uInt8 nLvl, SwRootFrame const* pLayout = nullptr) const;
 
    sal_uInt8 HasPrevNextLayNode() const;
 
    std::vector<SwFrameFormat *> const & GetAnchoredFlys() const { return m_aAnchoredFlys; }
    void AddAnchoredFly(SwFrameFormat *);
    void RemoveAnchoredFly(SwFrameFormat *);
 
    virtual void dumpAsXml(xmlTextWriterPtr pWriter) const;
 
    bool operator==(const SwNode& rOther) const { return this == &rOther; }
    bool operator!=(const SwNode& rOther) const { return this != &rOther; }
    bool operator<(const SwNode& rOther) const { assert(&GetNodes() == &rOther.GetNodes()); return GetIndex() < rOther.GetIndex(); }
    bool operator<=(const SwNode& rOther) const { assert(&GetNodes() == &rOther.GetNodes()); return GetIndex() <= rOther.GetIndex(); }
    bool operator>(const SwNode& rOther) const { assert(&GetNodes() == &rOther.GetNodes()); return GetIndex() > rOther.GetIndex(); }
    bool operator>=(const SwNode& rOther) const { assert(&GetNodes() == &rOther.GetNodes()); return GetIndex() >= rOther.GetIndex(); }
 
    sw::AccessibilityCheckStatus& getAccessibilityCheckStatus()
    {
        return m_aAccessibilityCheckStatus;
    }
 
    void resetAndQueueAccessibilityCheck();
 
private:
    SwNode( const SwNode & rNodes ) = delete;
    SwNode & operator= ( const SwNode & rNodes ) = delete;
};
 
class SAL_DLLPUBLIC_RTTI SwStartNode: public SwNode
{
    friend class SwNode;
    friend class SwNodes;
    friend class SwEndNode;     
 
    SwEndNode* m_pEndOfSection;
    SwStartNodeType m_eStartNodeType;
 
    SwStartNode( SwNodes& rNodes, SwNodeOffset nPos );
 
protected:
    SwStartNode( const SwNode& rWhere,
                 const SwNodeType nNodeType = SwNodeType::Start,
                 SwStartNodeType = SwNormalStartNode );
public:
    SwStartNodeType GetStartNodeType() const        { return m_eStartNodeType; }
 
    void CheckSectionCondColl() const;
 
    virtual void dumpAsXml(xmlTextWriterPtr pWriter) const override;
 
private:
    SwStartNode( const SwStartNode & rNode ) = delete;
    SwStartNode & operator= ( const SwStartNode & rNode ) = delete;
};
 
class SwEndNode final : public SwNode
{
    friend class SwNodes;
    friend class SwTableNode;       
    friend class SwSectionNode;     
 
    SwEndNode( SwNodes& rNodes, SwNodeOffset nPos, SwStartNode& rSttNd );
 
    SwEndNode( const SwNode& rWhere, SwStartNode& rSttNd );
 
    SwEndNode( const SwEndNode & rNode ) = delete;
    SwEndNode & operator= ( const SwEndNode & rNode ) = delete;
};
 
// SwContentNode
 
class SW_DLLPUBLIC SwContentNode: public sw::BroadcastingModify, public SwNode, public SwContentIndexReg
{
 
    sw::WriterMultiListener m_aCondCollListener;
    SwFormatColl* m_pCondColl;
    mutable bool mbSetModifyAtAttr;
 
protected:
    SwContentNode();
 
    SwContentNode( const SwNode& rWhere, const SwNodeType nNodeType,
                SwFormatColl *pFormatColl );
    virtual ~SwContentNode() override = 0;
 
    std::shared_ptr<const SfxItemSet> mpAttrSet;
 
    virtual void NewAttrSet( SwAttrPool& ) = 0;
 
    sal_uInt16 ClearItemsFromAttrSet( const std::vector<sal_uInt16>& rWhichIds );
 
    virtual void SwClientNotify( const SwModify&, const SfxHint& rHint) override;
 
public:
 
    virtual SwContentFrame *MakeFrame( SwFrame* pSib ) = 0;
 
    virtual SwContentNode *JoinNext();
    bool CanJoinNext( SwNodeIndex* pIdx = nullptr ) const;
    bool CanJoinNext( SwPosition* pIdx ) const;
    bool CanJoinPrev( SwNodeIndex* pIdx =nullptr ) const;
 
    bool GoNext(SwContentIndex *, SwCursorSkipMode nMode ) const;
    bool GoNext(SwPosition*, SwCursorSkipMode nMode ) const;
    bool GoPrevious(SwContentIndex *, SwCursorSkipMode nMode ) const;
 
    SwContentFrame *getLayoutFrame( const SwRootFrame*,
            const SwPosition *pPos = nullptr,
            std::pair<Point, bool> const* pViewPosAndCalcFrame = nullptr) const;
    SwRect FindLayoutRect( const bool bPrtArea = false,
                            const Point* pPoint = nullptr  ) const;
    SwRect FindPageFrameRect() const;
 
    void MakeFramesForAdjacentContentNode(SwContentNode& rNode);
 
    void DelFrames(SwRootFrame const* pLayout);
 
    virtual sal_Int32 Len() const;
 
    virtual SwContentNode* MakeCopy(SwDoc&, SwNode& rWhere, bool bNewFrames) const = 0;
 
    virtual bool GetInfo( SfxPoolItem& ) const override;
 
 
    const SfxPoolItem& GetAttr( sal_uInt16 nWhich, bool bInParent=true ) const;
    template<class T>
    const T& GetAttr( TypedWhichId<T> nWhich, bool bInParent=true ) const
    { return static_cast<const T&>(GetAttr(sal_uInt16(nWhich), bInParent)); }
    bool GetAttr( SfxItemSet& rSet ) const;
    virtual bool SetAttr( const SfxPoolItem& );
    virtual bool SetAttr( const SfxItemSet& rSet );
    virtual bool ResetAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 = 0 );
    virtual bool ResetAttr( const std::vector<sal_uInt16>& rWhichArr );
    virtual sal_uInt16 ResetAllAttr();
 
    const SfxPoolItem* GetNoCondAttr( sal_uInt16 nWhich, bool bInParents ) const;
    template<class T>
    const T* GetNoCondAttr( TypedWhichId<T> nWhich, bool bInParents ) const
    { return static_cast<const T*>(GetNoCondAttr(sal_uInt16(nWhich), bInParents)); }
 
    inline const SwAttrSet &GetSwAttrSet() const;
    const SwAttrSet *GetpSwAttrSet() const { return static_cast<const SwAttrSet*>(mpAttrSet.get()); }
    bool  HasSwAttrSet() const { return mpAttrSet != nullptr; }
 
    virtual SwFormatColl* ChgFormatColl( SwFormatColl* );
    SwFormatColl* GetFormatColl() const { return const_cast<SwFormatColl*>(static_cast<const SwFormatColl*>(GetRegisteredIn())); }
 
    inline SwFormatColl& GetAnyFormatColl() const;
    void SetCondFormatColl( SwFormatColl* );
    inline SwFormatColl* GetCondFormatColl() const;
 
    bool IsAnyCondition( SwCollCondition& rTmp ) const;
    void ChkCondColl(const SwTextFormatColl* pColl = nullptr);
 
    bool InvalidateNumRule();
 
    SvxFrameDirection GetTextDirection( const SwPosition& rPos,
                            const Point* pPt ) const;
 
    void SetModifyAtAttr( bool bSetModifyAtAttr ) const { mbSetModifyAtAttr = bSetModifyAtAttr; }
    bool GetModifyAtAttr() const { return mbSetModifyAtAttr; }
 
    static std::unique_ptr<SwOLENodes> CreateOLENodesArray( const SwFormatColl& rColl, bool bOnlyWithInvalidSize );
 
    // Access to DrawingLayer FillAttributes in a preprocessed form for primitive usage
    virtual drawinglayer::attribute::SdrAllFillAttributesHelperPtr getSdrAllFillAttributesHelper() const;
 
    void UpdateAttr(const SwUpdateAttr&);
 
private:
    SwContentNode( const SwContentNode & rNode ) = delete;
    SwContentNode & operator= ( const SwContentNode & rNode ) = delete;
};
 
// SwTableNode
 
class SW_DLLPUBLIC SwTableNode final : public SwStartNode, public sw::BroadcastingModify
{
    friend class SwNodes;
    std::unique_ptr<SwTable> m_pTable;
 
    virtual ~SwTableNode() override;
 
public:
    SwTableNode( const SwNode& );
 
    const SwTable& GetTable() const { return *m_pTable; }
    SwTable& GetTable() { return *m_pTable; }
    SwTabFrame *MakeFrame( SwFrame* );
 
    void MakeOwnFrames(SwPosition* pIdxBehind = nullptr);
 
    void DelFrames(SwRootFrame const* pLayout = nullptr);
 
    void MakeFramesForAdjacentContentNode(const SwNodeIndex & rIdx);
 
    SwTableNode* MakeCopy( SwDoc&, const SwNodeIndex& ) const;
    void SetNewTable( std::unique_ptr<SwTable> , bool bNewFrames=true );
 
    // Removes redline objects that relate to this table from the 'Extra Redlines' table
    void RemoveRedlines();
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const override;
 
private:
    SwTableNode( const SwTableNode & rNode ) = delete;
    SwTableNode & operator= ( const SwTableNode & rNode ) = delete;
};
 
class SAL_DLLPUBLIC_RTTI SwSectionNode final
    : public SwStartNode
{
    friend class SwNodes;
 
private:
    SwSectionNode(const SwSectionNode&) = delete;
    SwSectionNode& operator=(const SwSectionNode&) = delete;
 
    std::unique_ptr<SwSection> const m_pSection;
 
    virtual ~SwSectionNode() override;
 
public:
    SwSectionNode(const SwNode& rWhere,
        SwSectionFormat & rFormat, SwTOXBase const*const pTOXBase);
 
    const SwSection& GetSection() const { return *m_pSection; }
          SwSection& GetSection()       { return *m_pSection; }
 
    SwFrame *MakeFrame( SwFrame* );
 
    void MakeOwnFrames(SwNodeIndex* pIdxBehind, SwNodeIndex* pEnd = nullptr);
 
    void DelFrames(SwRootFrame const* pLayout = nullptr, bool bForce = false);
 
    void MakeFramesForAdjacentContentNode(const SwNodeIndex & rIdx);
 
    SwSectionNode* MakeCopy( SwDoc&, const SwNodeIndex& ) const;
 
    void NodesArrChgd();
 
    bool IsContentHidden() const;
 
    void dumpAsXml(xmlTextWriterPtr pWriter) const override;
 
};
 
class SwPlaceholderNode final : private SwNode
{
private:
    friend class SwNodes;
    SwPlaceholderNode(const SwNode& rWhere);
};
 
inline       SwEndNode   *SwNode::GetEndNode()
{
     return IsEndNode() ? static_cast<SwEndNode*>(this) : nullptr;
}
inline const SwEndNode   *SwNode::GetEndNode() const
{
     return IsEndNode() ? static_cast<const SwEndNode*>(this) : nullptr;
}
inline       SwStartNode *SwNode::GetStartNode()
{
     return IsStartNode() ? static_cast<SwStartNode*>(this) : nullptr;
}
inline const SwStartNode *SwNode::GetStartNode() const
{
     return IsStartNode() ? static_cast<const SwStartNode*>(this) : nullptr;
}
inline       SwTableNode *SwNode::GetTableNode()
{
     return IsTableNode() ? static_cast<SwTableNode*>(this) : nullptr;
}
inline const SwTableNode *SwNode::GetTableNode() const
{
     return IsTableNode() ? static_cast<const SwTableNode*>(this) : nullptr;
}
inline       SwSectionNode *SwNode::GetSectionNode()
{
     return IsSectionNode() ? static_cast<SwSectionNode*>(this) : nullptr;
}
inline const SwSectionNode *SwNode::GetSectionNode() const
{
     return IsSectionNode() ? static_cast<const SwSectionNode*>(this) : nullptr;
}
inline       SwContentNode *SwNode::GetContentNode()
{
     return IsContentNode() ? static_cast<SwContentNode*>(this) : nullptr;
}
inline const SwContentNode *SwNode::GetContentNode() const
{
     return IsContentNode() ? static_cast<const SwContentNode*>(this) : nullptr;
}
 
inline const SwStartNode* SwNode::FindSttNodeByType( SwStartNodeType eTyp ) const
{
    return const_cast<SwNode*>(this)->FindSttNodeByType( eTyp );
}
inline const SwTableNode* SwNode::FindTableNode() const
{
    return const_cast<SwNode*>(this)->FindTableNode();
}
inline const SwSectionNode* SwNode::FindSectionNode() const
{
    return const_cast<SwNode*>(this)->FindSectionNode();
}
inline SwNodeOffset SwNode::StartOfSectionIndex() const
{
    return m_pStartOfSection->GetIndex();
}
inline SwNodeOffset SwNode::EndOfSectionIndex() const
{
    return EndOfSectionNode()->GetIndex();
}
inline const SwEndNode* SwNode::EndOfSectionNode() const
{
    const SwStartNode* pStNd = IsStartNode() ? static_cast<const SwStartNode*>(this) : m_pStartOfSection;
    return pStNd->m_pEndOfSection;
}
inline SwEndNode* SwNode::EndOfSectionNode()
{
    const SwStartNode* pStNd = IsStartNode() ? static_cast<const SwStartNode*>(this) : m_pStartOfSection;
    return pStNd->m_pEndOfSection;
}
 
inline SwNodes& SwNode::GetNodes()
{
    return static_cast<SwNodes&>(GetArray());
}
inline const SwNodes& SwNode::GetNodes() const
{
    return static_cast<SwNodes&>(GetArray());
}
 
inline SwFormatColl* SwContentNode::GetCondFormatColl() const
{
    return m_pCondColl;
}
 
inline SwFormatColl& SwContentNode::GetAnyFormatColl() const
{
    return m_pCondColl
            ? *m_pCondColl
            : *const_cast<SwFormatColl*>(static_cast<const SwFormatColl*>(GetRegisteredIn()));
}
 
inline const SwAttrSet& SwContentNode::GetSwAttrSet() const
{
    return mpAttrSet ? *GetpSwAttrSet() : GetAnyFormatColl().GetAttrSet();
}
 
inline const SfxPoolItem& SwContentNode::GetAttr( sal_uInt16 nWhich,
                                                bool bInParents ) const
{
    return GetSwAttrSet().Get( nWhich, bInParents );
}
 
inline SwPlaceholderNode::SwPlaceholderNode(const SwNode& rWhere)
    : SwNode(rWhere, SwNodeType::PlaceHolder)
{
}
 
inline SwNode* SwNodes::operator[]( SwNodeOffset n ) const
{
    return static_cast<SwNode*>(BigPtrArray::operator[] ( sal_Int32(n) ));
}
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */