frmtool.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_FRMTOOL_HXX
#define INCLUDED_SW_SOURCE_CORE_INC_FRMTOOL_HXX
 
#include <swtypes.hxx>
#include <BorderCacheOwner.hxx>
#include "frame.hxx"
#include "txtfrm.hxx"
#include "swcache.hxx"
#include <swatrset.hxx>
 
class SwLayoutFrame;
class SwFont;
class SwTextFrame;
class SwFormatAnchor;
class SwViewShell;
class SwPageFrame;
class SwFlyFrame;
class SwContentFrame;
class SwRootFrame;
class SwDoc;
class SdrObject;
class SvxBrushItem;
class SdrMarkList;
class SwNodeIndex;
class GraphicObject;
class GraphicAttr;
class SwPageDesc;
class SwFrameFormats;
class SwRegionRects;
class SwTextNode;
namespace sw { struct Extent; }
namespace basegfx::utils { class B2DClipState; }
 
#define FAR_AWAY (SAL_MAX_INT32 - 20000)  // initial position of a Fly
constexpr tools::Long BROWSE_HEIGHT = 56700 * 10; // 10 Meters
#define GRFNUM_NO 0
#define GRFNUM_YES 1
#define GRFNUM_REPLACE 2
 
void AppendObjs( const SwFrameFormats *pTable, SwNodeOffset nIndex,
                       SwFrame *pFrame, SwPageFrame *pPage, SwDoc* doc );
 
void AppendObjsOfNode(SwFrameFormats const* pTable, SwNodeOffset nIndex,
        SwFrame * pFrame, SwPageFrame * pPage, SwDoc * pDoc,
        std::vector<sw::Extent>::const_iterator const* pIter,
        std::vector<sw::Extent>::const_iterator const* pEnd,
        SwTextNode const* pFirstNode, SwTextNode const* pLastNode);
 
void RemoveHiddenObjsOfNode(SwTextNode const& rNode,
        std::vector<sw::Extent>::const_iterator const* pIter,
        std::vector<sw::Extent>::const_iterator const* pEnd,
        SwTextNode const* pFirstNode, SwTextNode const* pLastNode);
 
bool IsAnchoredObjShown(SwTextFrame const& rFrame, SwFormatAnchor const& rAnchor);
 
void AppendAllObjs(const SwFrameFormats* pTable, const SwFrame* pSib);
 
// draw background with brush or graphics
// The 6th parameter indicates that the method should consider background
// transparency, saved in the color of the brush item.
void DrawGraphic(
    const SvxBrushItem *,
    vcl::RenderContext &,
    const SwRect &rOrg,
    const SwRect &rOut,
    const sal_uInt8 nGrfNum = GRFNUM_NO,
    const bool bConsiderBackgroundTransparency = false );
bool DrawFillAttributes(
    const drawinglayer::attribute::SdrAllFillAttributesHelperPtr& rFillAttributes,
    const SwRect& rOriginalLayoutRect,
    const SwRegionRects& rPaintRegion,
    const basegfx::utils::B2DClipState& rClipState,
    vcl::RenderContext& rOut);
 
// RotGrfFlyFrame: Adapted to rotation
void paintGraphicUsingPrimitivesHelper(
    vcl::RenderContext & rOutputDevice,
    GraphicObject const& rGraphicObj,
    GraphicAttr const& rGraphicAttr,
    const basegfx::B2DHomMatrix& rGraphicTransform,
    const OUString& rName,
    const OUString& rTitle,
    const OUString& rDescription);
 
// MM02 new VOC and primitive-based version
void paintGraphicUsingPrimitivesHelper(
    vcl::RenderContext & rOutputDevice,
    drawinglayer::primitive2d::Primitive2DContainer& rContent,
    const basegfx::B2DHomMatrix& rGraphicTransform,
    const OUString& rName,
    const OUString& rTitle,
    const OUString& rDescription);
 
// method to align rectangle.
// Created declaration here to avoid <extern> declarations
void SwAlignRect( SwRect &rRect, const SwViewShell *pSh, const vcl::RenderContext* pRenderContext );
 
// method to align graphic rectangle
// Created declaration here to avoid <extern> declarations
void SwAlignGrfRect( SwRect *pGrfRect, const vcl::RenderContext &rOut );
 
void PaintCharacterBorder(const SwFont& rFont, const SwRect& rPaintArea, const bool bVerticalLayout,
                          const bool bVerticalLayoutLRBT, const bool bJoinWithPrev,
                          const bool bJoinWithNext);
 
// get Fly, if no List is given use the current shell
// Implementation in feshview.cxx
SwFlyFrame *GetFlyFromMarked( const SdrMarkList *pLst, SwViewShell *pSh );
 
SwFrame *SaveContent( SwLayoutFrame *pLay, SwFrame *pStart = nullptr );
void RestoreContent( SwFrame *pSav, SwLayoutFrame *pParent, SwFrame *pSibling );
 
// Get ContentNodes, create ContentFrames, and add them to LayFrame.
void InsertCnt_( SwLayoutFrame *pLay, SwDoc *pDoc, SwNodeOffset nIndex,
                 bool bPages = false, SwNodeOffset nEndIndex = SwNodeOffset(0),
                 SwFrame *pPrv = nullptr, sw::FrameMode eMode = sw::FrameMode::New);
 
// Creation of frames for a specific section (uses InsertCnt_)
void MakeFrames( SwDoc *pDoc, SwNode &rSttIdx,
                            SwNode &rEndIdx );
 
extern bool bObjsDirect;
 
// for FlyCnts, see SwFlyAtContentFrame::MakeAll()
extern bool bSetCompletePaintOnInvalidate;
 
// for table settings via keyboard
SwTwips CalcRowRstHeight( SwLayoutFrame *pRow );
tools::Long CalcHeightWithFlys( const SwFrame *pFrame );
 
namespace sw {
    bool IsRightPageByNumber(SwRootFrame const& rLayout, sal_uInt16 nPageNum);
    class FlyCreationSuppressor
    {
        const bool m_wasAlreadySuppressed;
        public:
            FlyCreationSuppressor(bool isAlreadySuppressedAllowed = true);
            ~FlyCreationSuppressor();
    };
} // namespace sw
 
SwPageFrame *InsertNewPage( SwPageDesc &rDesc, SwFrame *pUpper,
                          bool isRightPage, bool bFirst, bool bInsertEmpty, bool bFootnote,
                          SwFrame *pSibling, bool bVeryFirstPage = false );
 
// connect Flys with page
void RegistFlys( SwPageFrame*, const SwLayoutFrame* );
 
// notification of Fly's background if needed
void Notify( SwFlyFrame *pFly, SwPageFrame *pOld, const SwRect &rOld,
             const SwRect* pOldRect = nullptr );
 
void Notify_Background( const SdrObject* pObj,
                        SwPageFrame* pPage,
                        const SwRect& rRect,
                        const PrepareHint eHint,
                        const bool bInva );
 
const SwFrame* GetVirtualUpper( const SwFrame* pFrame, const Point& rPos );
 
bool Is_Lower_Of( const SwFrame *pCurrFrame, const SdrObject* pObj );
 
// FIXME: EasyHack (refactoring): rename method and parameter name in all files
const SwFrame *FindContext( const SwFrame *pFrame, SwFrameType nAdditionalContextTyp );
 
bool IsFrameInSameContext( const SwFrame *pInnerFrame, const SwFrame *pFrame );
 
const SwFrame * FindPage( const SwRect &rRect, const SwFrame *pPage );
 
SwFrame* GetFrameOfModify( const SwRootFrame* pLayout,
                       sw::BroadcastingModify const&,
                       SwFrameType const nFrameType,
                       const SwPosition *pPos = nullptr,
                       std::pair<Point, bool> const* pViewPosAndCalcFrame = nullptr);
 
// Should extra data (redline stroke, line numbers) be painted?
bool IsExtraData( const SwDoc *pDoc );
 
// #i11760# - method declaration <CalcContent(..)>
void CalcContent( SwLayoutFrame *pLay, bool bNoColl = false );
 
// Notify classes memorize the current sizes in their constructor and do
// the necessary notifications in their destructor if needed
class SwFrameNotify
{
private:
    void ImplDestroy();
 
protected:
    SwFrame *mpFrame;
    const SwRect maFrame;
    const SwRect maPrt;
    SwTwips mnFlyAnchorOfst;
    SwTwips mnFlyAnchorOfstNoWrap;
    bool     mbHadFollow;
    bool     mbInvaKeep;
    bool     mbValidSize;
 
public:
    SwFrameNotify( SwFrame *pFrame );
    ~SwFrameNotify();
 
    const SwRect &getFrameArea() const { return maFrame; }
    void SetInvaKeep() { mbInvaKeep = true; }
};
 
class SwLayNotify : public SwFrameNotify
{
    bool m_bLowersComplete;
 
    void ImplDestroy();
 
public:
    SwLayNotify( SwLayoutFrame *pLayFrame );
    ~SwLayNotify();
 
    void SetLowersComplete( bool b ) { m_bLowersComplete = b; }
    bool IsLowersComplete() const    { return m_bLowersComplete; }
};
 
class SwFlyNotify : public SwLayNotify
{
    SwPageFrame *m_pOldPage;
    const SwRect m_aFrameAndSpace;
 
    void ImplDestroy();
 
public:
    SwFlyNotify( SwFlyFrame *pFlyFrame );
    ~SwFlyNotify();
};
 
class SwContentNotify : public SwFrameNotify
{
private:
    // #i11859#
    bool    mbChkHeightOfLastLine;
    SwTwips mnHeightOfLastLine;
 
    // #i25029#
    bool        mbInvalidatePrevPrtArea;
    bool        mbBordersJoinedWithPrev;
 
    void ImplDestroy();
 
public:
    SwContentNotify( SwContentFrame *pContentFrame );
    ~SwContentNotify();
 
    // #i25029#
    void SetInvalidatePrevPrtArea()
    {
        mbInvalidatePrevPrtArea = true;
    }
 
    void SetBordersJoinedWithPrev()
    {
        mbBordersJoinedWithPrev = true;
    }
};
 
// SwBorderAttrs encapsulates the calculation for margin attributes including
// border. The whole class is cached.
 
// WARNING! If more attributes should be cached also adjust the method
//          Modify::Modify!
class SwBorderAttrs final : public SwCacheObj
{
    const SwAttrSet      &m_rAttrSet;
    const SvxULSpaceItem &m_rUL;
    // #i96772#
    std::shared_ptr<SvxLRSpaceItem> m_xLR;
    const SvxBoxItem     &m_rBox;
    const SvxShadowItem  &m_rShadow;
    const Size            m_aFrameSize;
 
    // the following bool values set the cached values to INVALID - until they
    // are calculated for the first time
    bool m_bTopLine     : 1;
    bool m_bBottomLine  : 1;
    bool m_bLeftLine    : 1;
    bool m_bRightLine   : 1;
    bool m_bTop         : 1;
    bool m_bBottom      : 1;
    bool m_bLine        : 1;
    bool m_bLineSpacing : 1;
 
    bool m_bIsLine      : 1; // border on at least one side?
 
    bool m_bCacheGetLine        : 1; // cache GetTopLine(), GetBottomLine()?
    bool m_bCachedGetTopLine    : 1; // is GetTopLine() cached?
    bool m_bCachedGetBottomLine : 1; // is GetBottomLine() cached?
    // Booleans indicate that <m_bJoinedWithPrev> and <m_bJoinedWithNext> are
    // cached and valid.
    // Caching depends on value of <m_bCacheGetLine>.
    mutable bool m_bCachedJoinedWithPrev : 1;
    mutable bool m_bCachedJoinedWithNext : 1;
    // Booleans indicate that borders are joined with previous/next frame.
    bool m_bJoinedWithPrev :1;
    bool m_bJoinedWithNext :1;
 
    // The cached values (un-defined until calculated for the first time)
    sal_uInt16 m_nTopLine,
           m_nBottomLine,
           m_nLeftLine,
           m_nRightLine,
           m_nTop,
           m_nBottom,
           m_nGetTopLine,
           m_nGetBottomLine,
           m_nLineSpacing;
 
    // only calculate lines and shadow
    void CalcTopLine_();
    void CalcBottomLine_();
    void CalcLeftLine_();
    void CalcRightLine_();
 
    // lines + shadow + margin
    void CalcTop_();
    void CalcBottom_();
 
    void IsLine_();
 
    // #i25029# - If <_pPrevFrame> is set, its value is taken for testing, if
    // borders/shadow have to be joined with previous frame.
    void GetTopLine_   ( const SwFrame& _rFrame,
                         const SwFrame* _pPrevFrame );
    void GetBottomLine_( const SwFrame& _rFrame );
 
    // calculate cached values <m_bJoinedWithPrev> and <m_bJoinedWithNext>
    // #i25029# - If <_pPrevFrame> is set, its value is taken for testing, if
    // borders/shadow have to be joined with previous frame.
    void CalcJoinedWithPrev( const SwFrame& _rFrame,
                              const SwFrame* _pPrevFrame );
    void CalcJoinedWithNext( const SwFrame& _rFrame );
 
    // internal helper method for CalcJoinedWithPrev and CalcJoinedWithNext
    bool JoinWithCmp( const SwFrame& _rCallerFrame,
                       const SwFrame& _rCmpFrame ) const;
 
    // Are the left and right line and the LRSpace equal?
    bool CmpLeftRight( const SwBorderAttrs &rCmpAttrs,
                       const SwFrame *pCaller,
                       const SwFrame *pCmp ) const;
 
    // tdf#125300 line spacing before cell border
    void CalcLineSpacing_();
 
public:
    SwBorderAttrs( const sw::BorderCacheOwner* pOwner, const SwFrame *pConstructor );
    virtual ~SwBorderAttrs() override;
 
    const SwAttrSet      &GetAttrSet() const { return m_rAttrSet;  }
    const SvxULSpaceItem &GetULSpace() const { return m_rUL;       }
    const SvxBoxItem     &GetBox()     const { return m_rBox;      }
    const SvxShadowItem  &GetShadow()  const { return m_rShadow;   }
 
    inline sal_uInt16 CalcTopLine() const;
    inline sal_uInt16 CalcBottomLine() const;
    inline sal_uInt16 CalcLeftLine() const;
    inline sal_uInt16 CalcRightLine() const;
    inline sal_uInt16 CalcTop() const;
    inline sal_uInt16 CalcBottom() const;
    inline sal_uInt16 CalcLineSpacing() const;
           tools::Long CalcLeft( const SwFrame *pCaller ) const;
           tools::Long CalcRight( const SwFrame *pCaller ) const;
 
    inline bool IsLine() const;
 
    const Size &GetSize()     const { return m_aFrameSize; }
 
    // Should upper (or lower) border be evaluated for this frame?
    // #i25029# - If <_pPrevFrame> is set, its value is taken for testing, if
    // borders/shadow have to be joined with previous frame.
    inline sal_uInt16 GetTopLine   ( const SwFrame& _rFrame,
                                 const SwFrame* _pPrevFrame = nullptr ) const;
    inline sal_uInt16 GetBottomLine( const SwFrame& _rFrame ) const;
    inline void   SetGetCacheLine( bool bNew ) const;
 
    // Accessors for cached values <m_bJoinedWithPrev> and <m_bJoinedWithNext>
    // #i25029# - If <_pPrevFrame> is set, its value is taken for testing, if
    // borders/shadow have to be joined with previous frame.
    bool JoinedWithPrev( const SwFrame& _rFrame,
                         const SwFrame* _pPrevFrame = nullptr ) const;
    bool JoinedWithNext( const SwFrame& _rFrame ) const;
};
 
class SwBorderAttrAccess final : public SwCacheAccess
{
    const SwFrame *m_pConstructor;      //opt: for passing on to SwBorderAttrs
 
    virtual SwCacheObj *NewObj() override;
 
public:
    SwBorderAttrAccess( SwCache &rCache, const SwFrame *pOwner );
 
    SwBorderAttrs *Get();
};
 
// Iterator for draw objects of a page. The objects will be iterated sorted by
// their Z-order. Iterating is not cheap since for each operation the _whole_
// SortArray needs to be traversed.
class SwOrderIter
{
    const SwPageFrame *m_pPage;
    const SdrObject *m_pCurrent;
 
public:
    SwOrderIter( const SwPageFrame *pPage );
 
    void             Current( const SdrObject *pNew ) { m_pCurrent = pNew; }
    const SdrObject *operator()() const { return m_pCurrent; }
    void             Top();
    const SdrObject *Bottom();
    const SdrObject *Next();
    void             Prev();
};
 
class StackHack
{
    static sal_uInt8 s_nCnt;
    static bool s_bLocked;
 
public:
    StackHack()
    {
        if ( ++StackHack::s_nCnt > 50 )
            StackHack::s_bLocked = true;
    }
    ~StackHack()
    {
        if ( --StackHack::s_nCnt < 5 )
            StackHack::s_bLocked = false;
    }
 
    static bool IsLocked()  { return StackHack::s_bLocked; }
    static sal_uInt8 Count()        { return StackHack::s_nCnt; }
};
 
// Should upper (or lower) border be evaluated for this frame?
// #i25029# - If <_pPrevFrame> is set, its value is taken for testing, if
// borders/shadow have to be joined with previous frame.
inline sal_uInt16 SwBorderAttrs::GetTopLine ( const SwFrame& _rFrame,
                                          const SwFrame* _pPrevFrame ) const
{
    if ( !m_bCachedGetTopLine || _pPrevFrame )
    {
        const_cast<SwBorderAttrs*>(this)->GetTopLine_( _rFrame, _pPrevFrame );
    }
    return m_nGetTopLine;
}
inline sal_uInt16 SwBorderAttrs::GetBottomLine( const SwFrame& _rFrame ) const
{
    if ( !m_bCachedGetBottomLine )
        const_cast<SwBorderAttrs*>(this)->GetBottomLine_( _rFrame );
    return m_nGetBottomLine;
}
inline void SwBorderAttrs::SetGetCacheLine( bool bNew ) const
{
    const_cast<SwBorderAttrs*>(this)->m_bCacheGetLine = bNew;
    const_cast<SwBorderAttrs*>(this)->m_bCachedGetBottomLine =
    const_cast<SwBorderAttrs*>(this)->m_bCachedGetTopLine = false;
    // invalidate cache for values <m_bJoinedWithPrev> and <m_bJoinedWithNext>
    m_bCachedJoinedWithPrev = false;
    m_bCachedJoinedWithNext = false;
}
 
inline sal_uInt16 SwBorderAttrs::CalcTopLine() const
{
    if ( m_bTopLine )
        const_cast<SwBorderAttrs*>(this)->CalcTopLine_();
    return m_nTopLine;
}
inline sal_uInt16 SwBorderAttrs::CalcBottomLine() const
{
    if ( m_bBottomLine )
        const_cast<SwBorderAttrs*>(this)->CalcBottomLine_();
    return m_nBottomLine;
}
inline sal_uInt16 SwBorderAttrs::CalcLeftLine() const
{
    if ( m_bLeftLine )
        const_cast<SwBorderAttrs*>(this)->CalcLeftLine_();
    return m_nLeftLine;
}
inline sal_uInt16 SwBorderAttrs::CalcRightLine() const
{
    if ( m_bRightLine )
        const_cast<SwBorderAttrs*>(this)->CalcRightLine_();
    return m_nRightLine;
}
inline sal_uInt16 SwBorderAttrs::CalcTop() const
{
    if ( m_bTop )
        const_cast<SwBorderAttrs*>(this)->CalcTop_();
    return m_nTop;
}
inline sal_uInt16 SwBorderAttrs::CalcBottom() const
{
    if ( m_bBottom )
        const_cast<SwBorderAttrs*>(this)->CalcBottom_();
    return m_nBottom;
}
inline sal_uInt16 SwBorderAttrs::CalcLineSpacing() const
{
    if ( m_bLineSpacing )
        const_cast<SwBorderAttrs*>(this)->CalcLineSpacing_();
    return m_nLineSpacing;
}
inline bool SwBorderAttrs::IsLine() const
{
    if ( m_bLine )
        const_cast<SwBorderAttrs*>(this)->IsLine_();
    return m_bIsLine;
}
 
void GetSpacingValuesOfFrame( const SwFrame& rFrame,
                            SwTwips& onLowerSpacing,
                            SwTwips& onLineSpacing,
                            bool& obIsLineSpacingProportional,
                            bool bIdenticalStyles );
 
const SwContentFrame* GetCellContent( const SwLayoutFrame& rCell_ );
 
class SwDeletionChecker
{
private:
    const SwFrame* mpFrame;
    const sw::BroadcastingModify* mpRegIn;
 
public:
    SwDeletionChecker(const SwFrame* pFrame);
 
    bool HasBeenDeleted() const;
};
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */