ndarr.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_NDARR_HXX
#define INCLUDED_SW_INC_NDARR_HXX
 
#include <sal/config.h>
 
#include <limits>
#include <vector>
#include <memory>
#include <optional>
 
#include "bparr.hxx"
#include "ndtyp.hxx"
#include <rtl/ustring.hxx>
#include <o3tl/sorted_vector.hxx>
#include "nodeoffset.hxx"
 
class Graphic;
class GraphicObject;
class SwAttrSet;
class SfxItemSet;
class SwContentNode;
class SwDoc;
class SwGrfFormatColl;
class SwGrfNode;
class SwNode;
class SwNodeIndex;
class SwNodeRange;
class SwOLENode;
class SwPaM;
class SwRootFrame;
class SwSectionData;
class SwSectionFormat;
class SwTOXBase;
class SwSectionNode;
class SwStartNode;
class SwTableBoxFormat;
class SwTableFormat;
class SwTableLine;
class SwTableLineFormat;
class SwTableNode;
class SwTextFormatColl;
class SwTextNode;
class SwUndoTableToText;
class SwUndoTextToTable;
struct SwPosition;
 
namespace sw { class DocumentContentOperationsManager; }
namespace svt { class EmbeddedObjectRef; }
 
 
typedef bool (*FnForEach_SwNodes)( SwNode*, void* pArgs );
typedef struct _xmlTextWriter *xmlTextWriterPtr;
 
struct CompareSwOutlineNodes
{
    bool operator()( SwNode* const& lhs, SwNode* const& rhs) const;
};
 
class SwOutlineNodes : public o3tl::sorted_vector<SwNode*, CompareSwOutlineNodes>
{
public:
    static constexpr auto npos = std::numeric_limits<size_type>::max();
 
    bool Seek_Entry(SwNode* rP, size_type* pnPos) const;
};
 
struct SwTableToTextSave;
using SwTableToTextSaves = std::vector<std::unique_ptr<SwTableToTextSave>>;
 
class SW_DLLPUBLIC SwNodes final
    : private BigPtrArray
{
    friend class SwDoc;
    friend class SwNode;
    friend class SwNodeIndex;
    friend class SwStartNode;
    friend class ::sw::DocumentContentOperationsManager;
 
    SwNodeIndex* m_vIndices; 
    void RemoveNode( SwNodeOffset nDelPos, SwNodeOffset nLen, bool bDel );
 
    void InsertNode( SwNode* pNode, const SwNodeIndex& rPos );
    void InsertNode( SwNode* pNode, SwNodeOffset nPos );
 
    SwDoc& m_rMyDoc;                      
 
    SwNode *m_pEndOfPostIts, *m_pEndOfInserts,  
           *m_pEndOfAutotext, *m_pEndOfRedlines;
    std::unique_ptr<SwNode> m_pEndOfContent;
 
    mutable SwOutlineNodes m_aOutlineNodes;        
 
    bool m_bInNodesDel : 1;           
    bool m_bInDelUpdOutline : 1;         
 
    // Actions on the nodes.
    static void SectionUpDown( const SwNodeIndex & aStart, const SwNodeIndex & aEnd );
    void DelNodes( const SwNodeIndex& rStart, SwNodeOffset nCnt = SwNodeOffset(1) );
 
    void ChgNode( SwNodeIndex const & rDelPos, SwNodeOffset nSize,
                  SwNodeIndex& rInsPos, bool bNewFrames );
 
    void UpdateOutlineIdx( const SwNode& );   
 
    void CopyNodes( const SwNodeRange&, SwNode& rPos,
                    bool bNewFrames, bool bTableInsDummyNode = false ) const;
    void DelDummyNodes( const SwNodeRange& rRg );
 
    SwNodes(SwNodes const&) = delete;
    SwNodes& operator=(SwNodes const&) = delete;
 
    SwNodes(SwDoc& rDoc);
 
public:
    ~SwNodes();
 
    typedef std::vector<SwNodeRange> NodeRanges_t;
    typedef std::vector<NodeRanges_t> TableRanges_t;
 
    SwNode* operator[]( SwNodeOffset n ) const; // defined in node.hxx
 
    SwNodeOffset Count() const { return SwNodeOffset(BigPtrArray::Count()); }
    void ForEach( FnForEach_SwNodes fnForEach, void* pArgs = nullptr )
    {
        ForEach( SwNodeOffset(0), Count(), fnForEach, pArgs );
    }
    void ForEach( SwNodeOffset nStt, SwNodeOffset nEnd, FnForEach_SwNodes fnForEach, void* pArgs );
    void ForEach( SwNode& rStart, SwNode& rEnd,
                    FnForEach_SwNodes fnForEach, void* pArgs );
    void ForEach( const SwNodeIndex& rStart, const SwNodeIndex& rEnd,
                    FnForEach_SwNodes fnForEach, void* pArgs );
 
    SwNode& GetEndOfPostIts() const     { return *m_pEndOfPostIts; }
    SwNode& GetEndOfInserts() const     { return *m_pEndOfInserts; }
    SwNode& GetEndOfAutotext() const    { return *m_pEndOfAutotext; }
    SwNode& GetEndOfRedlines() const    { return *m_pEndOfRedlines; }
    SwNode& GetEndOfExtras() const      { return *m_pEndOfRedlines; }
    SwNode& GetEndOfContent() const     { return *m_pEndOfContent; }
 
    bool IsDocNodes() const;
 
    static sal_uInt16 GetSectionLevel(const SwNode &rIndex);
    void Delete(const SwNodeIndex &rPos, SwNodeOffset nNodes = SwNodeOffset(1));
    void Delete(const SwNode& rPos, SwNodeOffset nNodes = SwNodeOffset(1));
 
    bool MoveNodes( const SwNodeRange&, SwNodes& rNodes, SwNode& rPos,
                bool bNewFrames = true );
    void MoveRange( SwPaM&, SwPosition&, SwNodes& rNodes );
 
    void Copy_( const SwNodeRange& rRg, SwNode& rInsPos,
                bool bNewFrames = true ) const
        {   CopyNodes( rRg, rInsPos, bNewFrames ); }
 
    void SectionUp( SwNodeRange *);
    void SectionDown( SwNodeRange *pRange, SwStartNodeType = SwNormalStartNode );
 
    static void GoStartOfSection(SwNodeIndex *);
    static void GoEndOfSection(SwNodeIndex *);
 
    SwContentNode* GoNext(SwNodeIndex *) const;
    SwContentNode* GoNext(SwPosition *) const;
    static SwContentNode* GoPrevious(SwNodeIndex *);
    static SwContentNode* GoPrevious(SwPosition *);
 
    SwContentNode* GoNextSection( SwNodeIndex *, bool bSkipHidden  = true,
                                           bool bSkipProtect = true ) const;
    SwContentNode* GoNextSection( SwPosition *, bool bSkipHidden  = true,
                                           bool bSkipProtect = true ) const;
    static SwContentNode* GoPrevSection( SwNodeIndex *, bool bSkipHidden  = true,
                                           bool bSkipProtect = true );
    static SwContentNode* GoPrevSection( SwPosition *, bool bSkipHidden  = true,
                                           bool bSkipProtect = true );
 
    static SwStartNode* MakeEmptySection( SwNode& rWhere,
                                    SwStartNodeType = SwNormalStartNode );
 
    SwTextNode *MakeTextNode( SwNode& rWhere,
                            SwTextFormatColl *pColl,
                            bool bNewFrames = true); 
    SwStartNode* MakeTextSection( const SwNode & rWhere,
                            SwStartNodeType eSttNdTyp,
                            SwTextFormatColl *pColl );
 
    static SwGrfNode *MakeGrfNode( SwNode& rWhere,
                            const OUString& rGrfName,
                            const OUString& rFltName,
                            const Graphic* pGraphic,
                            SwGrfFormatColl *pColl,
                            SwAttrSet const * pAutoAttr = nullptr );    
 
    static SwGrfNode *MakeGrfNode( SwNode & rWhere,
                            const GraphicObject& rGrfObj,
                            SwGrfFormatColl *pColl ); 
 
    SwOLENode *MakeOLENode( SwNode& rWhere,
                            const svt::EmbeddedObjectRef&,
                            SwGrfFormatColl *pColl ); 
    SwOLENode *MakeOLENode( SwNode& rWhere,
                            const OUString &rName,
                            sal_Int64 nAspect,
                            SwGrfFormatColl *pColl,
                            SwAttrSet const * pAutoAttr ); 
 
    const SwOutlineNodes& GetOutLineNds() const { return m_aOutlineNodes;}
 
    void UpdateOutlineNode(SwNode & rNd);
 
    static SwTableNode* InsertTable( SwNode& rNd,
                        sal_uInt16 nBoxes, SwTextFormatColl* pContentTextColl,
                        sal_uInt16 nLines, sal_uInt16 nRepeat,
                        SwTextFormatColl* pHeadlineTextColl,
                        const SwAttrSet * pAttrSet);
 
    SwTableNode* TextToTable( const SwNodeRange& rRange, sal_Unicode cCh,
                                SwTableFormat* pTableFormat,
                                SwTableLineFormat* pLineFormat,
                                SwTableBoxFormat* pBoxFormat,
                                SwTextFormatColl* pTextColl,
                                SwUndoTextToTable* pUndo );
 
    void ExpandRangeForTableBox(const SwNodeRange & rRange,
                                std::optional<SwNodeRange>& rExpandedRange);
 
    SwTableNode* TextToTable( const TableRanges_t& rTableNodes,
                                SwTableFormat* pTableFormat,
                                SwTableLineFormat* pLineFormat,
                                SwTableBoxFormat* pBoxFormat );
 
    bool TableToText( const SwNodeRange& rRange, sal_Unicode cCh,
                        SwUndoTableToText* );
    SwTableNode* UndoTableToText( SwNodeOffset nStt, SwNodeOffset nEnd,
                        const SwTableToTextSaves& rSavedData );
 
    bool InsBoxen( SwTableNode*, SwTableLine*, SwTableBoxFormat*,
                        SwTextFormatColl*, const SfxItemSet* pAutoAttr,
                        sal_uInt16 nInsPos, sal_uInt16 nCnt = 1 );
    SwTableNode* SplitTable( SwNode& rPos, bool bAfter = true,
                                bool bCalcNewSize = false );
    bool MergeTable( SwNode& rPos, bool bWithPrev = true );
 
    SwSectionNode* InsertTextSection(SwNode& rNd,
                                SwSectionFormat& rSectionFormat,
                                SwSectionData const&,
                                SwTOXBase const*const pTOXBase,
                                SwNode const * pEndNd,
                                bool const bInsAtStart = true,
                                bool const bCreateFrames = true);
 
            SwDoc& GetDoc()         { return m_rMyDoc; }
    const   SwDoc& GetDoc() const   { return m_rMyDoc; }
 
    SwNode* FindPrvNxtFrameNode( const SwNode& rFrameNd,
                                const SwNode* pEnd,
                                SwRootFrame const* pLayout = nullptr) const;
 
    SwNode * DocumentSectionStartNode(SwNode * pNode) const;
    SwNode * DocumentSectionEndNode(SwNode * pNode) const;
 
    void dumpAsXml( xmlTextWriterPtr pWriter ) const;
};
 
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */