txtfrm.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_SOURCE_CORE_INC_TXTFRM_HXX
#define INCLUDED_SW_SOURCE_CORE_INC_TXTFRM_HXX
 
#include <com/sun/star/uno/Sequence.hxx>
#include "cntfrm.hxx"
#include "TextFrameIndex.hxx"
#include <nodeoffset.hxx>
 
#include <set>
#include <utility>
 
#include <view.hxx>
 
namespace com::sun::star::linguistic2 { class XHyphenatedWord; }
 
namespace sw::mark { class IMark; }
class SwCharRange;
class SwTextNode;
class SwTextAttrEnd;
class SwTextFormatter;
class SwTextFormatInfo;
class SwParaPortion;
class WidowsAndOrphans;
class SwTextFootnote;
class SwInterHyphInfo;      // Hyphenate()
class SwCache;
class SwBorderAttrs;
class SwFrameFormat;
struct SwCursorMoveState;
struct SwFillData;
class SwPortionHandler;
class SwScriptInfo;
enum class ExpandMode;
class SwTextAttr;
class SwWrtShell;
class SwNode;
class SwFlyAtContentFrame;
 
#define NON_PRINTING_CHARACTER_COLOR Color(0x26, 0x8b, 0xd2)
 
class SwInterHyphInfoTextFrame
{
private:
    css::uno::Reference<css::linguistic2::XHyphenatedWord> m_xHyphWord;
public:
    TextFrameIndex m_nStart;
    TextFrameIndex m_nEnd;
    TextFrameIndex m_nWordStart;
    TextFrameIndex m_nWordLen;
 
    SwInterHyphInfoTextFrame(SwTextFrame const& rFrame,
            SwTextNode const& rNode, SwInterHyphInfo const& rHyphInfo);
    void UpdateTextNodeHyphInfo(SwTextFrame const& rFrame,
            SwTextNode const& rNode, SwInterHyphInfo & o_rHyphInfo);
 
    void SetHyphWord(const css::uno::Reference<css::linguistic2::XHyphenatedWord> &xHW)
    {
        m_xHyphWord = xHW;
    }
};
 
namespace sw {
 
struct Extent
{
    SwTextNode * /*const logically, but need assignment for std::vector*/ pNode;
    sal_Int32 nStart;
    sal_Int32 nEnd;
    Extent(SwTextNode *const p, sal_Int32 const s, sal_Int32 const e)
        : pNode(p), nStart(s), nEnd(e)
    {
        assert(pNode);
        assert(nStart != nEnd);
    }
};
 
struct MergedPara;
class InsertText;
 
std::pair<SwTextNode*, sal_Int32> MapViewToModel(MergedPara const&, TextFrameIndex nIndex);
TextFrameIndex MapModelToView(MergedPara const&, SwTextNode const* pNode, sal_Int32 nIndex);
 
// warning: Existing must be used only once; a second use would delete the frame created by the first one...
enum class FrameMode { New, Existing };
std::unique_ptr<sw::MergedPara> CheckParaRedlineMerge(SwTextFrame & rFrame, SwTextNode & rTextNode, FrameMode eMode);
SwTextFrame * MakeTextFrame(SwTextNode & rNode, SwFrame *, sw::FrameMode eMode);
 
bool FrameContainsNode(SwContentFrame const& rFrame, SwNodeOffset nNodeIndex);
bool IsParaPropsNode(SwRootFrame const& rLayout, SwTextNode const& rNode);
SwTextNode * GetParaPropsNode(SwRootFrame const& rLayout, SwNode const& rNode);
SwPosition GetParaPropsPos(SwRootFrame const& rLayout, SwPosition const& rPos);
std::pair<SwTextNode *, SwTextNode *>
GetFirstAndLastNode(SwRootFrame const& rLayout, SwNode const& rPos);
 
SwTextNode const& GetAttrMerged(SfxItemSet & rFormatSet,
        SwTextNode const& rNode, SwRootFrame const* pLayout);
 
void GotoPrevLayoutTextFrame(SwNodeIndex & rIndex, SwRootFrame const* pLayout);
void GotoNextLayoutTextFrame(SwNodeIndex & rIndex, SwRootFrame const* pLayout);
 
TextFrameIndex UpdateMergedParaForDelete(MergedPara & rMerged,
        bool isRealDelete,
        SwTextNode const& rNode, sal_Int32 nIndex, sal_Int32 nLen);
 
void MoveMergedFlysAndFootnotes(std::vector<SwTextFrame*> const& rFrames,
        SwTextNode const& rFirstNode, SwTextNode & rSecondNode, bool);
 
void MoveDeletedPrevFrames(const SwTextNode & rDeletedPrev, SwTextNode & rNode);
enum class Recreate { No, ThisNode, Predecessor };
void CheckResetRedlineMergeFlag(SwTextNode & rNode, Recreate eRecreateMerged);
 
void UpdateFramesForAddDeleteRedline(SwDoc & rDoc, SwPaM const& rPam);
void UpdateFramesForRemoveDeleteRedline(SwDoc & rDoc, SwPaM const& rPam);
 
void AddRemoveFlysAnchoredToFrameStartingAtNode(
        SwTextFrame & rFrame, SwTextNode & rTextNode,
        std::set<SwNodeOffset> *pSkipped);
 
OUString GetExpandTextMerged(SwRootFrame const* pLayout,
        SwTextNode const& rNode, bool bWithNumber,
        bool bWithSpacesForLevel, ExpandMode i_mode);
 
bool IsMarkHidden(SwRootFrame const& rLayout, ::sw::mark::IMark const& rMark);
bool IsMarkHintHidden(SwRootFrame const& rLayout,
        SwTextNode const& rNode, SwTextAttrEnd const& rHint);
 
void RecreateStartTextFrames(SwTextNode & rNode);
 
sw::InsertText MakeInsertText(SwTextNode& rNode, const sal_Int32 nPos, const sal_Int32 nLen);
 
bool HasNumberingWhichNeedsLayoutUpdate(const SwTextNode& rTextNode);
 
} // namespace sw
 
class SW_DLLPUBLIC SwTextFrame final : public SwContentFrame
{
    friend class SwTextIter;
    friend class SwTestFormat;
    friend class WidowsAndOrphans;
    friend class TextFrameLockGuard; // May Lock()/Unlock()
    friend bool sw_ChangeOffset(SwTextFrame* pFrame, TextFrameIndex nNew);
 
    static SwCache *s_pTextCache;
    static constexpr tools::Long nMinPrtLine = 0;    // This Line must not be underrun when printing
                                // Hack for table cells stretching multiple pages
 
    sal_Int32  mnAllLines        :24; // Line count for the Paint (including nThisLines)
    sal_Int32  mnThisLines       :8; // Count of Lines of the Frame
 
    // The x position for flys anchored at this paragraph.
    // These values are calculated in SwTextFrame::CalcBaseOfstForFly()
    SwTwips mnFlyAnchorOfst;
    // The x position for wrap-through flys anchored at this paragraph.
    SwTwips mnFlyAnchorOfstNoWrap;
    SwTwips mnFlyAnchorVertOfstNoWrap;
    SwTwips mnFootnoteLine;
    // OD 2004-03-17 #i11860# - re-factoring of #i11859#
    // member for height of last line (value needed for proportional line spacing)
    SwTwips mnHeightOfLastLine;
    // member for the additional first line offset, which is caused by the list
    // label alignment for list level position and space mode LABEL_ALIGNMENT.
    // This additional first line offset is used for the text formatting.
    // It is NOT used for the determination of printing area.
    SwTwips mnAdditionalFirstLineOffset;
 
    std::unique_ptr<sw::MergedPara> m_pMergedPara;
 
    TextFrameIndex mnOffset; // Is the offset in the Content (character count)
 
    sal_uInt16 mnCacheIndex; // Index into the cache, USHRT_MAX if there's definitely no fitting object in the cache
 
    // Separates the Master and creates a Follow or adjusts the data in the Follow
    void AdjustFollow_( SwTextFormatter &rLine, TextFrameIndex nOffset,
                               TextFrameIndex nStrEnd, const sal_uInt8 nMode );
 
    // Iterates all Lines and sets the line spacing using the attribute
    void CalcLineSpace();
 
    // Only called in Format
    void AdjustFrame( const SwTwips nChgHeight, bool bHasToFit = false );
 
    // Evaluates the Preps in Format()
    bool CalcPreps();
    void PrepWidows( const sal_uInt16 nNeed, bool bNotify );
    void InvalidateRange_( const SwCharRange &, const tools::Long = 0);
    inline void InvalidateRange( const SwCharRange &, const tools::Long = 0);
 
    // WidowsAndOrphans, AdjustFrame, AdjustFollow
    void FormatAdjust( SwTextFormatter &rLine, WidowsAndOrphans &rFrameBreak,
                       TextFrameIndex nStrLen, const bool bDummy );
    void ChangeOffset( SwTextFrame* pFrame, TextFrameIndex nNew );
 
    bool mbLocked        : 1;        // In the Format?
    bool mbWidow         : 1;        // Is our follow a Widow?
    bool mbJustWidow     : 1;        // Did we just request Widow flag on master?
    bool mbEmpty         : 1;        // Are we an empty paragraph?
    bool mbInFootnoteConnect  : 1;        // Is in Connect at the moment
    bool mbFootnote           : 1;        // Has at least one footnote
    bool mbRepaint       : 1;        // TextFrame: Repaint is ready to be fetched
    bool mbHasRotatedPortions : 1;
    bool mbFieldFollow   : 1;        // Start with Field rest of the Master
    bool mbHasAnimation  : 1;        // Contains animated SwGrfNumPortion
    bool mbIsSwapped     : 1;        // during text formatting we swap the
                                    // width and height for vertical formatting
    // OD 14.03.2003 #i11760# - flag to control, if follow is formatted in
    // method <CalcFollow(..)>.
    // E.g., avoid formatting of follow, if method <SwLayoutFrame::FormatWidthCols(..)>
    // is running.
    bool mbFollowFormatAllowed : 1;
 
    void ResetPreps();
    void Lock() { mbLocked = true; }
    void Unlock() { mbLocked = false; }
    void SetWidow( const bool bNew ) { mbWidow = bNew; }
    void SetJustWidow( const bool bNew ) { mbJustWidow = bNew; }
    void SetEmpty( const bool bNew ) { mbEmpty = bNew; }
    void SetFieldFollow( const bool bNew ) { mbFieldFollow = bNew; }
 
    bool IsIdxInside(TextFrameIndex nPos, TextFrameIndex nLen) const;
 
    // Changes the Frame or not (cf. FlyCnt)
    bool GetModelPositionForViewPoint_(SwPosition *pPos, const Point &rPoint,
                      const bool bChgFrame, SwCursorMoveState* = nullptr ) const;
    void FillCursorPos( SwFillData &rFill ) const;
 
    // Format exactly one Line
    bool FormatLine( SwTextFormatter &rLine, const bool bPrev );
 
    // In order to safe stack space, we split this method:
    // Format_ calls Format_ with parameters
    void FormatImpl( vcl::RenderContext* pRenderContext, SwParaPortion *pPara,
            ::std::vector<SwAnchoredObject *> & rIntersectingObjs);
    void Format_( SwTextFormatter &rLine, SwTextFormatInfo &rInf,
                  const bool bAdjust = false );
    void FormatOnceMore( SwTextFormatter &rLine, SwTextFormatInfo &rInf );
 
    // Formats the Follow and ensures disposing on orphans
    bool CalcFollow(TextFrameIndex nTextOfst);
 
    virtual void MakePos() override;
 
    // Corrects the position from which we need to format
    static TextFrameIndex FindBrk(std::u16string_view aText, TextFrameIndex nStart,
                                  TextFrameIndex nEnd);
 
    // inline branch
    SwTwips GetFootnoteFrameHeight_() const;
 
    // Outsourced to CalcPreps
    bool CalcPrepFootnoteAdjust();
 
    // For Footnote and WidOrp: Forced validation
    void ValidateFrame();
    void ValidateBodyFrame();
 
    bool GetDropRect_( SwRect &rRect ) const;
 
    void SetPara( SwParaPortion *pNew, bool bDelete = true );
 
    bool IsFootnoteNumFrame_() const;
 
    // Refresh formatting information
    bool FormatQuick( bool bForceQuickFormat );
 
    // Opt: Format empty paragraphs
    bool FormatEmpty();
    SwTwips EmptyHeight() const;
 
    // Opt: Paint empty paragraphs
    bool PaintEmpty( const SwRect &, bool bCheck ) const;
 
    void ChgThisLines(); // Must always be called if the Line count could have changed
 
    // required for 'new' relative anchor position
    void CalcBaseOfstForFly();
 
    void CalcHeightOfLastLine( const bool _bUseFont = false );
 
    virtual void DestroyImpl() override;
    virtual ~SwTextFrame() override;
 
    void UpdateOutlineContentVisibilityButton(SwWrtShell* pWrtSh) const;
    void PaintOutlineContentVisibilityButton() const;
 
    void PaintParagraphStylesHighlighting() const;
 
    virtual void SwClientNotify(SwModify const& rModify, SfxHint const& rHint) override;
 
    std::vector<SwFlyAtContentFrame*> GetSplitFlyDrawObjs() const;
 
public:
 
    virtual const SvxFormatBreakItem& GetBreakItem() const override;
    virtual const SwFormatPageDesc& GetPageDescItem() const override;
 
    css::uno::Sequence< css::style::TabStop >  GetTabStopInfo( SwTwips CurrentPos ) override;
 
    void Init();
 
    SwRect AutoSpell_(SwTextNode &, sal_Int32);
 
    SwRect SmartTagScan(SwTextNode &);
 
    void CollectAutoCmplWrds(SwTextNode &, sal_Int32);
 
    virtual bool GetCharRect( SwRect& rRect, const SwPosition& rPos,
                                SwCursorMoveState* pCMS = nullptr, bool bAllowFarAway = true ) const override;
 
    bool GetAutoPos( SwRect &, const SwPosition& ) const;
 
    bool GetTopOfLine( SwTwips& _onTopOfLine,
                       const SwPosition& _rPos ) const;
 
    virtual bool FillSelection( SwSelectionList& rList, const SwRect& rRect ) const override;
 
    virtual bool GetModelPositionForViewPoint( SwPosition *, Point&,
                                  SwCursorMoveState* = nullptr, bool bTestBackground = false ) const override;
 
    bool GetKeyCursorOfst(SwPosition *pPos, const Point &rPoint ) const
            { return GetModelPositionForViewPoint_( pPos, rPoint, false ); }
 
    void   PaintExtraData( const SwRect & rRect ) const; 
    SwRect GetPaintSwRect();
    virtual void PaintSwFrame( vcl::RenderContext& rRenderContext, SwRect const&,
                        SwPrintData const*const pPrintData = nullptr ) const override;
    virtual bool GetInfo( SfxPoolItem & ) const override;
 
    virtual bool LeftMargin(SwPaM *) const override;
    virtual bool RightMargin(SwPaM *, bool bAPI = false) const override;
 
    virtual bool UnitUp(SwPaM *, const SwTwips nOffset,
                            bool bSetInReadOnly ) const override;
    virtual bool UnitDown(SwPaM *, const SwTwips nOffset,
                            bool bSetInReadOnly ) const override;
    bool UnitUp_(SwPaM *, const SwTwips nOffset,
                            bool bSetInReadOnly ) const;
    bool UnitDown_(SwPaM *, const SwTwips nOffset,
                            bool bSetInReadOnly ) const;
 
    void PrepareVisualMove( TextFrameIndex& nPos, sal_uInt8& nCursorLevel,
                            bool& bRight, bool bInsertCursor );
 
    void            SplitFrame(TextFrameIndex nTextPos);
    SwContentFrame *JoinFrame();
    TextFrameIndex GetOffset() const { return mnOffset; }
           void        SetOffset_(TextFrameIndex nNewOfst);
    inline void        SetOffset (TextFrameIndex nNewOfst);
    void ManipOfst(TextFrameIndex const nNewOfst) { mnOffset = nNewOfst; }
           SwTextFrame   *GetFrameAtPos ( const SwPosition &rPos);
    inline const SwTextFrame *GetFrameAtPos ( const SwPosition &rPos) const;
    SwTextFrame&   GetFrameAtOfst(TextFrameIndex nOfst);
    bool IsEmptyMaster() const
        { return GetFollow() && !GetFollow()->GetOffset(); }
 
    void SetMergedPara(std::unique_ptr<sw::MergedPara> p);
    sw::MergedPara      * GetMergedPara()       { return m_pMergedPara.get(); }
    sw::MergedPara const* GetMergedPara() const { return m_pMergedPara.get(); }
 
    const OUString& GetText() const;
    SwTextNode const* GetTextNodeForParaProps() const;
    SwTextNode const* GetTextNodeForFirstText() const;
    SwTextNode      * GetTextNodeFirst()
        { return const_cast<SwTextNode*>(const_cast<SwTextFrame const*>(this)->GetTextNodeFirst()); };
    SwTextNode const* GetTextNodeFirst() const;
    SwDoc      & GetDoc()
        { return const_cast<SwDoc &>(const_cast<SwTextFrame const*>(this)->GetDoc()); }
    SwDoc const& GetDoc() const;
 
    SwTextFrame(SwTextNode * const, SwFrame*, sw::FrameMode eMode);
 
    virtual bool Prepare( const PrepareHint ePrep = PrepareHint::Clear,
                          const void *pVoid = nullptr, bool bNotify = true ) override;
 
    virtual bool WouldFit(SwTwips &nMaxHeight, bool &bSplit, bool bTst, bool bMoveBwd) override;
 
    bool TestFormat( const SwFrame* pPrv, SwTwips &nMaxHeight, bool &bSplit );
 
    bool Hyphenate(SwInterHyphInfoTextFrame & rInf);
 
    inline SwTwips GrowTst( const SwTwips nGrow );
 
    SwParaPortion *GetPara();
    inline const SwParaPortion *GetPara() const;
    inline bool HasPara() const;
    bool HasPara_() const;
 
    std::pair<SwTextNode*, sal_Int32> MapViewToModel(TextFrameIndex nIndex) const;
    SwPosition MapViewToModelPos(TextFrameIndex nIndex) const;
    TextFrameIndex MapModelToView(SwTextNode const* pNode, sal_Int32 nIndex) const;
    TextFrameIndex MapModelToViewPos(SwPosition const& rPos) const;
 
    // If there are any hanging punctuation portions in the margin
    // the offset will be returned.
    SwTwips HangingMargin() const;
 
    SwTwips GetLowerMarginForFlyIntersect() const;
 
    // Locking
    bool IsLocked()      const { return mbLocked;     }
 
    bool IsWidow()       const { return mbWidow;      }
    bool IsJustWidow()   const { return mbJustWidow;  }
    bool IsEmpty()       const { return mbEmpty;      }
    bool HasFootnote()        const { return mbFootnote;        }
    bool IsInFootnoteConnect()const { return mbInFootnoteConnect;}
    bool IsFieldFollow() const { return mbFieldFollow;}
 
    inline void SetRepaint() const;
    inline void ResetRepaint() const;
    bool HasRepaint() const { return mbRepaint; }
    void SetHasRotatedPortions(bool bHasRotatedPortions);
    bool GetHasRotatedPortions() const { return mbHasRotatedPortions; }
    void SetAnimation() const
        { const_cast<SwTextFrame*>(this)->mbHasAnimation = true; }
    bool HasAnimation() const { return mbHasAnimation; }
 
    bool IsSwapped() const { return mbIsSwapped; }
 
#ifdef DBG_UTIL
    void CalcFootnoteFlag(TextFrameIndex nStop = TextFrameIndex(COMPLETE_STRING)); //For testing SplitFrame
#else
    void CalcFootnoteFlag();
#endif
 
    bool IsHiddenNow() const;       // bHidden && pOut == pPrt
    void HideHidden();              // Remove appendage if Hidden
    void HideFootnotes(TextFrameIndex nStart, TextFrameIndex nEnd);
 
    void HideAndShowObjects();
 
    void RemoveFootnote(TextFrameIndex nStart,
                        TextFrameIndex nLen = TextFrameIndex(COMPLETE_STRING));
    inline SwTwips GetFootnoteFrameHeight() const;
    SwTextFrame *FindFootnoteRef( const SwTextFootnote *pFootnote );
    const SwTextFrame *FindFootnoteRef( const SwTextFootnote *pFootnote ) const
    { return const_cast<SwTextFrame *>(this)->FindFootnoteRef( pFootnote ); }
    void ConnectFootnote( SwTextFootnote *pFootnote, const SwTwips nDeadLine );
 
    SwTwips GetFootnoteLine( const SwTextFootnote *pFootnote ) const;
 
    TextFrameIndex GetDropLen(TextFrameIndex nWishLen) const;
 
    LanguageType GetLangOfChar(TextFrameIndex nIndex, sal_uInt16 nScript,
            bool bNoChar = false) const;
 
    virtual void Format( vcl::RenderContext* pRenderContext, const SwBorderAttrs *pAttrs = nullptr ) override;
    virtual void CheckDirection( bool bVert ) override;
 
    SwTwips GetParHeight() const;
 
    inline       SwTextFrame *GetFollow();
    inline const SwTextFrame *GetFollow() const;
 
    SwTextFrame *FindQuoVadisFrame();
 
    SwTextFrame* GetFormatted( bool bForceQuickFormat = false );
 
    void SetFootnote( const bool bNew ) { mbFootnote = bNew; }
 
    inline bool IsInside(TextFrameIndex nPos) const;
 
    bool GetDropRect( SwRect &rRect ) const
    { return HasPara() && GetDropRect_( rRect ); }
 
    static SwCache *GetTextCache() { return s_pTextCache; }
    static void     SetTextCache( SwCache *pNew ) { s_pTextCache = pNew; }
 
    static tools::Long GetMinPrtLine() { return nMinPrtLine; }
 
    sal_uInt16 GetCacheIdx() const { return mnCacheIndex; }
    void   SetCacheIdx( const sal_uInt16 nNew ) { mnCacheIndex = nNew; }
 
    void ClearPara();
    void RemoveFromCache();
 
    bool IsFootnoteNumFrame() const
    { return IsInFootnote() && !GetIndPrev() && IsFootnoteNumFrame_(); }
 
    SwTwips CalcFitToContent();
 
    void CalcAdditionalFirstLineOffset();
 
    SwTwips GetAdditionalFirstLineOffset() const
    {
        return mnAdditionalFirstLineOffset;
    }
 
    tools::Long GetLineSpace( const bool _bNoPropLineSpacing = false ) const;
 
    sal_uInt16 FirstLineHeight() const;
 
    void MoveFlyInCnt(SwTextFrame *pNew, TextFrameIndex nStart, TextFrameIndex nEnd);
 
    TextFrameIndex CalcFlyPos( SwFrameFormat const * pSearch );
 
    bool FillRegister( SwTwips& rRegStart, sal_uInt16& rRegDiff );
 
    sal_Int32 GetLineCount(TextFrameIndex nPos);
 
    sal_Int32 GetAllLines()  const { return mnAllLines; }
    sal_Int32 GetThisLines() const { return mnThisLines;}
    void RecalcAllLines();
 
    void StopAnimation( const OutputDevice *pOut );
 
    void VisitPortions( SwPortionHandler& rPH ) const;
 
    const SwScriptInfo* GetScriptInfo() const;
 
    void SwapWidthAndHeight();
 
    void SwitchHorizontalToVertical( SwRect& rRect ) const;
 
    void SwitchHorizontalToVertical( Point& rPoint ) const;
 
    tools::Long SwitchHorizontalToVertical( tools::Long nLimit ) const;
 
    void SwitchVerticalToHorizontal( SwRect& rRect ) const;
 
    void SwitchVerticalToHorizontal( Point& rPoint ) const;
 
    tools::Long SwitchVerticalToHorizontal( tools::Long nLimit ) const;
 
    void SwitchLTRtoRTL( SwRect& rRect ) const;
 
    void SwitchLTRtoRTL( Point& rPoint ) const;
 
    void SwitchRTLtoLTR( SwRect& rRect ) const { SwitchLTRtoRTL( rRect ); }
 
    void SwitchRTLtoLTR( Point& rPoint ) const { SwitchLTRtoRTL( rPoint ); };
 
    bool FollowFormatAllowed() const
    {
        return mbFollowFormatAllowed;
    }
 
    void AllowFollowFormat()
    {
        mbFollowFormatAllowed = true;
    }
 
    void ForbidFollowFormat()
    {
        mbFollowFormatAllowed = false;
    }
 
    SwTwips GetBaseOffsetForFly( bool bIgnoreFlysAnchoredAtThisFrame ) const
    {
        return ( bIgnoreFlysAnchoredAtThisFrame ?
                 mnFlyAnchorOfst :
                 mnFlyAnchorOfstNoWrap );
    }
 
    SwTwips GetBaseVertOffsetForFly(bool bIgnoreFlysAnchoredAtThisFrame) const;
 
    SwTwips GetHeightOfLastLine() const
    {
        return mnHeightOfLastLine;
    }
 
    static void repaintTextFrames( const SwTextNode& rNode );
 
    void RegisterToNode(SwTextNode &, bool isForceNodeAsFirst = false);
 
    bool IsSymbolAt(TextFrameIndex) const;
    OUString GetCurWord(SwPosition const&) const;
    sal_uInt16 GetScalingOfSelectedText(TextFrameIndex nStt, TextFrameIndex nEnd);
 
    bool HasNonLastSplitFlyDrawObj() const;
 
    bool IsEmptyMasterWithSplitFly() const;
 
    bool IsEmptyWithSplitFly() const;
 
    static SwView* GetView();
 
    virtual void dumpAsXmlAttributes(xmlTextWriterPtr writer) const override;
 
    void dumpAsXml(xmlTextWriterPtr writer = nullptr) const override;
};
 
//use this to protect a SwTextFrame for a given scope from getting merged with
//its neighbour and thus deleted
class TextFrameLockGuard
{
private:
    SwTextFrame *m_pTextFrame;
    bool m_bOldLocked;
public:
    //Lock pFrame for the lifetime of the Cut/Paste call, etc. to avoid
    //SwTextFrame::AdjustFollow_ removing the pFrame we're trying to Make
    TextFrameLockGuard(SwFrame* pFrame)
    {
        m_pTextFrame = pFrame->IsTextFrame() ? static_cast<SwTextFrame*>(pFrame) : nullptr;
        if (m_pTextFrame)
        {
            m_bOldLocked = m_pTextFrame->IsLocked();
            m_pTextFrame->Lock();
        }
        else
        {
            m_bOldLocked = false;
        }
    }
 
    ~TextFrameLockGuard()
    {
        if (m_pTextFrame && !m_bOldLocked)
            m_pTextFrame->Unlock();
    }
};
 
inline const SwParaPortion *SwTextFrame::GetPara() const
{
    return const_cast<SwTextFrame*>(this)->GetPara();
}
 
inline bool SwTextFrame::HasPara() const
{
    return mnCacheIndex!=USHRT_MAX && HasPara_();
}
 
inline SwTwips SwTextFrame::GrowTst( const SwTwips nGrow )
{
    return Grow( nGrow, true );
}
 
inline bool SwTextFrame::IsInside(TextFrameIndex const nPos) const
{
    bool bRet = true;
    if( nPos < GetOffset() )
        bRet = false;
    else
    {
        const SwTextFrame *pFoll = GetFollow();
        if( pFoll && nPos >= pFoll->GetOffset() )
            bRet = false;
    }
    return bRet;
}
 
inline SwTwips SwTextFrame::GetFootnoteFrameHeight() const
{
    if(  !IsFollow() && IsInFootnote() && HasPara() )
        return GetFootnoteFrameHeight_();
    else
        return 0;
}
 
inline const SwTextFrame *SwTextFrame::GetFollow() const
{
    return static_cast<const SwTextFrame*>(SwContentFrame::GetFollow());
}
inline SwTextFrame *SwTextFrame::GetFollow()
{
    return static_cast<SwTextFrame*>(SwContentFrame::GetFollow());
}
 
inline const SwTextFrame *SwTextFrame::GetFrameAtPos( const SwPosition &rPos) const
{
    return const_cast<SwTextFrame*>(this)->GetFrameAtPos( rPos );
}
 
inline void SwTextFrame::SetOffset(TextFrameIndex const nNewOfst)
{
    if ( mnOffset != nNewOfst )
        SetOffset_( nNewOfst );
}
 
inline void SwTextFrame::SetRepaint() const
{
    const_cast<SwTextFrame*>(this)->mbRepaint = true;
}
inline void SwTextFrame::ResetRepaint() const
{
    const_cast<SwTextFrame*>(this)->mbRepaint = false;
}
 
class TemporarySwap {
protected:
    explicit TemporarySwap(SwTextFrame * frame, bool swap):
        m_frame(frame), m_undo(false)
    {
        if (m_frame->IsVertical() && swap) {
            m_undo = true;
            m_frame->SwapWidthAndHeight();
        }
    }
 
    ~TemporarySwap() {
        if (m_undo) {
            m_frame->SwapWidthAndHeight();
        }
    }
 
private:
    TemporarySwap(TemporarySwap const &) = delete;
    void operator =(TemporarySwap const &) = delete;
 
    SwTextFrame * m_frame;
    bool m_undo;
};
 
class SwSwapIfSwapped: private TemporarySwap {
public:
    explicit SwSwapIfSwapped(SwTextFrame* frame):
        TemporarySwap(frame, frame->IsSwapped()) {}
};
 
class SwSwapIfNotSwapped: private TemporarySwap {
public:
    explicit SwSwapIfNotSwapped(SwTextFrame* frame):
        TemporarySwap(frame, !frame->IsSwapped()) {}
};
 
class SwFrameSwapper
{
    const SwTextFrame* pFrame;
    bool bUndo;
public:
    SwFrameSwapper( const SwTextFrame* pFrame, bool bSwapIfNotSwapped );
    ~SwFrameSwapper();
};
 
class SwLayoutModeModifier
{
    const OutputDevice& m_rOut;
    vcl::text::ComplexTextLayoutFlags m_nOldLayoutMode;
public:
    SwLayoutModeModifier( const OutputDevice& rOutp );
    ~SwLayoutModeModifier();
    void Modify( bool bChgToRTL );
    void SetAuto();
};
 
class SwDigitModeModifier
{
    const OutputDevice& rOut;
    LanguageType nOldLanguageType;
public:
    SwDigitModeModifier( const OutputDevice& rOutp, LanguageType eCurLang );
    ~SwDigitModeModifier();
};
 
namespace sw {
 
struct MergedPara
{
    sw::WriterMultiListener listener;
    std::vector<Extent> extents;
    OUString mergedText;
    SwTextNode * pParaPropsNode;
    SwTextNode *const pFirstNode;
    SwTextNode const* pLastNode;
    MergedPara(SwTextFrame & rFrame, std::vector<Extent>&& rExtents,
            OUString aText,
            SwTextNode *const pProps, SwTextNode *const pFirst,
            SwTextNode const*const pLast)
        : listener(rFrame), extents(std::move(rExtents)), mergedText(std::move(aText))
        , pParaPropsNode(pProps), pFirstNode(pFirst), pLastNode(pLast)
    {
        assert(pParaPropsNode);
        assert(pFirstNode);
        assert(pLastNode);
    }
};
 
class MergedAttrIterBase
{
protected:
    sw::MergedPara const*const m_pMerged;
    SwTextNode const*const m_pNode;
    size_t m_CurrentExtent;
    size_t m_CurrentHint;
    MergedAttrIterBase(SwTextFrame const& rFrame);
};
 
class MergedAttrIter
    : public MergedAttrIterBase
{
public:
    MergedAttrIter(SwTextFrame const& rFrame) : MergedAttrIterBase(rFrame) {}
    SwTextAttr const* NextAttr(SwTextNode const** ppNode = nullptr);
};
 
class MergedAttrIterByEnd
{
private:
    std::vector<std::pair<SwTextNode const*, SwTextAttr const*>> m_Hints;
    SwTextNode const*const m_pNode;
    size_t m_CurrentHint;
public:
    MergedAttrIterByEnd(SwTextFrame const& rFrame);
    SwTextAttr const* NextAttr(SwTextNode const*& rpNode);
    void PrevAttr();
};
 
class MergedAttrIterReverse
    : public MergedAttrIterBase
{
public:
    MergedAttrIterReverse(SwTextFrame const& rFrame);
    SwTextAttr const* PrevAttr(SwTextNode const** ppNode = nullptr);
};
 
 
const SwTwips WIDOW_MAGIC = (SAL_MAX_INT32 - 1)/2;
 
} // namespace sw
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */