shell.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_SFX2_SHELL_HXX
#define INCLUDED_SFX2_SHELL_HXX
 
#include <memory>
#include <rtl/ustring.hxx>
#include <sal/config.h>
#include <sal/types.h>
#include <svl/typedwhich.hxx>
#include <sfx2/dllapi.h>
#include <svl/SfxBroadcaster.hxx>
#include <o3tl/typed_flags_set.hxx>
#include <o3tl/strong_int.hxx>
#include <optional>
 
namespace com::sun::star::embed { struct VerbDescriptor; }
namespace com::sun::star::uno { template <class E> class Sequence; }
 
class SfxItemPool;
class SfxPoolItem;
class SfxRequest;
class SfxItemSet;
class SfxInterface;
class SfxViewShell;
class SfxObjectShell;
 
class SfxShell;
struct SfxShell_Impl;
class SfxDispatcher;
class SfxViewFrame;
class SfxSlot;
class SfxRepeatTarget;
class SfxBindings;
class SfxModule;
class SfxUndoManager;
 
typedef o3tl::strong_int<sal_uInt16, struct SfxInterfaceIdTag> SfxInterfaceId;
 
constexpr auto SFX_INTERFACE_NONE         = SfxInterfaceId(0);
constexpr auto SFX_INTERFACE_SFXAPP       = SfxInterfaceId(1);
constexpr auto SFX_INTERFACE_SFXDOCSH     = SfxInterfaceId(2);
constexpr auto SFX_INTERFACE_SFXVIEWSH    = SfxInterfaceId(3);
constexpr auto SFX_INTERFACE_SFXVIEWFRM   = SfxInterfaceId(4);
constexpr auto SFX_INTERFACE_SFXMODULE    = SfxInterfaceId(5);
constexpr auto SFX_INTERFACE_SC_START     = SfxInterfaceId(150);
constexpr auto SFX_INTERFACE_SD_START     = SfxInterfaceId(200);
constexpr auto SFX_INTERFACE_SW_START     = SfxInterfaceId(250);
constexpr auto SFX_INTERFACE_SMA_START    = SfxInterfaceId(340);
constexpr auto SFX_INTERFACE_IDE_START    = SfxInterfaceId(400);
constexpr auto SFX_INTERFACE_IDE_END      = SfxInterfaceId(409);
 
enum class SfxShellFeature
{
    NONE                    = 0x0000,
    // Writer only, class SwView
    SwChildWindowLabel      = 0x0001,
    // Basic only, class Shell
    BasicShowBrowser        = 0x0004,
    // Forms only, class FmFormShell
    FormShowDatabaseBar     = 0x0008,
    FormShowField           = 0x0010,
    FormShowProperties      = 0x0020,
    FormShowExplorer        = 0x0040,
    FormShowFilterBar       = 0x0080,
    FormShowFilterNavigator = 0x0100,
    FormShowTextControlBar  = 0x0200,
    FormTBControls          = 0x0400,
    FormTBDesign            = 0x1000,
    FormShowDataNavigator   = 0x2000,
    // masks to make sure modules don't use flags from another
    SwMask                  = 0x0001,
    BasicMask               = 0x0004,
    FormMask                = 0x3ff8
};
namespace o3tl
{
    template<> struct typed_flags<SfxShellFeature> : is_typed_flags<SfxShellFeature, 0x37fd> {};
}
 
/* Flags that are being used in the slot definitions for the disable-features */
enum class SfxDisableFlags {
    NONE,
    SwOnProtectedCursor = 0x0001,
    SwOnMailboxEditor   = 0x0002,
};
namespace o3tl {
    template<> struct typed_flags<SfxDisableFlags> : is_typed_flags<SfxDisableFlags, 0x0003> {};
}
 
typedef void (*SfxExecFunc)(SfxShell *, SfxRequest &rReq);
typedef void (*SfxStateFunc)(SfxShell *, SfxItemSet &rSet);
 
class SFX2_DLLPUBLIC SfxShell: public SfxBroadcaster
{
    friend class SfxObjectItem;
 
    std::unique_ptr< SfxShell_Impl >              pImpl;
    SfxItemPool*                pPool;
    SfxUndoManager*             pUndoMgr;
 
private:
                                SfxShell( const SfxShell & ) = delete;
    SfxShell&                                   operator = ( const SfxShell & ) = delete;
 
protected:
    SfxShell();
 
    SfxShell( SfxViewShell *pViewSh );
 
    void SetViewShell_Impl( SfxViewShell* pView );
    SAL_DLLPRIVATE void Invalidate_Impl( SfxBindings& rBindings, sal_uInt16 nId );
    static void HandleOpenXmlFilterSettings(SfxRequest &);
 
public:
 
    virtual                     ~SfxShell() override;
 
    virtual SfxInterface*       GetInterface() const;
    static SfxInterface*        GetStaticInterface() { return nullptr; }
 
    void                        SetName( const OUString &rName );
 
    const OUString&             GetName() const;
 
    SfxViewShell*               GetViewShell() const;
 
    static void                 EmptyExecStub(SfxShell *pShell, SfxRequest &);
    static void                 EmptyStateStub(SfxShell *pShell, SfxItemSet &);
 
    const SfxPoolItem*          GetSlotState( sal_uInt16 nSlotId, const SfxInterface *pIF = nullptr, SfxItemSet *pStateSet = nullptr );
 
    const SfxPoolItem*          ExecuteSlot( SfxRequest &rReq, const SfxInterface *pIF = nullptr );
 
    void                        ExecuteSlot( SfxRequest &rReq, bool bAsync );
 
    inline SfxItemPool&         GetPool() const;
    inline void                 SetPool( SfxItemPool *pNewPool ) ;
 
    virtual SfxUndoManager*     GetUndoManager();
 
    void                        SetUndoManager( SfxUndoManager *pNewUndoMgr );
 
    SfxRepeatTarget*            GetRepeatTarget() const;
 
    void                        SetRepeatTarget( SfxRepeatTarget *pTarget );
 
    virtual void                Invalidate(sal_uInt16 nId = 0);
 
    virtual bool                IsDesignMode() const { return false; };
 
    bool                        IsActive() const;
 
    virtual void                Activate(bool bMDI);
 
    virtual void                Deactivate(bool bMDI);
 
    SfxDispatcher*              GetDispatcher() const;
 
    SfxViewFrame*               GetFrame() const;
 
    virtual bool                HasUIFeature(SfxShellFeature nFeature) const;
    void                        UIFeatureChanged();
 
    // Items
    const SfxPoolItem*          GetItem( sal_uInt16 nSlotId ) const;
    template<class T> const T*  GetItem( TypedWhichId<T> nWhich ) const
    {
        return static_cast<const T*>(GetItem(sal_uInt16(nWhich)));
    }
 
    void                        PutItem( const SfxPoolItem& rItem );
 
    // TODO/CLEANUP: still needed?!
    void SetVerbs(const css::uno::Sequence < css::embed::VerbDescriptor >& aVerbs);
    const css::uno::Sequence < css::embed::VerbDescriptor >& GetVerbs() const;
    void                        VerbExec (SfxRequest&);
    static void                 VerbState (SfxItemSet&);
    SAL_DLLPRIVATE const SfxSlot* GetVerbSlot_Impl(sal_uInt16 nId) const;
 
    virtual SfxObjectShell*     GetObjectShell();
    void                        SetDisableFlags( SfxDisableFlags nFlags );
    SfxDisableFlags             GetDisableFlags() const;
 
    virtual std::optional<SfxItemSet> CreateItemSet( sal_uInt16 nId );
    virtual void                ApplyItemSet( sal_uInt16 nId, const SfxItemSet& rSet );
 
    void SetContextName (const OUString& rsContextName);
 
    void BroadcastContextForActivation (const bool bIsActivated);
 
    bool SetContextBroadcasterEnabled (const bool bIsEnabled);
 
    SAL_DLLPRIVATE bool CanExecuteSlot_Impl( const SfxSlot &rSlot );
 
    virtual bool IsConditionalFastCall( const SfxRequest &rReq );
 
    SAL_DLLPRIVATE void DoActivate_Impl( SfxViewFrame *pFrame, bool bMDI);
 
    SAL_DLLPRIVATE void DoDeactivate_Impl( SfxViewFrame const *pFrame, bool bMDI);
};
 
SfxItemPool& SfxShell::GetPool() const
{
    assert(pPool && "no pool");
    return *pPool;
}
 
inline void SfxShell::SetPool
(
    SfxItemPool*        pNewPool        // Pointer to the new Pool or null
)
{
    pPool = pNewPool;
}
 
#define SFX_DECL_INTERFACE(nId)                                  \
            static SfxInterface*     s_pInterface;                 \
            static SfxInterface*     GetStaticInterface();       \
            static SfxInterfaceId    GetInterfaceId() {return nId;} \
            static void              RegisterInterface(const SfxModule* pMod=nullptr); \
            virtual SfxInterface*    GetInterface() const override;
 
#define SFX_TMPL_INTERFACE(Class,SuperClass,Abstract)                       \
                                                                            \
    SfxInterface* Class::s_pInterface = nullptr;                              \
    SfxInterface* Class::GetStaticInterface()                               \
    {                                                                       \
        if ( !s_pInterface )                                                  \
        {                                                                   \
            s_pInterface =                                                    \
                new SfxInterface(                                           \
            #Class, Abstract, GetInterfaceId(),                             \
            SuperClass::GetStaticInterface(),                               \
            a##Class##Slots_Impl[0],                                        \
            sal_uInt16(sizeof(a##Class##Slots_Impl) / sizeof(SfxSlot) ) );   \
            InitInterface_Impl();                                           \
        }                                                                   \
        return s_pInterface;                                                  \
    }                                                                       \
                                                                            \
    SfxInterface* Class::GetInterface() const                               \
    {                                                                       \
        return GetStaticInterface();                                        \
    }                                                                       \
                                                                            \
    void Class::RegisterInterface(const SfxModule* pMod)                    \
    {                                                                       \
        GetStaticInterface()->Register(pMod);                               \
    }
 
#define SFX_IMPL_INTERFACE(Class,SuperClass)                                \
SFX_TMPL_INTERFACE(Class,SuperClass,false)                                  \
 
#define SFX_IMPL_SUPERCLASS_INTERFACE(Class,SuperClass)                     \
SFX_TMPL_INTERFACE(Class,SuperClass,true)                                   \
 
enum class SfxVisibilityFlags {
    Invisible        = 0x0000, // Never visible
    Viewer           = 0x0040,
    ReadonlyDoc      = 0x0400,
    Standard         = 0x1000,
    FullScreen       = 0x2000,
    Client           = 0x4000,
    Server           = 0x8000,
};
namespace o3tl {
    template<> struct typed_flags<SfxVisibilityFlags> : is_typed_flags<SfxVisibilityFlags, 0xf440> {};
}
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */