editsh.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_EDITSH_HXX
#define INCLUDED_SW_INC_EDITSH_HXX

#include "crsrsh.hxx"

#include "charfmt.hxx"
#include "fldupde.hxx"
#include "frmfmt.hxx"
#include "swdllapi.h"
#include "swundo.hxx"
#include "tblenum.hxx"
#include "tox.hxx"

#include <memory>
#include <vector>
#include <set>

namespace tools { class PolyPolygon; }
class SwDoc;
class CommandExtTextInputData;

class SvNumberFormatter;
class SfxPoolItem;
class SfxItemSet;
class SfxWatermarkItem;
class SvxAutoCorrect;

class SwDDEFieldType;
class SwDBManager;

struct SwDocStat;
class SwAutoCompleteWord;

class SwFormatRefMark;

class SwNumRule;

class SwTextFormatColl;
class SwGrfNode;

class Graphic;
class GraphicObject;
class GraphicAttr;
class SwFormatINetFormat;
class SwTable;
class SwTextBlocks;
class SwFormatFootnote;
class SwSection;
class SwSectionData;
class SwSectionFormat;
class SwTableAutoFormat;
class SwPageDesc;
class SwTextINetFormat;
class SwSeqFieldList;
class SwGlblDocContent;
class SwGlblDocContents;
class SwRangeRedline;
class SwRedlineData;
class SwFootnoteInfo;
class SwEndNoteInfo;
class SwLineNumberInfo;
class SwAuthEntry;
class SwRewriter;
class SwView;
struct SwConversionArgs;
struct SvxSwAutoFormatFlags;
struct SwInsertTableOptions;
struct SwDBData;
enum class SvtScriptType;
enum class SfxClassificationPolicyType;
enum class RedlineFlags;
enum class TransliterationFlags;
enum class GraphicType;

namespace com::sun::star::uno { template < class > class Sequence; }
namespace com::sun::star::linguistic2 { class XSpellAlternatives; }
namespace com::sun::star::linguistic2 { struct ProofreadingResult; }

namespace svx{
    struct SpellPortion;
    typedef std::vector<SpellPortion> SpellPortions;
    class ClassificationResult;
}

namespace sfx2{
    class LinkManager;
}

namespace sw {
    class UndoRedoContext;
}

enum class ParaBreakType {
    ToBlank = 0,
    ToOnlyCR = 2
};

struct SwGetINetAttr
{
    OUString sText;
    const SwTextINetFormat& rINetAttr;

    SwGetINetAttr( const OUString& rText, const SwTextINetFormat& rAttr )
        : sText( rText ), rINetAttr( rAttr )
    {}
};
typedef std::vector<SwGetINetAttr> SwGetINetAttrs;

// Types of forms of content.
#define CNT_TXT 0x0001
#define CNT_GRF 0x0002
#define CNT_OLE 0x0010

// Test USHORT for a defined form of content.
#define CNT_HasText(USH) ((USH)&CNT_TXT)
#define CNT_HasGrf(USH) ((USH)&CNT_GRF)
#define CNT_HasOLE(USH) ((USH)&CNT_OLE)

class SW_DLLPUBLIC SwEditShell : public SwCursorShell
{
    static SvxSwAutoFormatFlags* s_pAutoFormatFlags;

    friend class SwAutoFormat;
    friend void InitCore();
    friend void FinitCore();
    friend class SwUndo;

    SAL_DLLPRIVATE SwGrfNode *GetGrfNode_() const ;

    SAL_DLLPRIVATE void DeleteSel( SwPaM& rPam, bool* pUndo = nullptr );

    SAL_DLLPRIVATE void SetSectionAttr_( SwSectionFormat& rSectFormat, const SfxItemSet& rSet );

    using SwViewShell::UpdateFields;
    using SwModify::GetInfo;

public:
    void Insert( sal_Unicode, bool bOnlyCurrCursor = false );
    void Insert2( const OUString &, const bool bForceExpandHints = false );
    void Overwrite( const OUString & );

    bool Replace( const OUString& rNewStr, bool bRegExpRplc );

    bool Delete();

    bool DelFullPara();

    void TransliterateText( TransliterationFlags nType );

    void CountWords( SwDocStat& rStat ) const;

    bool ConvertFieldsToText();

    void SetNumberingRestart();

    sal_uInt16 GetLinkUpdMode() const;
    void SetLinkUpdMode( sal_uInt16 nMode );

    bool Copy( SwEditShell* pDestShell );

    bool CopySelToDoc( SwDoc* pInsDoc );

    void SplitNode( bool bAutoFormat = false, bool bCheckTableStart = true );
    bool AppendTextNode();
    void AutoFormatBySplitNode();

    void DelINetAttrWithText();

    bool DontExpandFormat();

    bool GetPaMAttr( SwPaM* pPaM, SfxItemSet& ,
                     const bool bMergeIndentValuesOfNumRule = false ) const;
    bool GetCurAttr( SfxItemSet& ,
                     const bool bMergeIndentValuesOfNumRule = false ) const;
    void SetAttrItem( const SfxPoolItem&, SetAttrMode nFlags = SetAttrMode::DEFAULT,
                     const bool bParagraphSetting = false );
    void SetAttrSet( const SfxItemSet&, SetAttrMode nFlags = SetAttrMode::DEFAULT,
                     SwPaM* pCursor = nullptr, const bool bParagraphSetting = false );

    std::vector<std::pair< const SfxPoolItem*, std::unique_ptr<SwPaM>>> GetItemWithPaM( sal_uInt16 nWhich );

    void GetCurParAttr( SfxItemSet& rSet ) const;
    bool GetPaMParAttr( SwPaM* pPaM, SfxItemSet& rSet ) const;

    void SetDefault( const SfxPoolItem& );

    const SfxPoolItem& GetDefault( sal_uInt16 nFormatHint ) const;
    template<class T> const T&  GetDefault( TypedWhichId<T> nWhich ) const
    {
        return static_cast<const T&>(GetDefault(sal_uInt16(nWhich)));
    }

    void ResetAttr( const std::set<sal_uInt16> &attrs = std::set<sal_uInt16>(), SwPaM* pCursor = nullptr );
    void GCAttr();

    SvtScriptType GetScriptType() const;

    LanguageType GetCurLang() const;

    size_t GetTableFrameFormatCount( bool bUsed = false ) const;
    SwFrameFormat& GetTableFrameFormat(size_t nFormat, bool bUsed = false ) const;
    OUString GetUniqueTableName() const;

    sal_uInt16 GetCharFormatCount() const;
    SwCharFormat& GetCharFormat(sal_uInt16 nFormat) const;
    SwCharFormat* GetCurCharFormat() const;
    void FillByEx(SwCharFormat*);
    SwCharFormat* MakeCharFormat( const OUString& rName );
    SwCharFormat* FindCharFormatByName( const OUString& rName ) const;

    /* FormatCollections (new) - Explaining the general naming pattern:
     * GetXXXCount() returns the count of xxx in the document.
     * GetXXX(i)     returns i-th xxx (ERR_RAISE if beyond range!).
     * DelXXX(i)     deletes i-th xxx  (ERR_RAISE if beyond range!).
     * GetCurXXX()   returns xxx that is valid at cursor or in ranges.
     *               returns 0, if not unanimous.
     * SetXXX()      sets xxx at cursor or in ranges.
     * MakeXXX()     makes a xxx, derived from pDerivedFrom.
     */

    // TXT
    SwTextFormatColl& GetDfltTextFormatColl() const;
    sal_uInt16 GetTextFormatCollCount() const;
    SwTextFormatColl& GetTextFormatColl( sal_uInt16 nTextFormatColl) const;
    SwTextFormatColl* GetCurTextFormatColl() const;
    SwTextFormatColl* GetPaMTextFormatColl( SwPaM* pPaM ) const;

    // #i62675#
    void SetTextFormatColl(SwTextFormatColl*, const bool bResetListAttrs = false);
    SwTextFormatColl *MakeTextFormatColl(const OUString &rFormatCollName,
        SwTextFormatColl *pDerivedFrom = nullptr);
    void FillByEx(SwTextFormatColl*);
    SwTextFormatColl* FindTextFormatCollByName( const OUString& rName ) const;

    SwTextFormatColl* GetTextCollFromPool( sal_uInt16 nId );

    SwFormat* GetFormatFromPool( sal_uInt16 nId );

    SwPageDesc* GetPageDescFromPool( sal_uInt16 nId );

    bool IsUsed( const SwModify& ) const;

    SwFrameFormat* GetFrameFormatFromPool( sal_uInt16 nId )
        { return static_cast<SwFrameFormat*>(SwEditShell::GetFormatFromPool( nId )); }
    SwCharFormat* GetCharFormatFromPool( sal_uInt16 nId )
        { return static_cast<SwCharFormat*>(SwEditShell::GetFormatFromPool( nId )); }

    void SetClassification(const OUString& rName, SfxClassificationPolicyType eType);
    void ApplyAdvancedClassification(std::vector<svx::ClassificationResult> const & rResult);
    std::vector<svx::ClassificationResult> CollectAdvancedClassification();

    SfxWatermarkItem GetWatermark() const;
    void SetWatermark(const SfxWatermarkItem& rText);

    void SignParagraph();

    void ValidateParagraphSignatures(SwTextNode* pNode, bool updateDontRemove);

    void ValidateCurrentParagraphSignatures(bool updateDontRemove);

    void ValidateAllParagraphSignatures(bool updateDontRemove);

    void RestoreMetadataFieldsAndValidateParagraphSignatures();

    void ClassifyDocPerHighestParagraphClass();

    void ApplyParagraphClassification(std::vector<svx::ClassificationResult> aResult);
    std::vector<svx::ClassificationResult> CollectParagraphClassification();

    bool IsCursorInParagraphMetadataField() const;

    bool RemoveParagraphMetadataFieldAtCursor();

    void Insert2(SwField const &, const bool bForceExpandHints);

    void UpdateOneField(SwField &);   

    size_t GetFieldTypeCount(SwFieldIds nResId = SwFieldIds::Unknown) const;
    SwFieldType* GetFieldType(size_t nField, SwFieldIds nResId = SwFieldIds::Unknown) const;
    SwFieldType* GetFieldType(SwFieldIds nResId, const OUString& rName) const;

    void RemoveFieldType(size_t nField);
    void RemoveFieldType(SwFieldIds nResId, const OUString& rName);

    void FieldToText( SwFieldType const * pType );

    void ChangeAuthorityData(const SwAuthEntry* pNewData);

    SwDBData const & GetDBData() const;
    const SwDBData& GetDBDesc() const;
    void ChgDBData(const SwDBData& SwDBData);
    void ChangeDBFields( const std::vector<OUString>& rOldNames,
                         const OUString& rNewName );
    void GetAllUsedDB( std::vector<OUString>& rDBNameList,
                       std::vector<OUString> const * pAllDBNames );

    bool IsAnyDatabaseFieldInDoc()const;

    bool IsFieldDataSourceAvailable(OUString& rUsedDataSource) const;
    void UpdateExpFields(bool bCloseDB = false);
    void LockExpFields();
    void UnlockExpFields();
    bool IsExpFieldsLocked() const;

    SwFieldUpdateFlags GetFieldUpdateFlags() const;
    void SetFieldUpdateFlags( SwFieldUpdateFlags eFlags );

    SwDBManager* GetDBManager() const;

    SwFieldType* InsertFieldType(const SwFieldType &);

    bool IsModified() const;
    void SetModified();
    void ResetModified();
    void SetUndoNoResetModified();

    void UpdateDocStat();
    const SwDocStat &GetUpdatedDocStat();

    void    Insert(const SwTOXMark& rMark);

    void    DeleteTOXMark(SwTOXMark const * pMark);

    void    GetCurTOXMarks(SwTOXMarks& rMarks) const ;

    void                InsertTableOf(const SwTOXBase& rTOX,
                                        const SfxItemSet* pSet = nullptr);
    void                UpdateTableOf(const SwTOXBase& rTOX,
                                        const SfxItemSet* pSet = nullptr);
    const SwTOXBase*    GetCurTOX() const;
    const SwTOXBase*    GetDefaultTOXBase( TOXTypes eTyp, bool bCreate = false );
    void                SetDefaultTOXBase(const SwTOXBase& rBase);

    static bool         IsTOXBaseReadonly(const SwTOXBase& rTOXBase);
    void                SetTOXBaseReadonly(const SwTOXBase& rTOXBase, bool bReadonly);

    sal_uInt16              GetTOXCount() const;
    const SwTOXBase*    GetTOX( sal_uInt16 nPos ) const;
    bool                DeleteTOX( const SwTOXBase& rTOXBase, bool bDelNodes );

    void SetUpdateTOX( bool bFlag );
    bool IsUpdateTOX() const;

    sal_uInt16              GetTOXTypeCount(TOXTypes eTyp) const;
    const SwTOXType*    GetTOXType(TOXTypes eTyp, sal_uInt16 nId) const;
    void                InsertTOXType(const SwTOXType& rTyp);

    OUString const & GetTOIAutoMarkURL() const;
    void            SetTOIAutoMarkURL(const OUString& rSet);
    void            ApplyAutoMark();

    void GetTOIKeys( SwTOIKeyType eTyp, std::vector<OUString>& rArr ) const;

    void SetOutlineNumRule(const SwNumRule&);
    const SwNumRule* GetOutlineNumRule() const;

    bool OutlineUpDown( short nOffset = 1 );

    bool MoveOutlinePara( SwOutlineNodes::difference_type nOffset );

    bool IsProtectedOutlinePara() const;

    const SwNumRule* GetNumRuleAtCurrCursorPos() const;

    const SwNumRule* GetNumRuleAtCurrentSelection() const;

    void SetCurNumRule( const SwNumRule&,
                        const bool bCreateNewList /*= false*/,
                        const OUString& sContinuedListId = OUString(),
                        const bool bResetIndentAttrs = false );

    void NoNum();

    void DelNumRules();

    void NumUpDown( bool bDown = true );

    bool MoveParagraph( long nOffset = 1);
    bool MoveNumParas( bool bUpperLower, bool bUpperLeft );

    bool NumOrNoNum(bool bDelete = false, bool bChkStart = true);

    // #i23726#
    // #i90078#
    // Adjust method name and parameter name
    void ChangeIndentOfAllListLevels( sal_Int32 nDiff );
    // Adjust method name
    void SetIndent(short nIndent, const SwPosition & rPos);
    bool IsFirstOfNumRuleAtCursorPos() const;

    bool IsNoNum( bool bChkStart = true ) const;

    sal_uInt8 GetNumLevel() const;

    void GetCurrentOutlineLevels( sal_uInt8& rUpper, sal_uInt8& rLower );

    int GetCurrentParaOutlineLevel( ) const;

    // i29560
    bool HasNumber() const;
    bool HasBullet() const;

    bool SelectionHasNumber() const;
    bool SelectionHasBullet() const;

    OUString GetUniqueNumRuleName() const;
    void ChgNumRuleFormats( const SwNumRule& rRule );

    void SetNumRuleStart( bool bFlag, SwPaM* pCursor );
    bool IsNumRuleStart( SwPaM* pPaM = nullptr ) const;
    void SetNodeNumStart( sal_uInt16 nStt );

    sal_uInt16 GetNodeNumStart( SwPaM* pPaM ) const;

    void ReplaceNumRule( const OUString& rOldRule, const OUString& rNewRule );

    const SwNumRule * SearchNumRule(const bool bNum,
                                    OUString& sListId );

    void DoUndo( bool bOn = true );
    bool DoesUndo() const;
    void DoGroupUndo( bool bUn );
    bool DoesGroupUndo() const;
    void DelAllUndoObj();

    SwUndoId StartUndo( SwUndoId eUndoId = SwUndoId::EMPTY, const SwRewriter * pRewriter = nullptr );

    SwUndoId EndUndo( SwUndoId eUndoId = SwUndoId::EMPTY, const SwRewriter * pRewriter = nullptr );

    bool     GetLastUndoInfo(OUString *const o_pStr,
                             SwUndoId *const o_pId,
                             const SwView* pView = nullptr) const;
    bool     GetFirstRedoInfo(OUString *const o_pStr,
                              SwUndoId *const o_pId,
                              const SwView* pView = nullptr) const;
    SwUndoId GetRepeatInfo(OUString *const o_pStr) const;

    bool CursorsLocked() const;
    void HandleUndoRedoContext(::sw::UndoRedoContext & rContext);

    void Undo(sal_uInt16 const nCount = 1);
    void Redo(sal_uInt16 const nCount = 1);
    void Repeat(sal_uInt16 const nCount);

    void StartAllAction();
    void EndAllAction();

    virtual void CalcLayout() override;

    sal_uInt16 GetCntType() const;

    bool HasOtherCnt() const;

    virtual void ApplyViewOptions( const SwViewOption &rOpt ) override;

    void GetSelectedText( OUString &rBuf,
                        ParaBreakType nHndlParaBreak = ParaBreakType::ToBlank );

    const Graphic* GetGraphic( bool bWait = true ) const;
    const GraphicObject* GetGraphicObj() const;
    const GraphicAttr* GetGraphicAttr( GraphicAttr& rGA ) const;

    bool IsLinkedGrfSwapOut() const;
    GraphicType GetGraphicType() const;

    const tools::PolyPolygon *GetGraphicPolygon() const;
    void SetGraphicPolygon( const tools::PolyPolygon *pPoly );

    void ClearAutomaticContour();

    bool GetGrfSize(Size&) const;

    void GetGrfNms( OUString* pGrfName, OUString* pFltName,
                    const SwFlyFrameFormat* = nullptr ) const;

    void ReRead( const OUString& rGrfName, const OUString& rFltName,
                  const Graphic* pGraphic = nullptr );

    void    *GetIMapInventor() const;

    // #i73788#
    Graphic GetIMapGraphic() const; 
    const SwFlyFrameFormat* FindFlyByName( const OUString& rName ) const;

    svt::EmbeddedObjectRef&  GetOLEObject() const;

    bool HasOLEObj( const OUString &rName ) const;

    void SetChartName( const OUString &rName );

    void UpdateCharts( const OUString &rName );

    OUString GetCurWord() const;

    void InsertGlossary( SwTextBlocks& rGlossary, const OUString& );

    sal_uInt16 MakeGlossary( SwTextBlocks& rToFill, const OUString& rName,
                         const OUString& rShortName, bool bSaveRelFile,
                         const OUString* pOnlyText );

    sal_uInt16 SaveGlossaryDoc( SwTextBlocks& rGlossary, const OUString& rName,
                            const OUString& rShortName,
                            bool bSaveRelFile,
                            bool bOnlyText );

    // Linguistics...
    void HyphStart( SwDocPositions eStart, SwDocPositions eEnd );

    void HyphEnd();
    css::uno::Reference< css::uno::XInterface>
                HyphContinue( sal_uInt16* pPageCnt, sal_uInt16* pPageSt );

    void HyphIgnore();

    static void InsertSoftHyph( const sal_Int32 nHyphPos );

    const SwTable& InsertTable( const SwInsertTableOptions& rInsTableOpts,  
                                sal_uInt16 nRows, sal_uInt16 nCols,
                                const SwTableAutoFormat* pTAFormat = nullptr );

    void InsertDDETable( const SwInsertTableOptions& rInsTableOpts,  
                         SwDDEFieldType* pDDEType,
                         sal_uInt16 nRows, sal_uInt16 nCols  );

    void UpdateTable();
    void SetTableName( SwFrameFormat& rTableFormat, const OUString &rNewName );

    SwFrameFormat *GetTableFormat();
    bool TextToTable( const SwInsertTableOptions& rInsTableOpts,  
                      sal_Unicode cCh,
                      const SwTableAutoFormat* pTAFormat = nullptr );
    bool TableToText( sal_Unicode cCh );
    bool IsTextToTableAvailable() const;

    bool GetTableBoxFormulaAttrs( SfxItemSet& rSet ) const;
    void SetTableBoxFormulaAttrs( const SfxItemSet& rSet );

    bool IsTableBoxTextFormat() const;
    OUString GetTableBoxText() const;

    TableChgMode GetTableChgMode() const;
    void SetTableChgMode( TableChgMode eMode );

    void SplitTable( SplitTable_HeadlineOption eMode );

    bool CanMergeTable( bool bWithPrev = true, bool* pChkNxtPrv = nullptr ) const;
    bool MergeTable( bool bWithPrev );

    void AppendUndoForInsertFromDB( bool bIsTable );


    void SpellStart( SwDocPositions eStart, SwDocPositions eEnd,
                     SwDocPositions eCurr, SwConversionArgs *pConvArgs = nullptr );

    void SpellEnd( SwConversionArgs const *pConvArgs = nullptr, bool bRestoreSelection = true );
    css::uno::Any SpellContinue(
                    sal_uInt16* pPageCnt, sal_uInt16* pPageSt,
                    SwConversionArgs const *pConvArgs );

    bool SpellSentence(svx::SpellPortions& rToFill, bool bIsGrammarCheck );

    static void PutSpellingToSentenceStart();

    static void MoveContinuationPosToEndOfCheckedSentence();

    void ApplyChangedSentence(const svx::SpellPortions& rNewPortions, bool bRecheck);

    static bool HasLastSentenceGotGrammarChecked();

    static bool HasConvIter();

    static bool HasHyphIter();

    void HandleCorrectionError(const OUString& aText, SwPosition aPos, sal_Int32 nBegin,
                               sal_Int32 nLen, const Point* pPt,
                               SwRect& rSelectRect);
    css::uno::Reference< css::linguistic2::XSpellAlternatives >
            GetCorrection( const Point* pPt, SwRect& rSelectRect );

    bool GetGrammarCorrection( css::linguistic2::ProofreadingResult /*out*/ &rResult,
            sal_Int32 /*out*/ &rErrorPosInText,
            sal_Int32 /*out*/ &rErrorIndexInResult,
            css::uno::Sequence< OUString > /*out*/ &rSuggestions,
            const Point* pPt, SwRect& rSelectRect );

    static void IgnoreGrammarErrorAt( SwPaM& rErrorPosition );
    void SetLinguRange( SwDocPositions eStart, SwDocPositions eEnd );

    const SwFormatRefMark* GetRefMark( const OUString& rName ) const;

    sal_uInt16 GetRefMarks( std::vector<OUString>* = nullptr ) const;

    void AutoCorrect( SvxAutoCorrect& rACorr, bool bInsertMode,
                        sal_Unicode cChar );
    OUString GetPrevAutoCorrWord(SvxAutoCorrect& rACorr);

    // We consider no more than 9 characters before the cursor, and they must not start in the
    // middle of a word (leading spaces are OK)
    std::vector<OUString> GetChunkForAutoText();

    void AutoFormat( const SvxSwAutoFormatFlags* pAFlags );

    static SvxSwAutoFormatFlags* GetAutoFormatFlags();
    static void SetAutoFormatFlags(SvxSwAutoFormatFlags const *);

    OUString Calculate();

    bool InsertURL( const SwFormatINetFormat& rFormat, const OUString& rStr,
                    bool bKeepSelection = false );
    void GetINetAttrs( SwGetINetAttrs& rArr );

    OUString GetDropText( const sal_Int32 nChars ) const;
    void   ReplaceDropText( const OUString &rStr, SwPaM* pPaM = nullptr );

    bool IsOutlineMovable( SwOutlineNodes::size_type nIdx ) const;
    bool IsOutlineCopyable( SwOutlineNodes::size_type nIdx ) const;

    sal_uInt16 GetLineCount();

    bool GetCurFootnote( SwFormatFootnote* pToFillFootnote = nullptr );
    bool SetCurFootnote( const SwFormatFootnote& rFillFootnote );
    bool HasFootnotes( bool bEndNotes = false ) const;

    size_t GetSeqFootnoteList( SwSeqFieldList& rList, bool bEndNotes = false );

    SwSection const* InsertSection(
            SwSectionData & rNewData, SfxItemSet const*const = nullptr );
    bool IsInsRegionAvailable() const;
    const SwSection* GetCurrSection() const;

    SwSection* GetAnySection( bool bOutOfTab = false, const Point* pPt = nullptr );

    size_t GetSectionFormatCount() const;
    size_t GetSectionFormatPos(const SwSectionFormat&) const;
    const SwSectionFormat& GetSectionFormat(size_t nFormat) const;
    void DelSectionFormat( size_t nFormat);
    void UpdateSection( size_t const nSect, SwSectionData &,
            SfxItemSet const*const  = nullptr);
    bool IsAnySectionInDoc() const;

    OUString GetUniqueSectionName( const OUString* pChkStr = nullptr ) const;

    void SetSectionAttr(const SfxItemSet& rSet, SwSectionFormat* pSectFormat = nullptr);

    sal_uInt16 GetFullSelectedSectionCount() const;

    void DoSpecialInsert();
    bool CanSpecialInsert() const;

    void SetNewDoc();

    sfx2::LinkManager& GetLinkManager();
    inline const sfx2::LinkManager& GetLinkManager() const;

    bool IsMoveLeftMargin( bool bRight, bool bModulus = true ) const;
    void MoveLeftMargin( bool bRight, bool bModulus = true );

          SvNumberFormatter* GetNumberFormatter();
    const SvNumberFormatter* GetNumberFormatter() const
    {   return const_cast<SwEditShell*>(this)->GetNumberFormatter();  }

    bool IsGlobalDoc() const;
    void SetGlblDocSaveLinks( bool bFlag );
    bool IsGlblDocSaveLinks() const;
    void GetGlobalDocContent( SwGlblDocContents& rArr ) const;
    void InsertGlobalDocContent( const SwGlblDocContent& rPos,
                                 SwSectionData & rNew );
    bool InsertGlobalDocContent( const SwGlblDocContent& rPos,
                                 const SwTOXBase& rTOX );
    bool InsertGlobalDocContent( const SwGlblDocContent& rPos );
    void DeleteGlobalDocContent( const SwGlblDocContents& rArr,
                                size_t nPos );
    bool MoveGlobalDocContent( const SwGlblDocContents& rArr ,
                                size_t nFromPos, size_t nToPos,
                                size_t nNewPos );
    void GotoGlobalDocContent( const SwGlblDocContent& rPos );

    RedlineFlags GetRedlineFlags() const;
    void SetRedlineFlags( RedlineFlags eMode );
    bool IsRedlineOn() const;
    SwRedlineTable::size_type GetRedlineCount() const;
    const SwRangeRedline& GetRedline( SwRedlineTable::size_type nPos ) const;
    bool AcceptRedline( SwRedlineTable::size_type nPos );
    bool RejectRedline( SwRedlineTable::size_type nPos );
    bool AcceptRedlinesInSelection();
    bool RejectRedlinesInSelection();

    SwRedlineTable::size_type FindRedlineOfData( const SwRedlineData& ) const;

    bool SetRedlineComment( const OUString& rS );
    const SwRangeRedline* GetCurrRedline() const;

    void UpdateRedlineAttr();

    long CompareDoc( const SwDoc& rDoc );

    long MergeDoc( const SwDoc& rDoc );

    const SwFootnoteInfo& GetFootnoteInfo() const;
    void  SetFootnoteInfo(const SwFootnoteInfo& rInfo);
    const SwEndNoteInfo& GetEndNoteInfo() const;
    void  SetEndNoteInfo(const SwEndNoteInfo& rInfo);

    const SwLineNumberInfo &GetLineNumberInfo() const;
    void  SetLineNumberInfo( const SwLineNumberInfo& rInfo);

    void SetLabelDoc( bool bFlag );
    bool IsLabelDoc() const;

    void CreateExtTextInput(LanguageType eInputLanguage);
    OUString DeleteExtTextInput( bool bInsText = true);
    void SetExtTextInputData( const CommandExtTextInputData& );

    bool IsParagraphSignatureValidationEnabled() const { return m_bDoParagraphSignatureValidation; }
    bool SetParagraphSignatureValidation(const bool bEnable)
    {
        const bool bOldFlag = m_bDoParagraphSignatureValidation;
        m_bDoParagraphSignatureValidation = bEnable;
        return bOldFlag;
    }

    static SwAutoCompleteWord& GetAutoCompleteWords();

    sal_uInt16 GetScalingOfSelectedText() const;

    bool IsNbspRunNext() const { return m_bNbspRunNext; }

    SwEditShell( SwDoc&, vcl::Window*, const SwViewOption *pOpt );

    SwEditShell( SwEditShell&, vcl::Window* );
    virtual ~SwEditShell() override;

private:
    SwEditShell(const SwEditShell &) = delete;
    const SwEditShell &operator=(const SwEditShell &) = delete;

    /* TODO: this flag may have to be invalidated / reset to false at various
     * places if it was true and the edit cursor position changes. It's somehow
     * overkill though because it can only be true if a NO-BREAK SPACE was
     * inserted by the last DoAutoCorrect() call (in French language), any
     * subsequent call will reset it anyway and just if the cursor is
     * positioned behind "x :" and the next character inserted is not a space
     * the existing nb-space will be removed. Bear this in mind if that problem
     * arises. */
    bool m_bNbspRunNext;    
    bool m_bDoParagraphSignatureValidation; 
};

inline const sfx2::LinkManager& SwEditShell::GetLinkManager() const
{   return const_cast<SwEditShell*>(this)->GetLinkManager();  }

class SwActContext {
    SwEditShell & m_rShell;
public:
    SwActContext(SwEditShell *pShell);
    ~SwActContext() COVERITY_NOEXCEPT_FALSE;
};

class SwMvContext {
    SwEditShell & m_rShell;
public:
    SwMvContext(SwEditShell *pShell);
    ~SwMvContext() COVERITY_NOEXCEPT_FALSE;
};

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */