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 <utility>
#include <vector>
#include <o3tl/sorted_vector.hxx>
 
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 : sal_uInt8;
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( OUString aText, const SwTextINetFormat& rAttr )
        : sText(std::move( aText )), 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 isArtificialSelection, bool* pUndo = nullptr);
 
    SAL_DLLPRIVATE void SetSectionAttr_( SwSectionFormat& rSectFormat, const SfxItemSet& rSet );
 
    using SwViewShell::UpdateFields;
    using sw::BroadcastingModify::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 isArtificialSelection = false);
 
    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& rDestShell );
 
    bool CopySelToDoc( SwDoc& rInsDoc );
 
    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;
    void 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 o3tl::sorted_vector<sal_uInt16> &attrs = o3tl::sorted_vector<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 sw::BroadcastingModify& ) 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();
 
    bool InsertField(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;
    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( SwNodeOffset nOffset = SwNodeOffset(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, sal_uInt16 nOffset = 0);
    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( std::u16string_view 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( std::u16string_view 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 , bool bIncludeInToxContent = true);
 
    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();
 
    tools::Long CompareDoc( const SwDoc& rDoc );
 
    tools::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: */