rootfrm.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_ROOTFRM_HXX
#define INCLUDED_SW_SOURCE_CORE_INC_ROOTFRM_HXX
 
#include "layfrm.hxx"
#include <viewsh.hxx>
#include <doc.hxx>
#include <IDocumentTimerAccess.hxx>
#include <o3tl/typed_flags_set.hxx>
#include <set>
#include <vector>
 
class SwContentFrame;
class SdrPage;
class SwFrameFormat;
class SwPaM;
class SwCursor;
class SwShellCursor;
class SwTableCursor;
class SwLayVout;
class SwViewOption;
class SwSelectionList;
struct SwPosition;
struct SwCursorMoveState;
 
namespace sw {
    enum class RedlineMode
    {
        Shown, Hidden
    };
 
    enum class FieldmarkMode { ShowCommand = 1, ShowResult = 2, ShowBoth = 3 };
};
 
enum class SwInvalidateFlags
{
    Size      = 0x01,
    PrtArea   = 0x02,
    Pos       = 0x04,
    Table     = 0x08,
    Section   = 0x10,
    LineNum   = 0x20,
    Direction = 0x40,
};
 
namespace o3tl
{
    template<> struct typed_flags<SwInvalidateFlags> : is_typed_flags<SwInvalidateFlags, 0x7f> {};
};
 
enum class SwRemoveResult
{
    Next,
    Prev
};
 
using SwCurrShells = std::set<CurrShell*>;
 
class SwSectionFrame;
using SwDestroyList = o3tl::sorted_vector<SwSectionFrame*>;
 
class SW_DLLPUBLIC SwRootFrame final : public SwLayoutFrame
{
    // Needs to disable the Superfluous temporarily
    friend void AdjustSizeChgNotify( SwRootFrame *pRoot );
 
    // Maintains the mpLastPage (Cut() and Paste() of SwPageFrame
    friend inline void SetLastPage( SwPageFrame* );
 
    // For creating and destroying of the virtual output device manager
    friend void FrameInit(); // Creates s_pVout
    friend void FrameFinit(); // Destroys s_pVout
 
    std::vector<SwRect> maPageRects;// returns the current rectangle for each page frame
                                    // the rectangle is extended to the top/bottom/left/right
                                    // for pages located at the outer margins
    SwRect  maPagesArea;            // the area covered by the pages
    tools::Long    mnViewWidth;            // the current page layout bases on this view width
    sal_uInt16  mnColumns;          // the current page layout bases on this number of columns
    bool    mbBookMode;             // the current page layout is in book view
    bool    mbSidebarChanged;       // the notes sidebar state has changed
 
    bool    mbNeedGrammarCheck;     // true when sth needs to be checked (not necessarily started yet!)
 
    static SwLayVout     *s_pVout;
    static bool           s_isInPaint; // Protection against double Paints
    static bool           s_isNoVirDev;// No virt. Device for SystemPaints
 
    static constexpr sal_Int64 MIN_BROWSE_WIDTH = o3tl::toTwips(20000, o3tl::Length::mm100);
 
    bool    mbCheckSuperfluous   :1; // Search for empty Pages?
    bool    mbIdleFormat         :1; // Trigger Idle Formatter?
    bool    mbBrowseWidthValid   :1; // Is mnBrowseWidth valid?
    bool    mbTurboAllowed       :1;
    bool    mbAssertFlyPages     :1; // Insert more Pages for Flys if needed?
    bool    mbTableUpdateInProgress : 1; // tdf#139426 to allow suppression of AssertFlyPages during TableUpdate
    bool    mbIsVirtPageNum      :1; // Do we have a virtual pagenumber?
    bool    mbIsNewLayout        :1; // Layout loaded or newly created
    bool    mbCallbackActionEnabled:1; // No Action in Notification desired
                                      // @see dcontact.cxx, ::Changed()
    bool    mbLayoutFreezed;
    bool    mbHideRedlines;
    sw::FieldmarkMode m_FieldmarkMode;
 
    tools::Long    mnBrowseWidth;
 
    const SwContentFrame *mpTurbo;
 
    SwPageFrame *mpLastPage;
 
    friend class CurrShell;
    friend void SetShell( SwViewShell *pSh );
    friend void InitCurrShells( SwRootFrame *pRoot );
    SwViewShell *mpCurrShell;
    SwViewShell *mpWaitingCurrShell;
    std::unique_ptr<SwCurrShells> mpCurrShells;
 
    SdrPage *mpDrawPage;
 
    std::unique_ptr<SwDestroyList> mpDestroy;
 
    sal_uInt16  mnPhyPageNums; 
    sal_uInt16 mnAccessibleShells; // Number of accessible shells
 
    void ImplCalcBrowseWidth();
    void ImplInvalidateBrowseWidth();
 
    void DeleteEmptySct_(); // Destroys the registered SectionFrames
    void RemoveFromList_( SwSectionFrame* pSct ); // Removes SectionFrames from the Delete List
 
    virtual void DestroyImpl() override;
    virtual ~SwRootFrame() override;
 
    virtual void MakeAll(vcl::RenderContext* pRenderContext) override;
 
public:
 
    static void RemoveMasterObjs( SdrPage *pPg );
 
    void AllCheckPageDescs() const;
    void AllInvalidateAutoCompleteWords() const;
    void AllAddPaintRect() const;
    void AllRemoveFootnotes() ;
    void AllInvalidateSmartTagsOrSpelling(bool bSmartTags) const;
 
    static bool FlushVout();
 
    static bool HasSameRect( const SwRect& rRect );
 
    SwRootFrame( SwFrameFormat*, SwViewShell* );
    void Init(SwFrameFormat*);
 
    SwViewShell *GetCurrShell() const { return mpCurrShell; }
    void DeRegisterShell( SwViewShell *pSh );
 
    void StartAllAction();
    void EndAllAction( bool bVirDev = false );
 
    void UnoRemoveAllActions();
    void UnoRestoreAllActions();
 
    const SdrPage* GetDrawPage() const { return mpDrawPage; }
          SdrPage* GetDrawPage()       { return mpDrawPage; }
          void     SetDrawPage( SdrPage* pNew ){ mpDrawPage = pNew; }
 
    virtual bool  GetModelPositionForViewPoint( SwPosition *, Point&,
                               SwCursorMoveState* = nullptr, bool bTestBackground = false ) const override;
 
    virtual void PaintSwFrame( vcl::RenderContext& rRenderContext, SwRect const&,
                        SwPrintData const*const pPrintData = nullptr ) const override;
    virtual SwTwips ShrinkFrame( SwTwips, bool bTst = false, bool bInfo = false ) override;
    virtual SwTwips GrowFrame  ( SwTwips, bool bTst = false, bool bInfo = false ) override;
#ifdef DBG_UTIL
    virtual void Cut() override;
    virtual void Paste( SwFrame* pParent, SwFrame* pSibling = nullptr ) override;
#endif
 
    virtual bool FillSelection( SwSelectionList& rList, const SwRect& rRect ) const override;
 
    Point  GetNextPrevContentPos( const Point &rPoint, bool bNext ) const;
 
    virtual Size ChgSize( const Size& aNewSize ) override;
 
    void SetIdleFlags()
    {
        mbIdleFormat = true;
 
        SwViewShell* pCurrShell = GetCurrShell();
        // May be NULL if called from SfxBaseModel::dispose
        // (this happens in the build test 'rtfexport').
        if (pCurrShell != nullptr)
            pCurrShell->GetDoc()->getIDocumentTimerAccess().StartIdling();
    }
    bool IsIdleFormat()  const { return mbIdleFormat; }
    void ResetIdleFormat()     { mbIdleFormat = false; }
 
    bool IsNeedGrammarCheck() const         { return mbNeedGrammarCheck; }
    void SetNeedGrammarCheck( bool bVal )
    {
        mbNeedGrammarCheck = bVal;
 
        if ( bVal )
        {
            SwViewShell* pCurrShell = GetCurrShell();
            // May be NULL if called from SfxBaseModel::dispose
            // (this happens in the build test 'rtfexport').
            if (pCurrShell != nullptr)
                pCurrShell->GetDoc()->getIDocumentTimerAccess().StartIdling();
        }
    }
 
    void SetAssertFlyPages() { mbAssertFlyPages = true; }
    void AssertFlyPages();
    bool IsAssertFlyPages() const { return mbAssertFlyPages; }
 
    void SetTableUpdateInProgress(bool bValue) { mbTableUpdateInProgress = bValue; }
    bool IsTableUpdateInProgress() const { return mbTableUpdateInProgress; }
 
    static void AssertPageFlys( SwPageFrame * );
 
    void InvalidateAllContent( SwInvalidateFlags nInvalidate );
 
    void InvalidateAllObjPos();
 
    void SetSuperfluous()      { mbCheckSuperfluous = true; }
    bool IsSuperfluous() const { return mbCheckSuperfluous; }
    void RemoveSuperfluous();
 
    sal_uInt16  GetCurrPage( const SwPaM* ) const;
    sal_uInt16  SetCurrPage( SwCursor*, sal_uInt16 nPageNum );
    Point   GetPagePos( sal_uInt16 nPageNum ) const;
    sal_uInt16  GetPageNum() const      { return mnPhyPageNums; }
    void    DecrPhyPageNums()       { --mnPhyPageNums; }
    void    IncrPhyPageNums()       { ++mnPhyPageNums; }
    bool    IsVirtPageNum() const   { return mbIsVirtPageNum; }
    inline  void SetVirtPageNum( const bool bOf ) const;
    bool    IsDummyPage( sal_uInt16 nPageNum ) const;
 
    const SwPageFrame* GetPageAtPos( const Point& rPt, const Size* pSize = nullptr, bool bExtend = false ) const;
 
    bool IsBetweenPages(const Point& rPt) const;
 
    void CalcFrameRects( SwShellCursor& );
 
    bool MakeTableCursors( SwTableCursor& );
 
    void DisallowTurbo()  const { const_cast<SwRootFrame*>(this)->mbTurboAllowed = false; }
    void ResetTurboFlag() const { const_cast<SwRootFrame*>(this)->mbTurboAllowed = true; }
    bool IsTurboAllowed() const { return mbTurboAllowed; }
    void SetTurbo( const SwContentFrame *pContent ) { mpTurbo = pContent; }
    void ResetTurbo() { mpTurbo = nullptr; }
    const SwContentFrame *GetTurbo() const { return mpTurbo; }
 
    void UpdateFootnoteNums(); // Only for page by page numbering!
 
    void RemoveFootnotes( SwPageFrame *pPage = nullptr, bool bPageOnly = false,
                     bool bEndNotes = false );
    void CheckFootnotePageDescs( bool bEndNote );
 
    const SwPageFrame *GetLastPage() const { return mpLastPage; }
          SwPageFrame *GetLastPage()       { return mpLastPage; }
 
    static bool IsInPaint() { return s_isInPaint; }
 
    static void SetNoVirDev(const bool bNew) { s_isNoVirDev = bNew; }
 
    inline tools::Long GetBrowseWidth() const;
    inline void InvalidateBrowseWidth();
 
    bool IsNewLayout() const { return mbIsNewLayout; }
    void ResetNewLayout()    { mbIsNewLayout = false;}
 
    void InsertEmptySct( SwSectionFrame* pDel );
    void DeleteEmptySct() { if( mpDestroy ) DeleteEmptySct_(); }
    void RemoveFromList( SwSectionFrame* pSct ) { if( mpDestroy ) RemoveFromList_( pSct ); }
#ifdef DBG_UTIL
    bool IsInDelList( SwSectionFrame* pSct ) const;
#endif
 
    void SetCallbackActionEnabled( bool b ) { mbCallbackActionEnabled = b; }
    bool IsCallbackActionEnabled() const    { return mbCallbackActionEnabled; }
 
    bool IsAnyShellAccessible() const { return mnAccessibleShells > 0; }
    void AddAccessibleShell() { ++mnAccessibleShells; }
    void RemoveAccessibleShell() { --mnAccessibleShells; }
 
    SwPageFrame* GetPageByPageNum( sal_uInt16 _nPageNum ) const;
 
    void CheckViewLayout( const SwViewOption* pViewOpt, const SwRect* pVisArea );
    bool IsLeftToRightViewLayout() const;
    const SwRect& GetPagesArea() const { return maPagesArea; }
    void SetSidebarChanged() { mbSidebarChanged = true; }
 
    bool IsLayoutFreezed() const { return mbLayoutFreezed; }
    void FreezeLayout( bool freeze ) { mbLayoutFreezed = freeze; }
 
    void RemovePage( SwPageFrame **pDel, SwRemoveResult eResult );
 
    bool IsHideRedlines() const { return mbHideRedlines; }
    void SetHideRedlines(bool);
    sw::FieldmarkMode GetFieldmarkMode() const { return m_FieldmarkMode; }
    void SetFieldmarkMode(sw::FieldmarkMode);
    bool HasMergedParas() const {
        return IsHideRedlines() || GetFieldmarkMode() != sw::FieldmarkMode::ShowBoth;
    }
};
 
inline tools::Long SwRootFrame::GetBrowseWidth() const
{
    if ( !mbBrowseWidthValid )
        const_cast<SwRootFrame*>(this)->ImplCalcBrowseWidth();
    return mnBrowseWidth;
}
 
inline void SwRootFrame::InvalidateBrowseWidth()
{
    if ( mbBrowseWidthValid )
        ImplInvalidateBrowseWidth();
}
 
inline  void SwRootFrame::SetVirtPageNum( const bool bOf) const
{
    const_cast<SwRootFrame*>(this)->mbIsVirtPageNum = bOf;
}
 
class DisableCallbackAction
{
    private:
        SwRootFrame & m_rRootFrame;
        bool m_bOldCallbackActionState;
 
    public:
        explicit DisableCallbackAction(SwRootFrame & rRootFrame)
            : m_rRootFrame(rRootFrame)
            , m_bOldCallbackActionState(rRootFrame.IsCallbackActionEnabled())
        {
            m_rRootFrame.SetCallbackActionEnabled(false);
        }
 
        ~DisableCallbackAction()
        {
            m_rRootFrame.SetCallbackActionEnabled(m_bOldCallbackActionState);
        }
};
 
#endif // INCLUDED_SW_SOURCE_CORE_INC_ROOTFRM_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */