flowfrm.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_FLOWFRM_HXX
#define INCLUDED_SW_SOURCE_CORE_INC_FLOWFRM_HXX
 
#include "frame.hxx"
#include "layfrm.hxx"
#include <swtypes.hxx>
 
class SvxFormatKeepItem;
class SvxFormatBreakItem;
class SwPageFrame;
class SwRect;
class SwBorderAttrs;
class SwDoc;
class SwNode;
class SwNodeIndex;
 
class SAL_DLLPUBLIC_RTTI SAL_LOPLUGIN_ANNOTATE("crosscast") SwFlowFrame
{
    // PrepareMake is allowed to lock/unlock (robustness)
    friend inline void PrepareLock  ( SwFlowFrame * );
    friend inline void PrepareUnlock( SwFlowFrame * );
    friend inline void TableSplitRecalcLock( SwFlowFrame * );
    friend inline void TableSplitRecalcUnlock( SwFlowFrame * );
    // #i44049#
    friend class SwObjectFormatterTextFrame;
    friend class FlowFrameJoinLockGuard;
 
    // TableSel is allowed to reset the follow-bit
    friend inline void UnsetFollow( SwFlowFrame *pFlow );
 
    friend void MakeFrames( SwDoc *, SwNode &, SwNode & );
 
    friend class SwNode2LayImpl;
 
    SwFrame& m_rThis;
 
    // helper methods for MoveSubTree()
    static SwLayoutFrame *CutTree( SwFrame* );
    static bool         PasteTree( SwFrame *, SwLayoutFrame *, SwFrame *, SwFrame* );
 
    static bool s_bMoveBwdJump;
 
    const SwFrame* GetPrevFrameForUpperSpaceCalc_( const SwFrame* _pProposedPrevFrame = nullptr ) const;
 
    SwTwips GetUpperSpaceAmountConsideredForPrevFrame() const;
 
    SwTwips GetUpperSpaceAmountConsideredForPageGrid_(
                                const SwTwips _nUpperSpaceWithoutGrid ) const;
 
protected:
    SwFlowFrame *m_pFollow;
    SwFlowFrame *m_pPrecede;
 
    bool m_bLockJoin  :1; // if true than joins (and thus deletes) are prohibited!
    bool m_bUndersized:1; // I am smaller than needed
    bool m_bFlyLock   :1; // stop positioning of at-character flyframes
 
    // checks if forward flow makes sense to prevent infinite moves
    inline bool IsFwdMoveAllowed() const;
    // #i44049# - method <CalcContent(..)> has to check this property.
    friend void CalcContent( SwLayoutFrame *pLay, bool bNoColl );
    bool IsKeepFwdMoveAllowed( bool bIgnoreMyOwnKeepValue = false );    // like above, forward flow for Keep.
 
    sal_uInt8 BwdMoveNecessary( const SwPageFrame *pPage, const SwRect &rRect );
 
    void LockJoin()   { m_bLockJoin = true;  }
    void UnlockJoin() { m_bLockJoin = false; }
 
    bool CheckMoveFwd( bool& rbMakePage, bool bKeep, bool bIgnoreMyOwnKeepValue );
    bool MoveFwd( bool bMakePage, bool bPageBreak, bool bMoveAlways = false );
    bool MoveBwd( bool &rbReformat );
    virtual bool ShouldBwdMoved( SwLayoutFrame *pNewUpper, bool &rReformat )=0;
 
public:
    SwFlowFrame( SwFrame &rFrame );
    virtual ~SwFlowFrame();
 
    const SwFrame& GetFrame() const { return m_rThis; }
          SwFrame& GetFrame()       { return m_rThis; }
 
    static bool IsMoveBwdJump() { return s_bMoveBwdJump; }
    static void SetMoveBwdJump( bool bNew ){ s_bMoveBwdJump = bNew; }
 
    void SetUndersized( const bool bNew ) { m_bUndersized = bNew; }
    bool IsUndersized()  const { return m_bUndersized; }
 
    bool IsPrevObjMove() const;
 
    void MoveSubTree( SwLayoutFrame* pParent, SwFrame* pSibling = nullptr );
 
    bool HasFollow() const { return m_pFollow != nullptr; }
    bool IsFollow() const { return nullptr != m_pPrecede; }
    bool IsAnFollow( const SwFlowFrame *pFlow ) const;
    const SwFlowFrame *GetFollow() const { return m_pFollow; }
          SwFlowFrame *GetFollow()       { return m_pFollow; }
    void SetFollow(SwFlowFrame *const pFollow);
 
    const SwFlowFrame *GetPrecede() const { return m_pPrecede; }
          SwFlowFrame *GetPrecede()       { return m_pPrecede; }
 
    bool IsJoinLocked() const { return m_bLockJoin; }
    bool IsAnyJoinLocked() const { return m_bLockJoin || HasLockedFollow(); }
 
    bool IsPageBreak( bool bAct ) const;
    bool IsColBreak( bool bAct ) const;
 
    bool IsKeep(SvxFormatKeepItem const& rKeep,
                SvxFormatBreakItem const& rBreak,
                bool bBreakCheck = false ) const;
 
    bool HasLockedFollow() const;
 
    bool HasParaSpaceAtPages( bool bSct ) const;
 
    SwTwips CalcUpperSpace( const SwBorderAttrs *pAttrs = nullptr,
                            const SwFrame* pPr = nullptr,
                            const bool _bConsiderGrid = true ) const;
 
    SwTwips GetUpperSpaceAmountConsideredForPrevFrameAndPageGrid() const;
 
    SwTwips CalcLowerSpace( const SwBorderAttrs* _pAttrs = nullptr ) const;
 
    SwTwips CalcAddLowerSpaceAsLastInTableCell(
                                    const SwBorderAttrs* _pAttrs = nullptr ) const;
 
    void CheckKeep();
 
    void SetFlyLock( bool bNew ){ m_bFlyLock = bNew; }
    bool IsFlyLock() const {    return m_bFlyLock; }
 
    bool ForbiddenForFootnoteCntFwd() const;
 
    // Casting of a Frame into a FlowFrame (if it is one, otherwise 0)
    // These methods need to be customized in subclasses!
    static       SwFlowFrame *CastFlowFrame( SwFrame *pFrame );
    static const SwFlowFrame *CastFlowFrame( const SwFrame *pFrame );
};
 
inline bool SwFlowFrame::IsFwdMoveAllowed() const
{
    return m_rThis.GetIndPrev() != nullptr;
}
 
//use this to protect a SwLayoutFrame for a given scope from getting merged with
//its neighbour and thus deleted
class FlowFrameJoinLockGuard
{
private:
    SwFlowFrame *m_pFlow;
    bool m_bOldJoinLocked;
public:
    //JoinLock pParent for the lifetime of the Cut/Paste call, etc. to avoid
    //SwSectionFrame::MergeNext removing the pParent we're trying to reparent
    //into
    FlowFrameJoinLockGuard(SwLayoutFrame* pFrame)
    {
        m_pFlow = SwFlowFrame::CastFlowFrame(pFrame);
        if (m_pFlow)
        {
            m_bOldJoinLocked = m_pFlow->IsJoinLocked();
            m_pFlow->LockJoin();
        }
        else
        {
            m_bOldJoinLocked = false;
        }
    }
 
    ~FlowFrameJoinLockGuard()
    {
        if (m_pFlow && !m_bOldJoinLocked)
            m_pFlow->UnlockJoin();
    }
};
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */