Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 939 insertions, 0 deletions

diff --git a/include/sfx2/objsh.hxx b/include/sfx2/objsh.hxx
new file mode 100644
index 0000000000..20e497b6e4
--- /dev/null
+++ b/include/sfx2/objsh.hxx
@@ -0,0 +1,939 @@
+/* -*- 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_SFX2_OBJSH_HXX
+#define INCLUDED_SFX2_OBJSH_HXX
+
+#include <sal/config.h>
+#include <sfx2/dllapi.h>
+#include <sfx2/signaturestate.hxx>
+#include <sal/types.h>
+#include <comphelper/errcode.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/frame/XModel3.hpp>
+#include <vcl/bitmapex.hxx>
+
+#include <svl/poolitem.hxx>
+#include <sot/formats.hxx>
+#include <sot/object.hxx>
+#include <tools/gen.hxx>
+#include <tools/link.hxx>
+
+#include <sfx2/shell.hxx>
+#include <comphelper/embeddedobjectcontainer.hxx>
+#include <memory>
+#include <set>
+#include <string_view>
+
+#include <o3tl/typed_flags_set.hxx>
+#include <functional>
+#include <sfx2/AccessibilityIssue.hxx>
+
+namespace weld {class Button; }
+namespace model {class ColorSet; }
+struct NamedColor;
+class SbxValue;
+class SbxArray;
+class BasicManager;
+class SfxMedium;
+class SfxObjectFactory;
+class SfxDocumentInfoDialog;
+class SfxStyleSheetBasePool;
+class StarBASIC;
+class Printer;
+class SvKeyValueIterator;
+class SfxBaseModel;
+class SfxModule;
+class SfxProgress;
+class GDIMetaFile;
+class INetURLObject;
+class IndexBitSet;
+class JobSetup;
+class OutputDevice;
+class Color;
+class Fraction;
+class SvGlobalName;
+class InfobarData;
+class VirtualDevice;
+
+enum class SfxModelFlags;
+enum class SfxEventHintId;
+enum class InfobarType;
+
+// These values presumably must match exactly the corresponding
+// css::embed::Aspects ones (in offapi/com/sun/star/embed/Aspects.idl)
+// and the DVASPECT_* ones in the Win32 API.
+
+#define ASPECT_CONTENT      1
+#define ASPECT_THUMBNAIL    2 /* 120 * 120, 6 Colors DIB in MetaFile */
+#define ASPECT_ICON         4
+#define ASPECT_DOCPRINT     8
+
+namespace sfx2
+{
+    class SvLinkSource;
+    class StyleManager;
+}
+
+namespace com::sun::star::awt { class XWindow; }
+namespace com::sun::star::beans { struct PropertyValue; }
+namespace com::sun::star::document { struct CmisVersion; }
+namespace com::sun::star::document { class XDocumentProperties; }
+namespace com::sun::star::embed { class XStorage; }
+namespace com::sun::star::frame { class XModel; }
+namespace com::sun::star::graphic { class XGraphic; }
+namespace com::sun::star::io { class XStream; }
+namespace com::sun::star::script { class XLibraryContainer; }
+namespace com::sun::star::security { class XCertificate; }
+namespace com::sun::star::security { class XDocumentDigitalSignatures; }
+namespace com::sun::star::security { struct DocumentSignatureInformation; }
+namespace com::sun::star::task { class XInteractionHandler; }
+namespace com::sun::star::lang { class XComponent; }
+namespace com::sun::star::text { class XTextRange; }
+
+namespace sfx2 { class IXmlIdRegistry; }
+
+#define SFX_TITLE_TITLE    0
+#define SFX_TITLE_FILENAME 1
+#define SFX_TITLE_FULLNAME 2
+#define SFX_TITLE_APINAME  3
+#define SFX_TITLE_DETECT   4
+#define SFX_TITLE_CAPTION  5
+#define SFX_TITLE_PICKLIST 6
+#define SFX_TITLE_HISTORY  7
+#define SFX_TITLE_MAXLEN   10   // this gives the limits on length
+
+enum class SfxLoadedFlags
+{
+    NONE         = 0,
+    MAINDOCUMENT = 1,
+    IMAGES       = 2,
+    ALL          = MAINDOCUMENT | IMAGES
+};
+namespace o3tl
+{
+    template<> struct typed_flags<SfxLoadedFlags> : is_typed_flags<SfxLoadedFlags, 0x03> {};
+}
+
+enum class HiddenInformation
+{
+    NONE                  = 0x0000,
+    RECORDEDCHANGES       = 0x0001,
+    NOTES                 = 0x0002,
+    DOCUMENTVERSIONS      = 0x0004
+};
+namespace o3tl
+{
+    template<> struct typed_flags<HiddenInformation> : is_typed_flags<HiddenInformation, 0x07> {};
+}
+
+namespace weld { class Window; }
+
+enum class HiddenWarningFact
+{
+    WhenSaving = 0,
+    WhenPrinting,
+    WhenSigning,
+    WhenCreatingPDF
+};
+
+enum class SfxObjectCreateMode
+{
+    EMBEDDED,
+    STANDARD,
+    ORGANIZER,
+    INTERNAL
+};
+
+/*
+    The class SfxObjectShell is the base class for SFx-objects, ie documents
+    and parts of documents that can be integrated as separate objects
+    into foreign objects.
+    There can be multiple edit windows (SfxViewShell) for one SfxObjectShell.
+*/
+
+struct TransferableObjectDescriptor;
+template<class T> bool checkSfxObjectShell(const SfxObjectShell* pShell)
+{
+    return dynamic_cast<const T*>(pShell) != nullptr;
+}
+
+class SFX2_DLLPUBLIC SfxObjectShell :
+    public SfxShell, virtual public SotObject,
+    public ::comphelper::IEmbeddedHelper
+{
+friend struct ModifyBlocker_Impl;
+friend class SfxObjectShellLock;
+
+private:
+    std::unique_ptr<struct SfxObjectShell_Impl> pImpl;     // internal data
+
+    SfxMedium *                 pMedium;  // Description of the file for example
+                                          // storage that contains the object
+    SfxObjectCreateMode         eCreateMode;      // Purpose of the object
+    bool                        bHasName :1;      // sal_True  := existing object,
+                                                  // sal_False := new object
+    bool                        bIsInGenerateThumbnail; //optimize thumbnail generate and store procedure to improve odt saving performance, i120030
+    bool                        mbAvoidRecentDocs; ///< Avoid adding to the recent documents list, if not necessary.
+    bool                        bRememberSignature; // Do we want to remember the signature.
+
+    enum TriState               {undefined, yes, no};
+    TriState                    mbContinueImportOnFilterExceptions = undefined; // try to import as much as possible
+
+    bool                        CloseInternal();
+
+    SAL_DLLPRIVATE void UpdateTime_Impl(const css::uno::Reference<
+        css::document::XDocumentProperties> & i_xDocProps);
+
+    css::uno::Sequence< css::security::DocumentSignatureInformation > rSignatureInfosRemembered;
+
+    SAL_DLLPRIVATE bool SaveTo_Impl(SfxMedium &rMedium, const SfxItemSet* pSet );
+
+    // true if the document had macros (or similar) on load to trigger warning user
+    SAL_DLLPRIVATE bool  GetHadCheckedMacrosOnLoad() const;
+
+protected:
+                                SfxObjectShell(SfxObjectCreateMode);
+                                SfxObjectShell(SfxModelFlags);    // see sfxmodelfactory.hxx
+    virtual                     ~SfxObjectShell() override;
+
+    void                        ModifyChanged();
+    virtual bool                Close() override;
+
+    /// template method, called by FlushDocInfo; this implementation is empty
+    virtual void                DoFlushDocInfo();
+
+    // helper method
+    void AddToRecentlyUsedList();
+
+    // Parent class for actual guard objects that would do useful work
+    class LockAllViewsGuard
+    {
+    public:
+        virtual ~LockAllViewsGuard() {}
+    };
+
+public:
+                                SFX_DECL_INTERFACE(SFX_INTERFACE_SFXDOCSH)
+
+private:
+    /// SfxInterface initializer.
+    static void InitInterface_Impl();
+
+public:
+    static const css::uno::Sequence<sal_Int8>& getUnoTunnelId();
+    /* Stampit disable/enable cancel button for print jobs
+       default = true = enable! */
+    void                        Stamp_SetPrintCancelState(bool bState);
+    bool                        Stamp_GetPrintCancelState() const;
+
+    static OUString CreateShellID( const SfxObjectShell* pShell );
+
+    // Document-Shell Iterator
+    SAL_WARN_UNUSED_RESULT static SfxObjectShell* GetFirst( const std::function<bool ( const SfxObjectShell* )>& isObjectShell = nullptr,
+                                          bool bOnlyVisible = true );
+    SAL_WARN_UNUSED_RESULT static SfxObjectShell* GetNext( const SfxObjectShell& rPrev,
+                                         const std::function<bool ( const SfxObjectShell* )>& isObjectShell = nullptr,
+                                         bool bOnlyVisible = true );
+    SAL_WARN_UNUSED_RESULT static SfxObjectShell* Current();
+    static css::uno::Reference< css::uno::XInterface >
+                                GetCurrentComponent();
+    static void                 SetCurrentComponent( const css::uno::Reference< css::uno::XInterface >& _rxComponent );
+
+    virtual void                Invalidate(sal_uInt16 nId = 0) override;
+
+    SfxModule*                  GetModule() const;
+
+    virtual SfxObjectFactory&   GetFactory() const=0;
+    SfxMedium *                 GetMedium() const { return pMedium; }
+    css::uno::Reference< css::document::XDocumentProperties >
+                                getDocProperties() const;
+    void                        UpdateDocInfoForSave(  );
+    void                        FlushDocInfo();
+    bool                        HasName() const { return bHasName; }
+    OUString                    GetAPIName() const;
+    void                        SetReadOnly();
+    bool                        IsReadOnly() const;
+    bool                        IsReadOnlyMedium() const;
+    bool                        IsOriginallyReadOnlyMedium() const;
+    bool                        IsOriginallyLoadedReadOnlyMedium() const;
+    void                        SetReadOnlyUI( bool bReadOnly = true );
+    bool                        IsReadOnlyUI() const;
+    void                        SetNoName();
+    bool                        IsInModalMode() const;
+    bool                        IsInPrepareClose() const;
+    bool                        AcceptStateUpdate() const;
+    bool                        IsHelpDocument() const;
+
+    bool                        IsDocShared() const;
+    OUString                    GetSharedFileURL() const;
+    bool                        SwitchToShared( bool bShared, bool bSave );
+    SAL_DLLPRIVATE void         FreeSharedFile( const OUString& aTempFileURL );
+    SAL_DLLPRIVATE void         DoNotCleanShareControlFile();
+    void                        SetSharedXMLFlag( bool bFlag ) const;
+    bool                        HasSharedXMLFlagSet() const;
+
+    SAL_DLLPRIVATE void         SetModalMode_Impl(bool bModal);
+    SAL_DLLPRIVATE void         SetMacroMode_Impl(bool bModal=true);
+
+    void                        ResetError();
+    ErrCodeMsg                  GetErrorIgnoreWarning() const;
+    ErrCodeMsg                  GetErrorCode() const;
+    void                        SetError(const ErrCodeMsg& rErr);
+
+    /**
+     * Initialize bare minimum just enough for unit test runs.
+     *
+     * @return true if the initialization is successful, false otherwise.
+     */
+    void                        DoInitUnitTest();
+    bool                        DoInitNew();
+    bool                        DoLoad( SfxMedium* pMedium );
+    bool                        DoLoadExternal( SfxMedium* pMed );
+    bool                        DoSave();
+    bool                        DoSaveAs( SfxMedium &rNewStor );
+    bool                        DoSaveObjectAs( SfxMedium &rNewStor, bool bCommit );
+
+    // TODO/LATER: currently only overridden in Calc, should be made non-virtual
+    virtual bool                DoSaveCompleted( SfxMedium* pNewStor=nullptr, bool bRegisterRecent=true );
+    /// Terminate any in-flight editing. Used before saving, primarily by Calc to commit cell changes.
+    virtual void                TerminateEditing() {}
+
+    bool                        LoadOwnFormat( SfxMedium& pMedium );
+    virtual bool                SaveAsOwnFormat( SfxMedium& pMedium );
+    virtual bool                ConvertFrom( SfxMedium &rMedium );
+    virtual bool                ConvertTo( SfxMedium &rMedium );
+    virtual bool                InitNew( const css::uno::Reference< css::embed::XStorage >& xStorage );
+    virtual bool                Load( SfxMedium &rMedium  );
+    virtual bool                LoadFrom( SfxMedium& rMedium );
+    virtual bool                Save();
+    virtual bool                SaveAs( SfxMedium &rMedium  );
+    virtual bool                SaveCompleted( const css::uno::Reference< css::embed::XStorage >& xStorage );
+    bool                        SwitchPersistence(
+                                    const css::uno::Reference< css::embed::XStorage >& xStorage );
+    virtual void                UpdateLinks();
+    virtual bool                LoadExternal( SfxMedium& rMedium );
+    bool                        IsConfigOptionsChecked() const;
+    void                        SetConfigOptionsChecked( bool bChecked );
+
+    // called for a few slots like SID_SAVE[AS]DOC, SID_PRINTDOC[DIRECT], derived classes may abort the action
+    virtual bool                QuerySlotExecutable( sal_uInt16 nSlotId );
+
+    void                        SaveChildren(bool bObjectsOnly=false);
+    bool                        SaveAsChildren( SfxMedium &rMedium );
+    bool                        SwitchChildrenPersistence(
+                                    const css::uno::Reference< css::embed::XStorage >& xStorage,
+                                    bool bForceNonModified = false );
+    bool                        SaveCompletedChildren();
+
+    /** a very special case to insert at a position in Writer from UNO,
+        via OwnSubFilterService */
+    virtual bool                InsertGeneratedStream(SfxMedium& rMedium,
+            css::uno::Reference<css::text::XTextRange> const& xInsertPosition);
+    virtual bool                ImportFrom( SfxMedium &rMedium,
+            css::uno::Reference<css::text::XTextRange> const& xInsertPosition);
+    bool                        ExportTo( SfxMedium &rMedium );
+
+    /** Returns true if preparing was successful, else false. */
+    bool PrepareForSigning(weld::Window* pDialogParent);
+    bool CheckIsReadonly(bool bSignScriptingContent, weld::Window* pDialogParent = nullptr);
+    void RecheckSignature(bool bAlsoRecheckScriptingSignature);
+    void AfterSigning(bool bSignSuccess, bool bSignScriptingContent);
+    bool HasValidSignatures() const;
+    SignatureState              GetDocumentSignatureState();
+    bool                        SignDocumentContent(weld::Window* pDialogParent);
+    css::uno::Sequence<css::security::DocumentSignatureInformation> GetDocumentSignatureInformation(
+        bool bScriptingContent,
+        const css::uno::Reference<css::security::XDocumentDigitalSignatures>& xSigner
+        = css::uno::Reference<css::security::XDocumentDigitalSignatures>());
+
+    bool SignDocumentContentUsingCertificate(const css::uno::Reference<css::security::XCertificate>& xCertificate);
+    bool ResignDocument(css::uno::Sequence< css::security::DocumentSignatureInformation >& rSignaturesInfo);
+
+    void SignSignatureLine(weld::Window* pDialogParent, const OUString& aSignatureLineId,
+                           const css::uno::Reference<css::security::XCertificate>& xCert,
+                           const css::uno::Reference<css::graphic::XGraphic>& xValidGraphic,
+                           const css::uno::Reference<css::graphic::XGraphic>& xInvalidGraphic,
+                           const OUString& aComment);
+    SignatureState              GetScriptingSignatureState();
+    bool                        SignScriptingContent(weld::Window* pDialogParent);
+    DECL_DLLPRIVATE_LINK(SignDocumentHandler, weld::Button&, void);
+
+    virtual std::shared_ptr<SfxDocumentInfoDialog> CreateDocumentInfoDialog(weld::Window* pParent, const SfxItemSet& rItemSet);
+
+    ErrCode                     CallBasic( std::u16string_view rMacro, std::u16string_view rBasicName,
+                                    SbxArray* pArgs, SbxValue* pRet = nullptr );
+
+    ErrCode     CallXScript(
+        const OUString& rScriptURL,
+        const css::uno::Sequence< css::uno::Any >& aParams,
+        css::uno::Any& aRet,
+        css::uno::Sequence< sal_Int16 >& aOutParamIndex,
+        css::uno::Sequence< css::uno::Any >& aOutParam,
+        bool bRaiseError = true,
+        const css::uno::Any* aCaller = nullptr );
+
+    static ErrCode  CallXScript(
+        const css::uno::Reference< css::uno::XInterface >& _rxScriptContext,
+        const OUString& rScriptURL,
+        const css::uno::Sequence< css::uno::Any >& aParams,
+        css::uno::Any& aRet,
+        css::uno::Sequence< sal_Int16 >& aOutParamIndex,
+        css::uno::Sequence< css::uno::Any >& aOutParam,
+        bool bRaiseError = true,
+        const css::uno::Any* aCaller = nullptr
+    );
+
+    /** adjusts the internal macro mode, according to the current security settings
+
+        Finally, the macro mode is either NEVER_EXECUTE or ALWAYS_EXECUTE_NO_WARN.
+
+        @return
+            whether macros from this document should be executed
+    */
+    bool                        AdjustMacroMode();
+
+    static bool                 UnTrustedScript(const OUString& rScriptURL);
+
+    static bool                 isScriptAccessAllowed(const css::uno::Reference<css::uno::XInterface>& rScriptContext);
+
+    SvKeyValueIterator*         GetHeaderAttributes();
+    void                        ClearHeaderAttributesForSourceViewHack();
+    void                        SetHeaderAttributesForSourceViewHack();
+
+    bool                        IsQueryLoadTemplate() const;
+    bool                        IsUseUserData() const;
+    bool                        IsUseThumbnailSave() const;
+    bool                        IsLoadReadonly() const;
+    bool                        IsSaveVersionOnClose() const;
+    void                        SetQueryLoadTemplate( bool b );
+    void                        SetUseUserData( bool bNew );
+    void                        SetUseThumbnailSave( bool _bNew );
+    void                        SetLoadReadonly( bool _bReadonly );
+    void                        SetSaveVersionOnClose( bool bSet );
+    void                        ResetFromTemplate( const OUString& rTemplateName, std::u16string_view rFileName );
+
+    // TODO/LATER: the following two methods should be replaced by Get/SetModifPasswordInfo in future
+    sal_uInt32                  GetModifyPasswordHash() const;
+    bool                        SetModifyPasswordHash( sal_uInt32 nHash );
+
+    void                        SetMacroCallsSeenWhileLoading();
+    bool                        GetMacroCallsSeenWhileLoading() const;
+
+    // true if this type of link, from a document, is allowed by the user to be passed to uno:OpenDoc
+    static bool                 AllowedLinkProtocolFromDocument(const OUString& rUrl, SfxObjectShell* pObjShell, weld::Window* pDialogParent);
+
+    const css::uno::Sequence< css::beans::PropertyValue >& GetModifyPasswordInfo() const;
+    bool                        SetModifyPasswordInfo( const css::uno::Sequence< css::beans::PropertyValue >& aInfo );
+
+    static ErrCode              HandleFilter( SfxMedium* pMedium, SfxObjectShell const * pDoc );
+
+    virtual bool                PrepareClose(bool bUI = true);
+    virtual HiddenInformation   GetHiddenInformationState( HiddenInformation nStates );
+    void                        QueryHiddenInformation( HiddenWarningFact eFact );
+    bool                        IsSecurityOptOpenReadOnly() const;
+    void                        SetSecurityOptOpenReadOnly( bool bOpenReadOnly );
+
+    Size                        GetFirstPageSize() const;
+    bool                        DoClose();
+    std::shared_ptr<GDIMetaFile> GetPreviewMetaFile( bool bFullContent = false ) const;
+    BitmapEx                    GetPreviewBitmap() const;
+    virtual void                CancelTransfers();
+
+    bool                        GenerateAndStoreThumbnail(
+                                    bool bEncrypted,
+                                    const css::uno::Reference< css::embed::XStorage >& xStor );
+
+    bool                        WriteThumbnail(
+                                    bool bEncrypted,
+                                    const css::uno::Reference< css::io::XStream >& xStream );
+
+    bool                        IsInGenerateAndStoreThumbnail() const {return bIsInGenerateThumbnail;}//optimize thumbnail generate and store procedure to improve odt saving performance, i120030
+
+    /// Don't add to the recent documents - it's an expensive operation, sometimes it is not wanted.
+    bool                        IsAvoidRecentDocs() const { return mbAvoidRecentDocs; }
+
+    bool                        IsRememberingSignature() const { return bRememberSignature; }
+
+    /// Don't add to the recent documents - it's an expensive operation, sometimes it is not wanted.
+    void                        AvoidRecentDocs(bool bAvoid) { mbAvoidRecentDocs = bAvoid; }
+
+    /// On first error ask user if import should continue; return saved answer.
+    bool                        IsContinueImportOnFilterExceptions();
+
+    // Transfer IFace
+    bool                        IsAbortingImport() const;
+    void                        FinishedLoading( SfxLoadedFlags nWhich = SfxLoadedFlags::ALL );
+
+    void                        TemplateDisconnectionAfterLoad();
+    void                        SetLoading(SfxLoadedFlags nFlags);
+    bool                        IsLoading() const;
+    bool                        IsLoadingFinished() const;
+    void                        SetAutoLoad( const INetURLObject&, sal_uInt32 nTime, bool bReload );
+    bool                        IsAutoLoadLocked() const;
+
+    // Misc
+    bool                        IsPreview() const;
+    SfxObjectCreateMode         GetCreateMode() const { return eCreateMode; }
+    SfxProgress*                GetProgress() const;
+    void                        SetWaitCursor( bool bSet ) const;
+
+    // Naming Interface
+    void                        SetTitle( const OUString& rTitle );
+    /* Small non-zero values of nMaxLen don't mean length, but have a magic meaning:
+       0 (default)
+       the title itself, as it is
+
+       1 (==SFX_TITLE_FILENAME)
+       provides the logical file name without path
+       (under WNT depending on the system settings
+       without extension)
+
+       2 (==SFX_TITLE_FULLNAME)
+       provides the logical file names with full path
+       (remote =>:: com:: sun:: star:: util:: URL)
+
+       3 (==SFX_TITLE_APINAME)
+       provides the logical filename without path
+       and extension
+
+       4 (==SFX_TITLE_DETECT)
+       provides the complete title, if not set yet
+       it will be created from DocInfo or the name of
+       the medium.
+
+       5 (==SFX_TITLE_CAPTION)
+       provides the Title just like MB now in the
+       CaptionBar view
+
+       6 (==SFX_TITLE_PICKLIST)
+       returns the Title, just like MB now would
+       display it in the PickList
+
+       7 (==SFX_TITLE_HISTORY)
+       returns the Title just like MB now would
+       display it in the History
+
+       10 bis USHRT_MAX
+       provides the 'nMaxLength' of the logical
+       file name including the path
+       (remote => css::util::URL)
+    */
+    OUString                    GetTitle( sal_uInt16 nMaxLen = 0 ) const;
+    void                        InvalidateName();  // Re-set to unnamed
+
+#if defined(_WIN32)
+    // DDE-Interface
+    bool                        DdeExecute( const OUString& rCmd );
+    virtual bool                DdeGetData( const OUString& rItem,
+                                            const OUString& rMimeType,
+                                            css::uno::Any & rValue );
+    virtual bool                DdeSetData( const OUString& rItem,
+                                            const OUString& rMimeType,
+                                            const css::uno::Any & rValue );
+#endif
+    virtual ::sfx2::SvLinkSource* DdeCreateLinkSource( const OUString& rItem );
+    virtual void                ReconnectDdeLink(SfxObjectShell& rServer);
+
+    static void                 ReconnectDdeLinks(SfxObjectShell& rServer);
+
+    // Contents
+    virtual SfxStyleSheetBasePool*  GetStyleSheetPool();
+
+    virtual void                LoadStyles(SfxObjectShell &rSource);
+
+    virtual sfx2::StyleManager* GetStyleManager();
+
+    // Determine the position of the "Automatic" filter in the stylist
+    void                        SetAutoStyleFilterIndex(sal_uInt16 nSet);
+    sal_uInt16                  GetAutoStyleFilterIndex() const;
+    bool                        HasBasic() const;
+    BasicManager*               GetBasicManager() const;
+    css::uno::Reference< css::script::XLibraryContainer >
+                                GetBasicContainer();
+    css::uno::Reference< css::script::XLibraryContainer >
+                                GetDialogContainer();
+    StarBASIC*                  GetBasic() const;
+
+    std::optional<NamedColor> GetRecentColor(sal_uInt16 nSlotId);
+    void SetRecentColor(sal_uInt16 nSlotId, const NamedColor& rColor);
+
+    virtual std::set<Color>     GetDocColors();
+    virtual std::shared_ptr<model::ColorSet> GetThemeColors();
+
+    // Accessibility Check
+    virtual sfx::AccessibilityIssueCollection runAccessibilityCheck();
+
+                                // Documents, for which to format the view size
+
+    virtual SfxObjectShell*     GetObjectShell() override;
+
+    css::uno::Reference< css::frame::XModel3 >
+                                GetModel() const;
+    // Only temporarily for the applications!
+    void                        SetBaseModel( SfxBaseModel* pModel );
+    css::uno::Reference< css::frame::XModel3 > GetBaseModel() const;
+    // Only temporarily for the applications!
+
+    virtual css::uno::Sequence< OUString > GetEventNames();
+
+    css::uno::Reference<css::awt::XWindow> GetDialogParent(SfxMedium const* pMedium = nullptr);
+    static SfxObjectShell*      CreateObject( const OUString& rServiceName, SfxObjectCreateMode = SfxObjectCreateMode::STANDARD );
+    static SfxObjectShell*      CreateObjectByFactoryName( const OUString& rURL, SfxObjectCreateMode = SfxObjectCreateMode::STANDARD );
+    static css::uno::Reference< css::lang::XComponent >
+                                CreateAndLoadComponent( const SfxItemSet& rSet );
+    static SfxObjectShell* GetShellFromComponent(const css::uno::Reference< css::uno::XInterface >& xComp);
+    static SfxObjectShell* GetParentShell(const css::uno::Reference<css::uno::XInterface>& xChild);
+    static OUString             GetServiceNameFromFactory( const OUString& rFact );
+    bool                        IsInPlaceActive() const;
+    bool                        IsUIActive() const;
+
+    static bool                 CopyStoragesOfUnknownMediaType(
+                                    const css::uno::Reference< css::embed::XStorage >& xSource,
+                                    const css::uno::Reference<css::embed::XStorage>& xTarget,
+                                    const css::uno::Sequence<OUString>& rExceptions = css::uno::Sequence<OUString>());
+
+    bool isEditDocLocked() const;
+    bool isContentExtractionLocked() const;
+    bool isExportLocked() const;
+    bool isPrintLocked() const;
+    bool isSaveLocked() const;
+
+    // The functions from SvPersist
+    void            EnableSetModified( bool bEnable = true );
+    bool            IsEnableSetModified() const;
+    virtual void    SetModified( bool bModified = true );
+    bool            IsModified() const;
+
+    /**
+     * @param bChart true if the file is a chart doc and FillClass should not be called
+     */
+    void            SetupStorage(
+                        const css::uno::Reference< css::embed::XStorage >& xStorage,
+                        sal_Int32 nVersion, bool bTemplate ) const;
+
+    css::uno::Reference< css::embed::XStorage > const & GetStorage();
+
+    SvGlobalName const & GetClassName() const;
+
+    // comphelper::IEmbeddedHelper
+    virtual css::uno::Reference< css::task::XInteractionHandler > getInteractionHandler() const override;
+    virtual css::uno::Reference < css::embed::XStorage > getStorage() const override
+    {
+        return const_cast<SfxObjectShell*>(this)->GetStorage();
+    }
+    virtual comphelper::EmbeddedObjectContainer& getEmbeddedObjectContainer() const override
+    {
+        return GetEmbeddedObjectContainer();
+    }
+    bool    isEnableSetModified() const override
+    {
+        return IsEnableSetModified();
+    }
+    virtual OUString getDocumentBaseURL() const override;
+
+    comphelper::EmbeddedObjectContainer&    GetEmbeddedObjectContainer() const;
+    void    ClearEmbeddedObjects();
+
+    // The functions from SvEmbeddedObject
+    virtual Printer *       GetDocumentPrinter();
+    virtual OutputDevice*   GetDocumentRefDev();
+    virtual void            OnDocumentPrinterChanged( Printer * pNewPrinter );
+    virtual tools::Rectangle GetVisArea( sal_uInt16 nAspect ) const;
+    virtual void      SetVisArea( const tools::Rectangle & rVisArea );
+    const tools::Rectangle & GetVisArea() const;
+    void              SetVisAreaSize( const Size & rVisSize );
+
+    MapUnit         GetMapUnit() const;
+    void            SetMapUnit( MapUnit nMUnit );
+
+    void            FillTransferableObjectDescriptor( TransferableObjectDescriptor& rDesc ) const;
+    void            DoDraw( OutputDevice *, const Point & rObjPos,
+                            const Size & rSize,
+                            const JobSetup & rSetup,
+                            sal_uInt16 nAspect = ASPECT_CONTENT,
+                            bool bOutputForScreen = false );
+    virtual void    Draw( OutputDevice *, const JobSetup & rSetup,
+                          sal_uInt16 nAspect, bool bOutputForScreen ) = 0;
+
+
+    virtual void    FillClass( SvGlobalName * pClassName,
+                               SotClipboardFormatId * pFormat,
+                               OUString * pFullTypeName,
+                               sal_Int32 nVersion,
+                               bool bTemplate = false) const = 0;
+
+    // change recording and respective passwword protection for Writer and Calc
+    // slots available for Writer:  FN_REDLINE_ON, FN_REDLINE_ON
+    // slots used for Calc:         FID_CHG_RECORD, SID_CHG_PROTECT
+    virtual bool    IsChangeRecording() const;
+    virtual bool    HasChangeRecordProtection() const;
+    virtual void    SetChangeRecording( bool bActivate, bool bLockAllViews = false );
+    virtual void    SetProtectionPassword( const OUString &rPassword );
+    virtual bool    GetProtectionHash( /*out*/ css::uno::Sequence< sal_Int8 > &rPasswordHash );
+
+    static bool IsOwnStorageFormat(const SfxMedium &);
+
+    /** Append Infobar once the frame is ready.
+        Useful when you want to register an Infobar before the doc/frame is fully loaded. */
+    void AppendInfoBarWhenReady(const OUString& sId, const OUString& sPrimaryMessage,
+                                const OUString& sSecondaryMessage, InfobarType aInfobarType,
+                                bool bShowCloseButton = true);
+    std::vector<InfobarData>& getPendingInfobars();
+
+    SAL_DLLPRIVATE bool CreatePreview_Impl(bool bFullContent, VirtualDevice* pDevice, GDIMetaFile* pFile) const;
+
+    SAL_DLLPRIVATE static bool IsPackageStorageFormat_Impl(const SfxMedium &);
+
+    SAL_DLLPRIVATE bool ConnectTmpStorage_Impl( const css::uno::Reference< css::embed::XStorage >& xStorage, SfxMedium* pMedium );
+    SAL_DLLPRIVATE bool DisconnectStorage_Impl( SfxMedium& rSrcMedium, SfxMedium& rTargetMedium );
+
+    SAL_DLLPRIVATE bool PutURLContentsToVersionStream_Impl(
+                    const OUString& aURL,
+                    const css::uno::Reference< css::embed::XStorage >& xDocStorage,
+                    const OUString& aStreamName );
+
+    SAL_DLLPRIVATE OUString CreateTempCopyOfStorage_Impl(
+                    const css::uno::Reference< css::embed::XStorage >& xStorage );
+
+    SAL_DLLPRIVATE void InitOwnModel_Impl();
+    SAL_DLLPRIVATE void BreakMacroSign_Impl( bool bBreakMacroSing );
+    SAL_DLLPRIVATE void CheckSecurityOnLoading_Impl();
+    SAL_DLLPRIVATE void CheckForBrokenDocSignatures_Impl();
+    SAL_DLLPRIVATE void CheckEncryption_Impl( const css::uno::Reference< css::task::XInteractionHandler >& xHandler );
+    SAL_DLLPRIVATE void SetModifyPasswordEntered( bool bEntered = true );
+    SAL_DLLPRIVATE bool IsModifyPasswordEntered() const;
+
+    SAL_DLLPRIVATE void InitBasicManager_Impl();
+    SAL_DLLPRIVATE SfxObjectShell_Impl* Get_Impl() { return pImpl.get(); }
+
+    SAL_DLLPRIVATE static bool UseInteractionToHandleError(
+                    const css::uno::Reference< css::task::XInteractionHandler >& xHandler,
+                    const ErrCodeMsg& nError );
+    SAL_DLLPRIVATE const SfxObjectShell_Impl* Get_Impl() const { return pImpl.get(); }
+
+    SAL_DLLPRIVATE void SetCreateMode_Impl( SfxObjectCreateMode nMode );
+
+    SAL_DLLPRIVATE void DoDraw_Impl( OutputDevice* pDev,
+                                            const Point & rViewPos,
+                                            const Fraction & rScaleX,
+                                            const Fraction & rScaleY,
+                                            const JobSetup & rSetup,
+                                            sal_uInt16 nAspect,
+                                            bool bOutputForScreen );
+
+    // Shell Interface
+    SAL_DLLPRIVATE void ExecFile_Impl(SfxRequest &);
+    SAL_DLLPRIVATE void GetState_Impl(SfxItemSet&);
+    SAL_DLLPRIVATE void PrintExec_Impl(SfxRequest &);
+    SAL_DLLPRIVATE void PrintState_Impl(SfxItemSet&);
+    SAL_DLLPRIVATE void ExecProps_Impl(SfxRequest &);
+    SAL_DLLPRIVATE void StateProps_Impl(SfxItemSet &);
+    SAL_DLLPRIVATE void ExecView_Impl(SfxRequest &);
+    SAL_DLLPRIVATE static void StateView_Impl(SfxItemSet &);
+
+    // Load/Save public internals
+    SAL_DLLPRIVATE bool ImportFromGeneratedStream_Impl(
+                    const css::uno::Reference< css::io::XStream >& xStream,
+                    const css::uno::Sequence< css::beans::PropertyValue >& aMediaDescr );
+    SAL_DLLPRIVATE void UpdateFromTemplate_Impl();
+    SAL_DLLPRIVATE bool CanReload_Impl();
+    SAL_DLLPRIVATE void SetNamedVisibility_Impl();
+    SAL_DLLPRIVATE bool DoSave_Impl( const SfxItemSet* pSet );
+    SAL_DLLPRIVATE bool Save_Impl( const SfxItemSet* pSet );
+    SAL_DLLPRIVATE bool
+    PreDoSaveAs_Impl(const OUString& rFileName, const OUString& rFiltName,
+                     SfxItemSet const& rItemSet,
+                     const css::uno::Sequence<css::beans::PropertyValue>& rArgs);
+    SAL_DLLPRIVATE bool APISaveAs_Impl(std::u16string_view aFileName, SfxItemSet& rItemSet,
+                                       const css::uno::Sequence<css::beans::PropertyValue>& rArgs);
+    SAL_DLLPRIVATE bool
+    CommonSaveAs_Impl(const INetURLObject& aURL, const OUString& aFilterName, SfxItemSet& rItemSet,
+                      const css::uno::Sequence<css::beans::PropertyValue>& rArgs);
+    SAL_DLLPRIVATE bool GeneralInit_Impl(
+                                    const css::uno::Reference< css::embed::XStorage >& xStorage,
+                                    bool bTypeMustBeSetAlready );
+    SAL_DLLPRIVATE void PrepareSecondTryLoad_Impl();
+    SAL_DLLPRIVATE void SetInitialized_Impl( const bool i_fromInitNew );
+
+    // public-internals
+    SAL_DLLPRIVATE IndexBitSet& GetNoSet_Impl();
+    SAL_DLLPRIVATE void SetProgress_Impl( SfxProgress *pProgress );
+    SAL_DLLPRIVATE void PostActivateEvent_Impl( SfxViewFrame const * );
+    SAL_DLLPRIVATE void SetActivateEvent_Impl(SfxEventHintId );
+
+    // configuration items
+    SAL_DLLPRIVATE SignatureState ImplGetSignatureState( bool bScriptingContent = false );
+
+    SAL_DLLPRIVATE bool QuerySaveSizeExceededModules_Impl( const css::uno::Reference< css::task::XInteractionHandler >& xHandler );
+    SAL_DLLPRIVATE static bool QueryAllowExoticFormat_Impl( const css::uno::Reference< css::task::XInteractionHandler >& xHandler,
+                                                     const OUString& rURL,
+                                                     const OUString& rFilterUIName);
+
+    SAL_DLLPRIVATE void CheckOut( );
+    SAL_DLLPRIVATE void CancelCheckOut( );
+    SAL_DLLPRIVATE void CheckIn( );
+    SAL_DLLPRIVATE css::uno::Sequence< css::document::CmisVersion > GetCmisVersions() const;
+
+    /** override this if you have a XmlIdRegistry. */
+    virtual const sfx2::IXmlIdRegistry* GetXmlIdRegistry() const { return nullptr; }
+
+    /// Is this read-only object shell opened via .uno:SignPDF?
+    bool IsSignPDF() const;
+
+    /// Gets the certificate that is already picked by the user but not yet used for signing.
+    css::uno::Reference<css::security::XCertificate> GetSignPDFCertificate() const;
+
+    /// Gets grab-bagged password info to unprotect change tracking with verification
+    css::uno::Sequence< css::beans::PropertyValue > GetDocumentProtectionFromGrabBag() const;
+
+    // Lock all unlocked views, and returns a guard object which unlocks those views when destructed
+    virtual std::unique_ptr<LockAllViewsGuard> LockAllViews()
+    {
+        return std::make_unique<LockAllViewsGuard>();
+    }
+
+};
+
+#define SFX_GLOBAL_CLASSID \
+    0x9eaba5c3, 0xb232, 0x4309, \
+    0x84, 0x5f, 0x5f, 0x15, 0xea, 0x50, 0xd0, 0x74
+
+    struct ModifyBlocker_Impl
+    {
+    private:
+        SfxObjectShell* pPersist;
+        bool bWasEnabled;
+    public:
+        ModifyBlocker_Impl( SfxObjectShell* pPersistP ) : pPersist( pPersistP )
+        {
+            bWasEnabled = pPersistP->IsEnableSetModified();
+            if ( bWasEnabled )
+                pPersistP->EnableSetModified( false );
+        }
+        ~ModifyBlocker_Impl()
+        {
+            if ( bWasEnabled )
+                pPersist->EnableSetModified( bWasEnabled );
+        }
+    };
+
+
+typedef tools::SvRef<SfxObjectShell> SfxObjectShellRef;
+
+class SfxObjectShellLock
+{
+    SfxObjectShell * pObj;
+public:
+    SfxObjectShellLock() { pObj = nullptr; }
+    inline               SfxObjectShellLock( const SfxObjectShellLock & rObj );
+    inline               SfxObjectShellLock( SfxObjectShellLock && rObj ) noexcept;
+    inline               SfxObjectShellLock( SfxObjectShell * pObjP );
+    inline void          Clear();
+    inline               ~SfxObjectShellLock();
+    inline SfxObjectShellLock & operator = ( const SfxObjectShellLock & rObj );
+    inline SfxObjectShellLock & operator = ( SfxObjectShellLock && rObj );
+    inline SfxObjectShellLock & operator = ( SfxObjectShell * pObj );
+    bool                 Is() const { return pObj != nullptr; }
+    SfxObjectShell *     operator &  () const { return pObj; }
+    SfxObjectShell *     operator -> () const { return pObj; }
+    SfxObjectShell &     operator *  () const { return *pObj; }
+    operator SfxObjectShell * () const { return pObj; }
+};
+inline SfxObjectShellLock::SfxObjectShellLock( const SfxObjectShellLock & rObj )
+{
+    pObj = rObj.pObj;
+    if( pObj )
+        pObj->OwnerLock( true );
+}
+inline SfxObjectShellLock::SfxObjectShellLock( SfxObjectShellLock && rObj ) noexcept
+{
+    pObj = rObj.pObj;
+    rObj.pObj = nullptr;
+}
+inline SfxObjectShellLock::SfxObjectShellLock( SfxObjectShell * pObjP )
+{
+    pObj = pObjP;
+    if( pObj )
+        pObj->OwnerLock( true );
+}
+inline void SfxObjectShellLock::Clear()
+{
+    if( pObj )
+    {
+        SfxObjectShell* const pRefObj = pObj;
+        pObj = nullptr;
+        pRefObj->OwnerLock( false );
+    }
+}
+inline SfxObjectShellLock::~SfxObjectShellLock()
+{
+    if( pObj )
+        pObj->OwnerLock( false );
+}
+inline SfxObjectShellLock & SfxObjectShellLock::operator=( const SfxObjectShellLock & rObj )
+{
+    if( rObj.pObj )
+        rObj.pObj->OwnerLock( true );
+    SfxObjectShell* const pRefObj = pObj;
+    pObj = rObj.pObj;
+    if( pRefObj )
+        pRefObj->OwnerLock( false );
+    return *this;
+}
+inline SfxObjectShellLock & SfxObjectShellLock::operator=( SfxObjectShellLock && rObj )
+{
+    if (pObj)
+        pObj->OwnerLock( false );
+    pObj = rObj.pObj;
+    rObj.pObj = nullptr;
+    return *this;
+}
+inline SfxObjectShellLock & SfxObjectShellLock::operator=( SfxObjectShell * pObjP )
+{
+    *this = SfxObjectShellLock( pObjP );
+    return *this;
+}
+
+class SFX2_DLLPUBLIC SfxObjectShellItem final : public SfxPoolItem
+{
+    SfxObjectShell*         pObjSh;
+
+public:
+                            static SfxPoolItem* CreateDefault();
+
+                            SfxObjectShellItem() :
+                                SfxPoolItem( 0 ),
+                                pObjSh( nullptr )
+                            {}
+                            SfxObjectShellItem( sal_uInt16 nWhichId,
+                                                SfxObjectShell *pObjShell ):
+                                SfxPoolItem( nWhichId ),
+                                pObjSh( pObjShell )
+                            {}
+
+    virtual bool            operator==( const SfxPoolItem& ) const override;
+    virtual SfxObjectShellItem* Clone( SfxItemPool *pPool = nullptr ) const override;
+    virtual bool            QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId = 0 ) const override;
+    virtual bool            PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) override;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */