ndtxt.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 .
 */
#pragma once
 
#include <cppuhelper/weakref.hxx>
#include <com/sun/star/text/XTextContent.hpp>
 
#include "swdllapi.h"
#include "IDocumentContentOperations.hxx"
#include "SwNumberTreeTypes.hxx"
#include "hintids.hxx"
#include "list.hxx"
#include "modeltoviewhelper.hxx"
#include "ndhints.hxx"
#include "node.hxx"
#include "paratr.hxx"
 
#include <sfx2/Metadatable.hxx>
#include <unotools/weakref.hxx>
#include <o3tl/sorted_vector.hxx>
#include <memory>
#include <vector>
#include <functional>
 
class SfxHint;
class SwNumRule;
class SwNodeNum;
class SvxFirstLineIndentItem;
class SvxTextLeftMarginItem;
class SwXParagraph;
 
namespace utl {
    class TransliterationWrapper;
}
namespace vcl
{
class Font;
}
 
class SwContentFrame;
class SwTextField;
class SwTextInputField;
class SfxItemSet;
class SwUndoTransliterate;
struct SwSpellArgs;
struct SwConversionArgs;
class SwInterHyphInfo;
class SwWrongList;
class SwGrammarMarkUp;
struct SwDocStat;
enum class ExpandMode;
enum class SwFieldIds : sal_uInt16;
class SwField;
 
namespace sw {
    class TextNodeNotificationSuppressor;
    namespace mark { enum class RestoreMode; }
}
 
namespace com::sun::star {
    namespace uno {
        template < class > class Sequence;
    }
}
 
typedef o3tl::sorted_vector< sal_Int32 > SwSoftPageBreakList;
 
namespace sw
{
 
enum class WrongState { TODO, PENDING, DONE };
 
struct ParagraphIdleData
{
    std::unique_ptr<SwWrongList> pWrong;                // for spell checking
    std::unique_ptr<SwGrammarMarkUp> pGrammarCheck;     // for grammar checking /  proof reading
    std::unique_ptr<SwWrongList> pSmartTags;
    sal_uLong nNumberOfWords  = 0;
    sal_uLong nNumberOfAsianWords  = 0;
    sal_uLong nNumberOfChars  = 0;
    sal_uLong nNumberOfCharsExcludingSpaces = 0;
    bool bWordCountDirty = true;
    WrongState eWrongDirty = WrongState::TODO; 
    bool bGrammarCheckDirty = true;
    bool bSmartTagDirty = true;
    bool bAutoComplDirty = true;               
};
 
} // end namespace sw
 
class SW_DLLPUBLIC SwTextNode final
    : public SwContentNode
    , public ::sfx2::Metadatable
    , public sw::FormatDropDefiner
{
    friend class SwContentNode;
    friend class SwDoc;         
    friend class SwNodes;
    friend class SwTextFrame;
    friend class SwScriptInfo;
    friend class sw::TextNodeNotificationSuppressor;
 
    std::unique_ptr<SwpHints> m_pSwpHints;
 
    mutable std::unique_ptr<SwNodeNum> mpNodeNum;  
    mutable std::unique_ptr<SwNodeNum> mpNodeNumRLHidden; 
    mutable std::unique_ptr<SwNodeNum> mpNodeNumOrig; 
 
    OUString m_Text;
 
    mutable sw::ParagraphIdleData m_aParagraphIdleData;
 
    mutable bool m_bContainsHiddenChars : 1;
    mutable bool m_bHiddenCharsHidePara : 1;
    mutable bool m_bRecalcHiddenCharFlags : 1;
 
    mutable bool m_bLastOutlineState : 1;
    bool m_bNotifiable;
 
    bool mbEmptyListStyleSetDueToSetOutlineLevelAttr;
 
    bool mbInSetOrResetAttr;
 
    bool m_bInUndo;
 
    std::optional< OUString > m_oNumStringCache;
 
    unotools::WeakReference<SwXParagraph> m_wXParagraph;
 
    // DrawingLayer FillAttributes in a preprocessed form for primitive usage
    drawinglayer::attribute::SdrAllFillAttributesHelperPtr  maFillAttributes;
 
    SAL_DLLPRIVATE SwTextNode( SwNode& rWhere, SwTextFormatColl *pTextColl,
                             const SfxItemSet* pAutoAttr = nullptr );
    virtual void SwClientNotify( const SwModify&, const SfxHint& ) override;
    SAL_DLLPRIVATE void CopyAttr( SwTextNode *pDest, const sal_Int32 nStart, const sal_Int32 nOldPos);
 
    SAL_DLLPRIVATE SwTextNode* MakeNewTextNode( SwNode&, bool bNext = true,
                                bool bChgFollow = true );
 
    SAL_DLLPRIVATE void CutImpl(
          SwTextNode * const pDest, const SwContentIndex & rDestStart,
          const SwContentIndex & rStart, /*const*/ sal_Int32 nLen,
          const bool bUpdate = true );
 
    SAL_DLLPRIVATE void MoveTextAttr_To_AttrSet();  // Called by SplitNode.
 
    SAL_DLLPRIVATE virtual void NewAttrSet( SwAttrPool& ) override;
 
    bool IsCalcHiddenCharFlags() const
        { return m_bRecalcHiddenCharFlags; }
    void SetHiddenCharAttribute( bool bNewHiddenCharsHidePara, bool bNewContainsHiddenChars ) const
    {
        m_bHiddenCharsHidePara = bNewHiddenCharsHidePara;
        m_bContainsHiddenChars = bNewContainsHiddenChars;
        m_bRecalcHiddenCharFlags = false;
    }
 
    SAL_DLLPRIVATE void CalcHiddenCharFlags() const;
 
    SAL_DLLPRIVATE void SetLanguageAndFont( const SwPaM &rPaM,
            LanguageType nLang, sal_uInt16 nLangWhichId,
            const vcl::Font *pFont,  sal_uInt16 nFontWhichId );
 
    inline void TryDeleteSwpHints();
 
    SAL_DLLPRIVATE void impl_FormatToTextAttr(const SfxItemSet& i_rAttrSet);
 
    const SwTextInputField* GetOverlappingInputField( const SwTextAttr& rTextAttr ) const;
 
    void DelFrames_TextNodePart();
    void HandleNonLegacyHint(const SfxHint&);
 
public:
    bool IsWordCountDirty() const;
    sw::WrongState GetWrongDirty() const;
    bool IsWrongDirty() const;
    bool IsGrammarCheckDirty() const;
    bool IsSmartTagDirty() const;
    bool IsAutoCompleteWordDirty() const;
    void SetWordCountDirty( bool bNew ) const;
    void SetWrongDirty(sw::WrongState eNew) const;
    void SetGrammarCheckDirty( bool bNew ) const;
    void SetSmartTagDirty( bool bNew ) const;
    void SetAutoCompleteWordDirty( bool bNew ) const;
    void SetWrong( std::unique_ptr<SwWrongList> pNew );
    void ClearWrong();
    std::unique_ptr<SwWrongList> ReleaseWrong();
    SwWrongList* GetWrong();
    const SwWrongList* GetWrong() const;
    void SetGrammarCheck( std::unique_ptr<SwGrammarMarkUp> pNew );
    void ClearGrammarCheck();
    std::unique_ptr<SwGrammarMarkUp> ReleaseGrammarCheck();
    SwGrammarMarkUp* GetGrammarCheck();
    // return SwWrongList because *function pointer* return values aren't covariant
    SwWrongList const* GetGrammarCheck() const;
    void SetSmartTags( std::unique_ptr<SwWrongList> pNew );
    void ClearSmartTags();
    std::unique_ptr<SwWrongList> ReleaseSmartTags();
    SwWrongList* GetSmartTags();
    SwWrongList const* GetSmartTags() const;
 
 
public:
    using SwContentNode::GetAttr;
    void UpdateDocPos(const SwTwips nDocPos, const sal_uInt32 nIndex);
    void TriggerNodeUpdate(const sw::LegacyModifyHint&);
 
    const OUString& GetText() const { return m_Text; }
 
    // returns the maximum number of characters that can still be added to the node
    inline sal_Int32 GetSpaceLeft() const;
 
    inline       SwpHints &GetSwpHints();
    inline const SwpHints &GetSwpHints() const;
          SwpHints *GetpSwpHints()       { return m_pSwpHints.get(); }
    const SwpHints *GetpSwpHints() const { return m_pSwpHints.get(); }
    bool   HasHints() const { return m_pSwpHints != nullptr; }
    inline       SwpHints &GetOrCreateSwpHints();
 
    virtual ~SwTextNode() override;
 
    virtual sal_Int32 Len() const override;
 
    void GetMinMaxSize( SwNodeOffset nIndex, sal_uLong& rMin, sal_uLong &rMax, sal_uLong &rAbs ) const;
 
    virtual bool SetAttr( const SfxPoolItem& ) override;
    virtual bool SetAttr( const SfxItemSet& rSet ) override;
    virtual bool ResetAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 = 0 ) override;
    virtual bool ResetAttr( const std::vector<sal_uInt16>& rWhichArr ) override;
    virtual sal_uInt16 ResetAllAttr() override;
 
    OUString InsertText( const OUString & rStr, const SwContentIndex & rIdx,
                     const SwInsertFlags nMode
                         = SwInsertFlags::DEFAULT );
    OUString InsertText( const OUString & rStr, const SwPosition & rIdx,
                     const SwInsertFlags nMode
                         = SwInsertFlags::DEFAULT );
    void InsertDummy() { m_Text = OUStringChar(CH_TXT_TRACKED_DUMMY_CHAR); }
 
    void EraseText ( const SwContentIndex &rIdx, const sal_Int32 nCount = SAL_MAX_INT32,
                     const SwInsertFlags nMode = SwInsertFlags::DEFAULT );
    void EraseText ( const SwPosition& rIdx, const sal_Int32 nCount = SAL_MAX_INT32,
                     const SwInsertFlags nMode = SwInsertFlags::DEFAULT );
 
    void RstTextAttr(
        const sal_Int32 nContentStart,
        const sal_Int32 nLen,
        const sal_uInt16 nWhich = 0,
        const SfxItemSet* pSet = nullptr,
        const bool bInclRefToxMark = false,
        const bool bExactRange = false );
    void    GCAttr();
 
    // Delete text attribute (needs to be deregistered at Pool!)
    void    DestroyAttr( SwTextAttr* pAttr );
 
    // delete all attributes from SwpHintsArray.
    void    ClearSwpHintsArr( bool bDelFields );
 
    void    FileLoadedInitHints();
 
    bool    InsertHint( SwTextAttr * const pAttr,
                  const SetAttrMode nMode = SetAttrMode::DEFAULT );
    SwTextAttr* InsertItem( SfxPoolItem& rAttr,
                  const sal_Int32 nStart, const sal_Int32 nEnd,
                  const SetAttrMode nMode = SetAttrMode::DEFAULT );
 
    bool SetAttr( const SfxItemSet& rSet,
                  sal_Int32 nStt, sal_Int32 nEnd,
                  const SetAttrMode nMode = SetAttrMode::DEFAULT,
                  SwTextAttr **ppNewTextAttr = nullptr);
    bool GetParaAttr( SfxItemSet& rSet, sal_Int32 nStt, sal_Int32 nEnd,
                  const bool bOnlyTextAttr  = false,
                  const bool bGetFromChrFormat = true,
                  const bool bMergeIndentValuesOfNumRule = false,
                  SwRootFrame const* pLayout = nullptr) const;
 
    void FormatToTextAttr( SwTextNode* pNd );
 
    void DeleteAttributes( const sal_uInt16 nWhich,
                  const sal_Int32 nStart, const sal_Int32 nEnd = 0 );
    void DeleteAttribute ( SwTextAttr * const pTextAttr );
 
    void CopyText( SwTextNode * const pDest,
               const SwContentIndex &rStart,
               const sal_Int32 nLen,
               const bool bForceCopyOfAllAttrs );
    void CopyText( SwTextNode * const pDest,
               const SwContentIndex &rDestStart,
               const SwContentIndex &rStart,
               sal_Int32 nLen,
               const bool bForceCopyOfAllAttrs = false );
    void CopyText( SwTextNode * const pDest,
               const SwContentIndex &rDestStart,
               const SwPosition &rStart,
               sal_Int32 nLen,
               const bool bForceCopyOfAllAttrs = false );
 
    void        CutText(SwTextNode * const pDest,
                    const SwContentIndex & rStart, const sal_Int32 nLen);
    inline void CutText(SwTextNode * const pDest, const SwContentIndex &rDestStart,
                    const SwContentIndex & rStart, const sal_Int32 nLen);
 
    void ReplaceText( const SwContentIndex& rStart, const sal_Int32 nDelLen,
            const OUString & rText );
    void ReplaceText( SwPosition& rStart, const sal_Int32 nDelLen,
            const OUString & rText );
    void ReplaceTextOnly( sal_Int32 nPos, sal_Int32 nLen,
            std::u16string_view aText,
            const css::uno::Sequence<sal_Int32>& rOffsets );
 
    virtual SwContentFrame *MakeFrame( SwFrame* ) override;
    SwTextNode * SplitContentNode(const SwPosition &,
            std::function<void (SwTextNode *, sw::mark::RestoreMode, bool AtStart)> const* pContentIndexRestore);
    virtual SwContentNode *JoinNext() override;
    void JoinPrev();
 
    SwContentNode *AppendNode( const SwPosition & );
 
    bool DontExpandFormat( sal_Int32 nContentIdx, bool bFlag = true,
                        bool bFormatToTextAttributes = true );
 
    SwTextAttr *GetTextAttrAt(
        sal_Int32 const nIndex,
        sal_uInt16 const nWhich,
        ::sw::GetTextAttrMode const eMode = ::sw::GetTextAttrMode::Default) const;
 
    std::vector<SwTextAttr *> GetTextAttrsAt(
        sal_Int32 const nIndex,
        sal_uInt16 const nWhich ) const;
 
    SwTextAttr *GetTextAttrForCharAt(
        const sal_Int32 nIndex,
        const sal_uInt16 nWhich = RES_TXTATR_END ) const;
 
    SwTextAttr* GetTextAttrForEndCharAt(sal_Int32 nIndex, sal_uInt16 nWhich) const;
 
    SwTextField* GetFieldTextAttrAt(
        const sal_Int32 nIndex,
        ::sw::GetTextAttrMode const eMode = ::sw::GetTextAttrMode::Expand) const;
 
    bool Spell(SwSpellArgs*);
    bool Convert( SwConversionArgs & );
 
    inline SwTextFormatColl *GetTextColl() const;
    virtual SwFormatColl *ChgFormatColl( SwFormatColl* ) override;
    void ChgTextCollUpdateNum( const SwTextFormatColl* pOld,
                                const SwTextFormatColl* pNew );
 
    void CopyCollFormat(SwTextNode& rDestNd, bool bUndoForChgFormatColl = true);
 
    // BEGIN OF BULLET/NUMBERING/OUTLINE STUFF:
 
    SwNumRule *GetNumRule(bool bInParent = true) const;
 
    const SwNodeNum* GetNum(SwRootFrame const* pLayout = nullptr,
             SwListRedlineType eRedline = SwListRedlineType::SHOW) const;
    void DoNum(std::function<void (SwNodeNum &)> const&);
 
    SwNumberTree::tNumberVector GetNumberVector(SwRootFrame const* pLayout = nullptr,
            SwListRedlineType eRedline = SwListRedlineType::SHOW) const;
 
    bool IsOutline() const;
 
    bool IsOutlineStateChanged() const;
 
    void UpdateOutlineState();
 
    void NumRuleChgd();
 
    OUString GetNumString( const bool _bInclPrefixAndSuffixStrings = true,
            const unsigned int _nRestrictToThisLevel = MAXLEVEL,
            SwRootFrame const* pLayout = nullptr,
            SwListRedlineType eRedline = SwListRedlineType::SHOW) const;
 
     tools::Long GetLeftMarginWithNum( bool bTextLeft = false ) const;
 
    bool GetFirstLineOfsWithNum( short& rFirstOffset ) const;
 
    SwTwips GetAdditionalIndentForStartingNewList() const;
 
    tools::Long GetLeftMarginForTabCalculation() const;
 
    bool HasNumber(SwRootFrame const* pLayout = nullptr) const;
 
    bool HasBullet() const;
 
    bool IsNumbered(SwRootFrame const* pLayout = nullptr) const;
 
    bool HasMarkedLabel() const;
 
    void SetAttrListLevel(int nLevel);
 
    bool HasAttrListLevel() const;
 
    int GetAttrListLevel() const;
 
    int GetActualListLevel(SwListRedlineType eRedline = SwListRedlineType::SHOW) const;
 
    int GetAttrOutlineLevel() const;
 
    void SetAttrOutlineLevel(int nLevel);
 
    void GetAttrOutlineContentVisible(bool& bOutlineContentVisibleAttr);
    void SetAttrOutlineContentVisible(bool bVisible);
 
    bool IsEmptyListStyleDueToSetOutlineLevelAttr() const { return mbEmptyListStyleSetDueToSetOutlineLevelAttr;}
    void SetEmptyListStyleDueToSetOutlineLevelAttr();
    void ResetEmptyListStyleDueToResetOutlineLevelAttr();
 
    SwTwips GetWidthOfLeadingTabs() const;
 
    bool HasVisibleNumberingOrBullet() const;
 
    void SetListId(OUString const& rListId);
    OUString GetListId() const;
 
    ::sw::ListLevelIndents AreListLevelIndentsApplicable() const;
    bool AreListLevelIndentsApplicableImpl(sal_uInt16 nWhich) const;
 
    bool GetListTabStopPosition( tools::Long& nListTabStopPosition ) const;
 
    OUString GetLabelFollowedBy() const;
 
    // END OF BULLET/NUMBERING/OUTLINE STUFF:
 
    void fillSoftPageBreakList( SwSoftPageBreakList& rBreak ) const;
 
    LanguageType GetLang( const sal_Int32 nBegin, const sal_Int32 nLen = 0,
                    sal_uInt16 nScript = 0 ) const;
 
    bool IsSymbolAt(sal_Int32 nBegin) const; // In itratr.cxx.
    virtual SwContentNode* MakeCopy(SwDoc&, SwNode& rWhere, bool bNewFrames) const override;
 
    bool Hyphenate( SwInterHyphInfo &rHyphInf );
    void DelSoftHyph( const sal_Int32 nStart, const sal_Int32 nEnd );
 
    OUString GetExpandText( SwRootFrame const* pLayout,
                            const sal_Int32 nIdx = 0,
                            const sal_Int32 nLen = -1,
                            const bool bWithNum = false,
                            const bool bAddSpaceAfterListLabelStr = false,
                            const bool bWithSpacesForLevel = false,
                            const ExpandMode eAdditionalMode = ExpandMode::ExpandFootnote | ExpandMode::HideFieldmarkCommands) const;
    bool CopyExpandText( SwTextNode& rDestNd, const SwContentIndex* pDestIdx,
                           sal_Int32 nIdx, sal_Int32 nLen,
                           SwRootFrame const* pLayout,
                           bool bWithNum = false, bool bWithFootnote = true,
                           bool bReplaceTabsWithSpaces = false ) const;
 
    OUString GetRedlineText() const;
 
    sal_Int32 GetDropLen(sal_Int32 nWishLen) const;
 
    bool GetDropSize(int& rFontHeight, int& rDropHeight, int& rDropDescent) const;
 
    bool CalcHiddenParaField()
        { return m_pSwpHints && m_pSwpHints->CalcHiddenParaField(); }
    void SetCalcHiddenParaField()
        { if (m_pSwpHints) m_pSwpHints->SetCalcHiddenParaField(); }
 
    bool IsHiddenByParaField() const
        { return m_pSwpHints && m_pSwpHints->IsHiddenByParaField(); }
 
 
    bool HasHiddenCharAttribute( bool bWholePara ) const
    {
        if ( m_bRecalcHiddenCharFlags )
            CalcHiddenCharFlags();
        return bWholePara ? m_bHiddenCharsHidePara : m_bContainsHiddenChars;
    }
 
    void SetCalcHiddenCharFlags() const
        { m_bRecalcHiddenCharFlags = true; }
 
    bool IsHidden() const;
 
 
    virtual void Update(
        SwContentIndex const & rPos,
        const sal_Int32 nChangeLen,
        UpdateMode eMode) override;
 
    void TransliterateText( utl::TransliterationWrapper& rTrans,
                            sal_Int32 nStart, sal_Int32 nEnd,
                            SwUndoTransliterate* pUndo, bool bUseRedlining = false );
 
    bool CountWords( SwDocStat& rStat, sal_Int32 nStart, sal_Int32 nEnd ) const;
 
    bool IsNotificationEnabled() const;
 
    bool IsNotifiable() const;
 
    void SetListRestart( bool bRestart );
    bool IsListRestart() const;
 
    void SetAttrListRestartValue( SwNumberTree::tSwNumTreeNumber nNum );
    bool HasAttrListRestartValue() const;
    SwNumberTree::tSwNumTreeNumber GetAttrListRestartValue() const;
    SwNumberTree::tSwNumTreeNumber GetActualListStartValue() const;
 
    void SetCountedInList( bool bCounted );
    bool IsCountedInList() const;
 
    void AddToList();
    void AddToListRLHidden();
    void AddToListOrig();
    void RemoveFromList();
    void RemoveFromListRLHidden();
    void RemoveFromListOrig();
    bool IsInList() const;
 
    bool IsFirstOfNumRule(SwRootFrame const& rLayout) const;
 
    SAL_DLLPRIVATE unotools::WeakReference<SwXParagraph> const& GetXParagraph() const
            { return m_wXParagraph; }
    SAL_DLLPRIVATE void SetXParagraph(rtl::Reference<SwXParagraph> const& xParagraph);
 
    virtual ::sfx2::IXmlIdRegistry& GetRegistry() override;
    virtual bool IsInClipboard() const override;
    virtual bool IsInUndo() const override;
    virtual bool IsInContent() const override;
    virtual css::uno::Reference< css::rdf::XMetadatable > MakeUnoObject() override;
 
    bool IsCollapse() const;
 
    virtual void dumpAsXml(xmlTextWriterPtr pWriter) const override;
 
    sal_uInt32 GetRsid( sal_Int32 nStt, sal_Int32 nEnd ) const;
    sal_uInt32 GetParRsid() const;
 
    bool CompareRsid( const SwTextNode &rTextNode, sal_Int32 nStt1, sal_Int32 nStt2 ) const;
    bool CompareParRsid( const SwTextNode &rTextNode ) const;
 
    // Access to DrawingLayer FillAttributes in a preprocessed form for primitive usage
    virtual drawinglayer::attribute::SdrAllFillAttributesHelperPtr getSdrAllFillAttributesHelper() const override;
 
    static bool IsIgnoredCharFormatForNumbering(const sal_uInt16 nWhich, bool bIsCharStyle = false);
    void FormatDropNotify(const SwFormatDrop& rDrop) override
            { TriggerNodeUpdate(sw::LegacyModifyHint(&rDrop, &rDrop)); };
 
    void SetInSwUndo(bool bInUndo);
};
 
inline SwpHints & SwTextNode::GetSwpHints()
{
    assert( m_pSwpHints );
    return *m_pSwpHints;
}
inline const SwpHints &SwTextNode::GetSwpHints() const
{
    assert( m_pSwpHints );
    return *m_pSwpHints;
}
 
inline SwpHints& SwTextNode::GetOrCreateSwpHints()
{
    if ( !m_pSwpHints )
    {
        m_pSwpHints.reset(new SwpHints(*this));
    }
    return *m_pSwpHints;
}
 
inline void SwTextNode::TryDeleteSwpHints()
{
    if ( m_pSwpHints && m_pSwpHints->CanBeDeleted() )
    {
        m_pSwpHints.reset();
    }
}
 
inline SwTextFormatColl* SwTextNode::GetTextColl() const
{
    return const_cast<SwTextFormatColl*>(static_cast<const SwTextFormatColl*>(GetRegisteredIn()));
}
 
inline SwTextNode *SwNode::GetTextNode()
{
     return SwNodeType::Text == m_nNodeType ? static_cast<SwTextNode*>(this) : nullptr;
}
 
inline const SwTextNode *SwNode::GetTextNode() const
{
     return SwNodeType::Text == m_nNodeType ? static_cast<const SwTextNode*>(this) : nullptr;
}
 
inline void
SwTextNode::CutText(SwTextNode * const pDest, const SwContentIndex & rDestStart,
                    const SwContentIndex & rStart, const sal_Int32 nLen)
{
    CutImpl( pDest, rDestStart, rStart, nLen );
}
 
inline sal_Int32 SwTextNode::GetSpaceLeft() const
{
    // do not fill the String up to the max - need to be able to have a
    // SwPosition "behind" the last character, i.e., at index TXTNODE_MAX + 1
    const sal_Int32 TXTNODE_MAX = SAL_MAX_INT32 - 2;
    return TXTNODE_MAX-m_Text.getLength();
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */