fesh.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_INC_FESH_HXX
#define INCLUDED_SW_INC_FESH_HXX
 
#include <com/sun/star/text/RelOrientation.hpp>
#include <com/sun/star/text/XPasteListener.hpp>
 
#include <svx/svdobj.hxx>
#include "swdllapi.h"
#include "editsh.hxx"
#include "flyenum.hxx"
 
#include <svx/svdtypes.hxx>
#include <sot/formats.hxx>
#include <rtl/ustring.hxx>
#include <o3tl/typed_flags_set.hxx>
#include <comphelper/interfacecontainer3.hxx>
 
#include <vector>
#include <memory>
 
namespace editeng { class SvxBorderLine; }
 
class SwFlyFrame;
class SwTabCols;
class SvxBrushItem;
class SvxFrameDirectionItem;
class SwTableAutoFormat;
class SwFrame;
class SwFormatFrameSize;
class SwFormatRowSplit;
class Outliner;
class SwFrameFormat;
struct SwSortOptions;
class SdrMarkList;
enum class RndStdIds;
 
namespace svx
{
    class ISdrObjectFilter;
}
namespace com::sun::star::embed { class XEmbeddedObject; }
 
// return values for GetFrameType() and GetSelFrameType().
enum class FrameTypeFlags {
    NONE            =     0,
    PAGE            =     1,
    HEADER          =     2,
    FOOTER          =     4,
    BODY            =     8,
    COLUMN          =    16,
    TABLE           =    32,
    FLY_FREE        =    64,
    FLY_ATCNT       =   128,
    FLY_INCNT       =   256,
    FOOTNOTE        =   512,
    FTNPAGE         =  1024,
    FLY_ANY         =  2048,
    DRAWOBJ         =  4096,
    COLSECT         =  8192,
    COLSECTOUTTAB   = 16384
};
namespace o3tl
{
    template<> struct typed_flags<FrameTypeFlags> : is_typed_flags<FrameTypeFlags, 0x7fff> {};
}
 
enum class GotoObjFlags
{
    NONE           =  0,
    DrawControl    =  1,
    DrawSimple     =  2,
    DrawAny        = DrawControl | DrawSimple,
    FlyFrame         =  4,
    FlyGrf         =  8,
    FlyOLE         = 16,
    FlyAny         = FlyOLE | FlyGrf | FlyFrame,
    Any            = FlyAny | DrawAny,
};
namespace o3tl
{
    template<> struct typed_flags<GotoObjFlags> : is_typed_flags<GotoObjFlags, 31> {};
}
 
enum class FlyProtectFlags
{
    NONE         = 0,
    Content      = 1,
    Size         = 2,
    Pos          = 4,
    Parent       = 8,      
    Fixed        = 16,    
};
namespace o3tl
{
    template<> struct typed_flags<FlyProtectFlags> : is_typed_flags<FlyProtectFlags, 31> {};
}
 
// For figuring out contents by position (D&D)
enum ObjCntType
{
    OBJCNT_NONE,
    OBJCNT_FLY,
    OBJCNT_GRF,
    OBJCNT_OLE,
    OBJCNT_SIMPLE,
    OBJCNT_CONTROL,
    OBJCNT_URLBUTTON,
 
    OBJCNT_GROUPOBJ,
    OBJCNT_DONTCARE     
};
 
//For GetAnyCurRect
enum class CurRectType
{
    Page,                 
    PageCalc,             
    PagePrt,              
    Frame,                
    FlyEmbedded,          
    FlyEmbeddedPrt,       
    Section,              
    SectionOutsideTable,  
    SectionPrt,           
    HeaderFooter,         
    PagesArea             
};
 
struct SwGetCurColNumPara
{
    const SwFrameFormat* pFrameFormat;
    const SwRect* pPrtRect;
    SwGetCurColNumPara() : pFrameFormat( nullptr ), pPrtRect( nullptr ) {}
};
 
enum class SwPasteSdr
{
    NONE        = 0,
    Insert      = 1,
    Replace     = 2,
    SetAttr     = 3
};
 
#define SW_ADD_SELECT   1
#define SW_ENTER_GROUP  2
#define SW_LEAVE_FRAME  4
#define SW_ALLOW_TEXTBOX  8
 
enum class SwMove
{
    UP      = 0,
    DOWN    = 1,
    LEFT    = 2,
    RIGHT   = 3
};
 
// return values for WhichMouseTabCol
enum class SwTab
{
    COL_NONE          = 0,
    COL_HORI          = 1,
    COL_VERT          = 2,
    ROW_HORI          = 3,
    ROW_VERT          = 4,
    SEL_HORI          = 5,
    SEL_HORI_RTL      = 6,
    ROWSEL_HORI       = 7,
    ROWSEL_HORI_RTL   = 8,
    COLSEL_HORI       = 9,
    SEL_VERT          = 10,
    ROWSEL_VERT       = 11,
    COLSEL_VERT       = 12
};
 
class SdrDropMarkerOverlay;
struct SwColCache;
 
class SW_DLLPUBLIC SwFEShell : public SwEditShell
{
private:
    mutable std::unique_ptr<SwColCache> m_pColumnCache;
    mutable std::unique_ptr<SwColCache> m_pRowCache;
    std::unique_ptr<SdrDropMarkerOverlay> m_pChainTo;
    std::unique_ptr<SdrDropMarkerOverlay> m_pChainFrom;
    bool m_bCheckForOLEInCaption;
    comphelper::OInterfaceContainerHelper3<css::text::XPasteListener> m_aPasteListeners;
    SwTable::SearchType m_eTableInsertMode;
    bool m_bTableCopied;
 
    SAL_DLLPRIVATE SwFlyFrame *FindFlyFrame( const css::uno::Reference < css::embed::XEmbeddedObject >&  ) const;
 
    SAL_DLLPRIVATE void EndAllActionAndCall();
 
    SAL_DLLPRIVATE void ScrollTo( const Point &rPt );
 
    SAL_DLLPRIVATE void ChangeOpaque( SdrLayerID nLayerId );
 
    SAL_DLLPRIVATE const SwFrame *GetBox( const Point &rPt, bool* pbRow = nullptr, bool* pbCol = nullptr ) const;
 
    // 0 == not in any column.
    SAL_DLLPRIVATE static sal_uInt16 GetCurColNum_( const SwFrame *pFrame,
                          SwGetCurColNumPara* pPara );
 
    SAL_DLLPRIVATE void GetTabCols_(SwTabCols &rToFill, const SwFrame *pBox) const;
    SAL_DLLPRIVATE void GetTabRows_(SwTabCols &rToFill, const SwFrame *pBox) const;
 
    SAL_DLLPRIVATE bool ImpEndCreate();
 
    SAL_DLLPRIVATE bool CopyDrawSel( SwFEShell& rDestShell, const Point& rSttPt,
                                const Point& rInsPt, bool bIsMove,
                                bool bSelectInsert );
 
    SAL_DLLPRIVATE const SdrMarkList* GetMarkList_() const;
 
    SAL_DLLPRIVATE bool CheckHeadline( bool bRepeat ) const;
 
    using SwEditShell::Copy;
 
public:
 
    using SwEditShell::Insert;
 
    SwFEShell( SwDoc& rDoc, vcl::Window *pWin, const SwViewOption *pOpt );
    SwFEShell( SwEditShell& rShell, vcl::Window *pWin );
    virtual ~SwFEShell() override;
 
    void Copy( SwDoc& rClpDoc, const OUString* pNewClpText = nullptr );
    bool Paste( SwDoc& rClpDoc, bool bNestedTable = false );
 
    void PastePages( SwFEShell& rToFill, sal_uInt16 nStartPage, sal_uInt16 nEndPage);
 
    bool Copy( SwFEShell&, const Point& rSttPt, const Point& rInsPt,
               bool bIsMove = false, bool bSelectInsert = true );
 
    void SelectFlyFrame( SwFlyFrame& rFrame );
 
    const SwFrameFormat* IsFlyInFly();
 
    bool SelectObj( const Point& rSelPt, sal_uInt8 nFlag = 0, SdrObject *pObj = nullptr );
    void DelSelectedObj();
 
    void SelectionToTop   ( bool bTop = true );
    void SelectionToBottom( bool bBottom = true );
 
    SdrLayerID GetLayerId() const;   
    void  SelectionToHeaven();  
    void  SelectionToHell();    
 
    bool IsObjSelectable( const Point& rPt );
    SdrObject* GetObjAt(const Point& rPt);
    bool IsInsideSelectedObj( const Point& rPt );    
    bool ShouldObjectBeSelected(const Point& rPt);
 
    bool MoveAnchor( SwMove nDir );
 
    bool IsDirectlyInSection() const;
 
    FrameTypeFlags GetFrameType( const Point *pPt, bool bStopAtFly ) const;
    FrameTypeFlags GetSelFrameType() const;               //Selection (Drawing)
 
    bool IsSelContainsControl() const;
 
    static ObjCntType GetObjCntType( const SdrObject& rObj );
    ObjCntType GetObjCntType( const Point &rPt, SdrObject *&rpObj ) const;
    ObjCntType GetObjCntTypeOfSelection() const;
 
    SwRect  GetObjRect() const;
 
    SwRect  GetFlyRect() const;
    void CalcBoundRect( SwRect& _orRect,
                        const RndStdIds _nAnchorId,
                        const sal_Int16 _eHoriRelOrient = css::text::RelOrientation::FRAME,
                        const sal_Int16 _eVertRelOrient = css::text::RelOrientation::FRAME,
                        const SwFormatAnchor* _pToCharContentPos = nullptr,
                        const bool _bFollowTextFlow = false,
                        bool _bMirror = false,
                        Point* _opRef = nullptr,
                        Size* _opPercent = nullptr,
                        const SwFormatFrameSize* pFormatFrameSize = nullptr ) const;
 
    void SetObjRect( const SwRect& rRect );
 
    void BeginDrag( const Point *pPt, bool bProp );
    void Drag     ( const Point *pPt, bool bProp );
    void EndDrag  ();
    void BreakDrag();
 
    Point GetAnchorObjDiff() const;
    Point GetObjAbsPos()     const;
    Size  GetObjSize()       const;
 
    void GetPageObjs( std::vector<SwFrameFormat*>& rFillArr );
    void SetPageObjsNewPage( std::vector<SwFrameFormat*>& rFillArr );
 
    virtual void MakeSelVisible() override;
 
    const SwFrameFormat* GetFormatFromObj( const Point& rPt, SwRect** pRectToFill = nullptr ) const;
 
    const SwFrameFormat* GetFormatFromAnyObj( const Point& rPt ) const;
 
    FlyProtectFlags IsSelObjProtected( FlyProtectFlags eType ) const;
 
    const Graphic *GetGrfAtPos( const Point &rDocPos,
                                OUString &rName, bool &rbLink ) const;
 
    OUString GetObjTitle() const;
    void SetObjTitle( const OUString& rTitle );
    OUString GetObjDescription() const;
    void SetObjDescription( const OUString& rDescription );
    bool IsObjDecorative() const;
    void SetObjDecorative(bool isDecorative);
 
    bool IsFrameSelected() const;
    bool GetFlyFrameAttr( SfxItemSet &rSet ) const;
    bool SetFlyFrameAttr( SfxItemSet &rSet );
    static SfxItemSetFixed<RES_VERT_ORIENT, RES_ANCHOR> makeItemSetFromFormatAnchor(SfxItemPool& rPool, const SwFormatAnchor &rAnchor);
    void ResetFlyFrameAttr( const SfxItemSet* pSet );
    const SwFrameFormat *NewFlyFrame( const SfxItemSet &rSet, bool bAnchValid = false,
                         SwFrameFormat *pParent = nullptr );
    void SetFlyPos( const Point &rAbsPos);
    Point FindAnchorPos( const Point &rAbsPos, bool bMoveIt = false );
 
    bool IsFrameVertical(const bool bEnvironment, bool& bRightToLeft, bool& bVertL2R) const;
 
    SwFrameFormat* GetSelectedFrameFormat() const; 
    void SetFrameFormat( SwFrameFormat *pFormat, bool bKeepOrient = false, Point const * pDocPos = nullptr ); 
 
    // Get selected fly
    SwFlyFrame* GetSelectedFlyFrame() const;
 
    // Get current fly in which the cursor is positioned
    SwFlyFrame* GetCurrFlyFrame(const bool bCalcFrame = true) const;
 
    // Get selected fly, but if none Get current fly in which the cursor is positioned
    SwFlyFrame* GetSelectedOrCurrFlyFrame() const;
 
    SwFrameFormat* WizardGetFly();
 
    bool GotoNextFly( GotoObjFlags eType = GotoObjFlags::FlyAny )
                                { return GotoObj( true, eType ); }
    bool GotoPrevFly( GotoObjFlags eType = GotoObjFlags::FlyAny)
                                { return GotoObj( false, eType); }
 
    size_t GetFlyCount( FlyCntType eType, bool bIgnoreTextBoxes = false ) const;
    const SwFrameFormat* GetFlyNum(size_t nIdx, FlyCntType eType, bool bIgnoreTextBoxes = false) const;
 
    std::vector<SwFrameFormat const*> GetFlyFrameFormats(
            FlyCntType eType, bool bIgnoreTextBoxes);
 
    const SwFrameFormat* SelFlyGrabCursor();
 
    const SwFrameFormat* GetFlyFrameFormat() const;
          SwFrameFormat* GetFlyFrameFormat();
 
    Size RequestObjectResize( const SwRect &rRect, const css::uno::Reference < css::embed::XEmbeddedObject >& );
 
    virtual void MoveObjectIfActive( svt::EmbeddedObjectRef& xObj, const Point& rOffset );
 
    virtual void CalcAndSetScale( svt::EmbeddedObjectRef& xObj,
                                  const SwRect *pFlyPrtRect = nullptr,
                                  const SwRect *pFlyFrameRect = nullptr,
                                  const bool bNoTextFramePrtAreaChanged = false ) = 0;
 
    virtual void ConnectObj( svt::EmbeddedObjectRef&,
                             const SwRect &rPrt,
                             const SwRect &rFrame ) = 0;
 
    bool IsCheckForOLEInCaption() const         { return m_bCheckForOLEInCaption; }
    void SetCheckForOLEInCaption( bool bFlag )  { m_bCheckForOLEInCaption = bFlag; }
 
    void SetFlyName( const OUString& rName );
    OUString GetFlyName() const;
 
    css::uno::Reference < css::embed::XEmbeddedObject > GetOleRef() const;
 
    OUString GetUniqueGrfName() const;
    OUString GetUniqueOLEName() const;
    OUString GetUniqueFrameName() const;
 
    bool GotoFly( const OUString& rName, FlyCntType eType,
                  bool bSelFrame );
 
    const SwFrameFormat* IsURLGrfAtPos( const Point& rPt, OUString* pURL = nullptr,
                                    OUString *pTargetFrameName = nullptr,
                                    OUString *pURLDescription = nullptr ) const;
 
    SwChainRet Chainable( SwRect &rRect, const SwFrameFormat &rSource, const Point &rPt ) const;
    SwChainRet Chain( SwFrameFormat &rSource, const Point &rPt );
    void       Chain( SwFrameFormat &rSource, const SwFrameFormat &rDest );
    void Unchain( SwFrameFormat &rFormat );
    void HideChainMarker();
    void SetChainMarker();
 
    Size GetGraphicDefaultSize() const;
 
    void CheckUnboundObjects();
 
    bool GetObjAttr( SfxItemSet &rSet ) const;
    void SetObjAttr( const SfxItemSet &rSet );
 
    const SdrObject* GetBestObject(bool bNext, GotoObjFlags eType, bool bFlat = true,
                                   const svx::ISdrObjectFilter* pFilter = nullptr,
                                   bool* pbWrapped = nullptr);
    bool GotoObj( bool bNext, GotoObjFlags eType = GotoObjFlags::DrawAny);
 
    void SetDragMode( SdrDragMode eSdrDragMode );
 
    // Get the current drag mode
    SdrDragMode GetDragMode() const;
 
    // Start cropping the selected image
    void StartCropImage();
 
    // RotGrfFlyFrame: check if RotationMode is possible
    bool IsRotationOfSwGrfNodePossible() const;
 
    size_t IsObjSelected() const;   
    bool IsObjSelected( const SdrObject& rObj ) const;
    bool IsObjSameLevelWithMarked(const SdrObject* pObj) const;
    const SdrMarkList* GetMarkList() const{ return GetMarkList_(); };
 
    void EndTextEdit();             
 
    RndStdIds GetAnchorId() const;
 
    bool BeginCreate( SdrObjKind eSdrObjectKind, const Point &rPos );
    bool BeginCreate( SdrObjKind eSdrObjectKind, SdrInventor eObjInventor, const Point &);
    void MoveCreate ( const Point &rPos );
    bool EndCreate  ( SdrCreateCmd eSdrCreateCmd );
    void BreakCreate();
    bool IsDrawCreate() const;
    void CreateDefaultShape(SdrObjKind eSdrObjectKind, const tools::Rectangle& rRect, sal_uInt16 nSlotId);
 
    bool BeginMark( const Point &rPos );
    void MoveMark ( const Point &rPos );
    bool EndMark  ();
 
    bool IsGroupSelected(bool bAllowDiagams);     
    void GroupSelection();          
    void UnGroupSelection();        
    bool IsGroupAllowed() const;
    bool IsUnGroupAllowed() const;
 
    void MirrorSelection( bool bHorizontal );   
 
    void ChgAnchor( RndStdIds eAnchorId, bool bSameOnly = false,
                                   bool bPosCorr = true );
 
    bool SetDrawingAttr( SfxItemSet &rSet );
 
    bool GetDrawObjGraphic( SotClipboardFormatId nFormat, Graphic& rGrf ) const;
 
    void Paste( SvStream& rStm, SwPasteSdr nAction, const Point* pPt );
    bool Paste( const Graphic &rGrf, const OUString& rURL );
 
    comphelper::OInterfaceContainerHelper3<css::text::XPasteListener>& GetPasteListeners();
 
    bool IsAlignPossible() const;
    void SetCalcFieldValueHdl(Outliner* pOutliner);
 
    void Insert(const OUString& rGrfName,
                const OUString& rFltName,
                const Graphic* pGraphic,
                const SfxItemSet* pFlyAttrSet );
 
    void InsertDrawObj( SdrObject& rDrawObj,
                        const Point& rInsertPosition );
 
    void ReplaceSdrObj( const OUString& rGrfName, const Graphic* pGrf );
 
    // --> #i972#
    void AlignFormulaToBaseline( const css::uno::Reference < css::embed::XEmbeddedObject >& xObj );
 
    void AlignAllFormulasToBaseline();
 
    Point GetContentPos( const Point& rPoint, bool bNext ) const;
 
    Point GetRelativePagePosition(const Point& rDocPos);
 
    void ShellLoseFocus();
    void ShellGetFocus();
 
    void   ChgCurPageDesc( const SwPageDesc& );
    size_t GetCurPageDesc( const bool bCalcFrame = true ) const;
    size_t GetMousePageDesc( const Point &rPt ) const;
    size_t GetPageDescCnt() const;
    SwPageDesc* FindPageDescByName( const OUString& rName,
                                    bool bGetFromPool = false,
                                    size_t* pPos = nullptr );
 
    const SwPageDesc& GetPageDesc( size_t i ) const;
    void  ChgPageDesc( size_t i, const SwPageDesc& );
    const SwPageDesc* GetSelectedPageDescs() const;
 
    const SwRect& GetAnyCurRect( CurRectType eType,
                                 const Point* pPt = nullptr,
                                 const css::uno::Reference < css::embed::XEmbeddedObject >& =
                                 css::uno::Reference < css::embed::XEmbeddedObject >() ) const;
 
    sal_uInt16 GetPageNumber( const Point &rPoint ) const;
    bool GetPageNumber( tools::Long nYPos, bool bAtCursorPos, sal_uInt16& rPhyNum, sal_uInt16& rVirtNum, OUString &rDisplay ) const;
 
    SwFlyFrameFormat* InsertObject( const svt::EmbeddedObjectRef&,
                SfxItemSet* pFlyAttrSet );
    bool    FinishOLEObj(); 
 
    void GetTableAttr( SfxItemSet & ) const;
    void SetTableAttr( const SfxItemSet & );
 
    bool HasWholeTabSelection() const;
 
    bool HasBoxSelection() const;
 
    void InsertRow( sal_uInt16 nCnt, bool bBehind );
    void InsertCol( sal_uInt16 nCnt, bool bBehind );  // 0 == at the end.
    bool DeleteCol();
    void DeleteTable();
    bool DeleteRow(bool bCompleteTable = false);
 
    SwTable::SearchType GetTableInsertMode() const         { return m_eTableInsertMode; }
    void SetTableInsertMode( SwTable::SearchType eFlag )  { m_eTableInsertMode = eFlag; }
 
    bool GetTableCopied() const { return m_bTableCopied; }
    void SetTableCopied( bool bCopied )  { m_bTableCopied = bCopied; }
 
    bool DeleteTableSel();        
 
    TableMergeErr MergeTab();          
    void SplitTab( bool bVert, sal_uInt16 nCnt, bool bSameHeight );
    bool Sort(const SwSortOptions&);    // sorting
 
    void SetRowHeight( const SwFormatFrameSize &rSz );
 
    std::unique_ptr<SwFormatFrameSize> GetRowHeight() const;
 
    void SetRowSplit( const SwFormatRowSplit &rSz );
    std::unique_ptr<SwFormatRowSplit> GetRowSplit() const;
 
    void   SetBoxAlign( sal_uInt16 nOrient );
    sal_uInt16 GetBoxAlign() const;         
 
    bool BalanceRowHeight( bool bTstOnly, const bool bOptimize = false );
 
    void SetTabBorders( const SfxItemSet& rSet );
    void GetTabBorders(       SfxItemSet& rSet) const;
    void SetTabLineStyle(const Color* pColor, bool bSetLine = false, const editeng::SvxBorderLine* pBorderLine = nullptr);
 
    void SetTabBackground( const SvxBrushItem &rNew );
    void GetTabBackground( std::unique_ptr<SvxBrushItem>& rToFill ) const;
 
    void SetBoxBackground( const SvxBrushItem &rNew );
    bool GetBoxBackground( std::unique_ptr<SvxBrushItem>& rToFill ) const; 
 
    void SetBoxDirection( const SvxFrameDirectionItem& rNew );
    bool GetBoxDirection( std::unique_ptr<SvxFrameDirectionItem>& rToFill ) const; 
 
    void SetRowBackground( const SvxBrushItem &rNew );
    bool GetRowBackground( std::unique_ptr<SvxBrushItem>& rToFill ) const; 
 
    SwTab WhichMouseTabCol( const Point &rPt ) const;
    void GetTabCols( SwTabCols &rToFill ) const; 
    void SetTabCols( const SwTabCols &rNew, bool bCurRowOnly );
    void GetMouseTabCols( SwTabCols &rToFill, const Point &rPt ) const;
    void SetMouseTabCols( const SwTabCols &rNew, bool bCurRowOnly,
                          const Point &rPt );
 
    bool SelTableRowCol( const Point& rPt, const Point* pEnd, bool bRowDrag );
 
    void GetTabRows( SwTabCols &rToFill ) const;
    void SetTabRows( const SwTabCols &rNew, bool bCurColOnly );
    void GetMouseTabRows( SwTabCols &rToFill, const Point &rPt ) const;
    void SetMouseTabRows( const SwTabCols &rNew, bool bCurColOnly, const Point &rPt );
 
    void ProtectCells();    
    void UnProtectCells();  
    void UnProtectTables();   
    bool HasTableAnyProtection( const OUString* pTableName,
                              bool* pFullTableProtection );
    bool CanUnProtectCells() const;
 
    sal_uInt16 GetRowsToRepeat() const;
    void SetRowsToRepeat( sal_uInt16 nNumOfRows );
    sal_uInt16 GetVirtPageNum() const;
 
    sal_uInt16    GetRowSelectionFromTop() const;
 
    bool IsInRepeatedHeadline() const { return CheckHeadline( true ); }
    bool IsInHeadline() const { return CheckHeadline( false ); }
 
    void AdjustCellWidth( const bool bBalance, const bool bNoShrink );
 
    bool IsAdjustCellWidthAllowed( bool bBalance = false ) const;
 
    void SetTableStyle(const OUString& rStyleName);
    bool SetTableStyle(const SwTableAutoFormat& rNew);
 
    bool UpdateTableStyleFormatting(SwTableNode *pTableNode = nullptr, bool bResetDirect = false, OUString const* pStyleName = nullptr);
 
    bool GetTableAutoFormat( SwTableAutoFormat& rGet );
 
    void SetColRowWidthHeight( TableChgWidthHeightType eType, sal_uInt16 nDiff );
 
    void GetAutoSum( OUString& rFormula ) const;
 
    sal_uInt16  GetPhyPageNum() const;
 
    void SetNewPageOffset( sal_uInt16 nOffset );
    void SetPageOffset( sal_uInt16 nOffset );   
    sal_uInt16 GetPageOffset() const;           
 
    void InsertLabel( const SwLabelType eType, const OUString &rText, const OUString& rSeparator,
                      const OUString& rNumberSeparator,
                      const bool bBefore, const sal_uInt16 nId,
                      const OUString& rCharacterStyle,
                      const bool bCpyBrd );
 
    sal_uInt16 GetCurColNum( SwGetCurColNumPara* pPara = nullptr ) const; //0 == not in any column.
    sal_uInt16 GetCurMouseColNum( const Point &rPt ) const;
    size_t GetCurTabColNum() const;     //0 == not in any table.
    size_t GetCurMouseTabColNum( const Point &rPt ) const;
    sal_uInt16 GetCurOutColNum() const;  
 
    bool IsColRightToLeft() const;
    bool IsTableRightToLeft() const;
    bool IsMouseTableRightToLeft( const Point &rPt ) const;
    bool IsTableVertical() const;
 
    bool IsLastCellInRow() const;
 
    tools::Long GetSectionWidth( SwFormat const & rFormat ) const;
 
    void GetConnectableFrameFormats
    (SwFrameFormat & rFormat, const OUString & rReference, bool bSuccessors,
     std::vector< OUString > & aPrevPageVec,
     std::vector< OUString > & aThisPageVec,
     std::vector< OUString > & aNextPageVec,
     std::vector< OUString > & aRestVec);
 
    Color GetShapeBackground() const;
 
    bool IsShapeDefaultHoriTextDirR2L() const;
 
    void ParkCursorInTab();
 
    SwTextNode * GetNumRuleNodeAtPos(const Point &rPot);
    bool IsNumLabel( const Point &rPt, int nMaxOffset = -1 );
 
    static bool IsVerticalModeAtNdAndPos( const SwTextNode& _rTextNode,
                                   const Point& _rDocPos );
 
    void ToggleHeaderFooterEdit( );
    static void SetLineEnds(SfxItemSet& rAttr, SdrObject const & rObj, sal_uInt16 nSlotId);
 
    SAL_DLLPRIVATE void ClearColumnRowCache(SwTabFrame const*);
};
 
void ClearFEShellTabCols(SwDoc & rDoc, SwTabFrame const*const pFrame);
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */