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 "bparr.hxx"
#include "ndtyp.hxx"
#include <rtl/ustring.hxx>
#include <o3tl/sorted_vector.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 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( sal_uLong nDelPos, sal_uLong nLen, bool bDel );

    void InsertNode( SwNode* pNode, const SwNodeIndex& rPos );
    void InsertNode( SwNode* pNode, sal_uLong nPos );

    SwDoc& m_rMyDoc;                      

    SwNode *m_pEndOfPostIts, *m_pEndOfInserts,  
           *m_pEndOfAutotext, *m_pEndOfRedlines;
    std::unique_ptr<SwNode> m_pEndOfContent;

    mutable std::unique_ptr<SwOutlineNodes> m_pOutlineNodes;        

    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, sal_uLong nCnt = 1 );

    void ChgNode( SwNodeIndex const & rDelPos, sal_uLong nSize,
                  SwNodeIndex& rInsPos, bool bNewFrames );

    void UpdateOutlineIdx( const SwNode& );   

    void CopyNodes( const SwNodeRange&, const SwNodeIndex&,
                    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[]( sal_uLong n ) const; // defined in node.hxx

    sal_uLong Count() const { return BigPtrArray::Count(); }
    void ForEach( FnForEach_SwNodes fnForEach, void* pArgs = nullptr )
    {
        ForEach( 0, BigPtrArray::Count(), fnForEach, pArgs );
    }
    void ForEach( sal_uLong nStt, sal_uLong nEnd, 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 SwNodeIndex &rIndex);
    void Delete(const SwNodeIndex &rPos, sal_uLong nNodes = 1);

    bool MoveNodes( const SwNodeRange&, SwNodes& rNodes, const SwNodeIndex&,
                bool bNewFrames = true );
    void MoveRange( SwPaM&, SwPosition&, SwNodes& rNodes );

    void Copy_( const SwNodeRange& rRg, const SwNodeIndex& 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;
    static SwContentNode* GoPrevious(SwNodeIndex *);

    SwContentNode* GoNextSection( SwNodeIndex *, bool bSkipHidden  = true,
                                           bool bSkipProtect = true ) const;
    static SwContentNode* GoPrevSection( SwNodeIndex *, bool bSkipHidden  = true,
                                           bool bSkipProtect = true );

    static SwStartNode* MakeEmptySection( const SwNodeIndex& rIdx,
                                    SwStartNodeType = SwNormalStartNode );

    SwTextNode *MakeTextNode( const SwNodeIndex & rWhere,
                            SwTextFormatColl *pColl,
                            bool bNewFrames = true); 
    SwStartNode* MakeTextSection( const SwNodeIndex & rWhere,
                            SwStartNodeType eSttNdTyp,
                            SwTextFormatColl *pColl );

    static SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
                            const OUString& rGrfName,
                            const OUString& rFltName,
                            const Graphic* pGraphic,
                            SwGrfFormatColl *pColl,
                            SwAttrSet const * pAutoAttr = nullptr );    

    static SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
                            const GraphicObject& rGrfObj,
                            SwGrfFormatColl *pColl ); 

    SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
                            const svt::EmbeddedObjectRef&,
                            SwGrfFormatColl *pColl ); 
    SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
                            const OUString &rName,
                            sal_Int64 nAspect,
                            SwGrfFormatColl *pColl,
                            SwAttrSet const * pAutoAttr ); 

    const SwOutlineNodes& GetOutLineNds() const { return *m_pOutlineNodes;}

    void UpdateOutlineNode(SwNode & rNd);

    static SwTableNode* InsertTable( const SwNodeIndex& rNdIdx,
                        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 );

    std::unique_ptr<SwNodeRange> ExpandRangeForTableBox(const SwNodeRange & rRange);

    SwTableNode* TextToTable( const TableRanges_t& rTableNodes,
                                SwTableFormat* pTableFormat,
                                SwTableLineFormat* pLineFormat,
                                SwTableBoxFormat* pBoxFormat );

    bool TableToText( const SwNodeRange& rRange, sal_Unicode cCh,
                        SwUndoTableToText* );
    SwTableNode* UndoTableToText( sal_uLong nStt, sal_uLong nEnd,
                        const SwTableToTextSaves& rSavedData );

    bool InsBoxen( SwTableNode*, SwTableLine*, SwTableBoxFormat*,
                        SwTextFormatColl*, const SfxItemSet* pAutoAttr,
                        sal_uInt16 nInsPos, sal_uInt16 nCnt = 1 );
    SwTableNode* SplitTable( const SwNodeIndex& rPos, bool bAfter = true,
                                bool bCalcNewSize = false );
    bool MergeTable( const SwNodeIndex& rPos, bool bWithPrev = true,
                    sal_uInt16 nMode = 0 );

    SwSectionNode* InsertTextSection(SwNodeIndex const& rNdIdx,
                                SwSectionFormat& rSectionFormat,
                                SwSectionData const&,
                                SwTOXBase const*const pTOXBase,
                                SwNodeIndex const*const pEnd,
                                bool const bInsAtStart = true,
                                bool const bCreateFrames = true);

            SwDoc& GetDoc()         { return m_rMyDoc; }
    const   SwDoc& GetDoc() const   { return m_rMyDoc; }

    SwNode* FindPrvNxtFrameNode( SwNodeIndex& rFrameIdx,
                                const SwNode* pEnd ) const;

    SwNode * DocumentSectionStartNode(SwNode * pNode) const;
    SwNode * DocumentSectionEndNode(SwNode * pNode) const;

    void dumpAsXml( xmlTextWriterPtr pWriter ) const;
};


#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */