Module.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "Object.h"
 
namespace DynExp
{
    class ModuleBase;
    class ModuleInstance;
    class EventListenersBase;
    class QModuleBase;
 
    using ModulePtrType = std::unique_ptr<ModuleBase>;
 
    template <typename ModuleT>
    ConfiguratorBasePtrType MakeModuleConfig()
    {
        return std::make_shared<typename ModuleT::ConfigType>();
    }
 
    template <typename ModuleT>
    ModulePtrType MakeModule(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params)
    {
        dynamic_Params_cast<ModuleT>(Params.get())->ModuleData = std::make_unique<typename ModuleT::ModuleDataType>();
 
        return std::make_unique<ModuleT>(OwnerThreadID, std::move(Params));
    }
 
    int ModuleThreadMain(ModuleInstance Instance, ModuleBase* const Module);
 
    class EventBase
    {
    public:
        EventBase() = default;
        virtual ~EventBase() = 0;
 
        void Invoke(ModuleInstance& Instance) const { InvokeChild(Instance); }
 
    private:
        virtual void InvokeChild(ModuleInstance& Instance) const = 0;       
    };
 
    template <typename ReceiverType, typename ArgTupleType>
    class DefaultEvent : public EventBase
    {
    private:
        template <size_t... Indices>
        struct EventFuncTraits
        {
            constexpr EventFuncTraits() = default;
 
            using EventFuncPtrType = void (ReceiverType::*)(ModuleInstance*, std::tuple_element_t<Indices, ArgTupleType>...) const;
            
            using EventFuncType = Util::CallableMemberWrapper<const ReceiverType, EventFuncPtrType>;
        };
 
        template <size_t... Indices>
        constexpr static auto MakeEventFuncTraits(std::index_sequence<Indices...>) { return EventFuncTraits<Indices...>(); }
 
        using ArgTupleIndexSequenceType = decltype(std::make_index_sequence<std::tuple_size_v<ArgTupleType>>());
        
        using InstantiatedEventFuncTraitsType = decltype(DefaultEvent<ReceiverType, ArgTupleType>::MakeEventFuncTraits(std::declval<ArgTupleIndexSequenceType>()));
 
    public:
        using EventFuncPtrType = typename InstantiatedEventFuncTraitsType::EventFuncPtrType;    
        using EventFuncType = typename InstantiatedEventFuncTraitsType::EventFuncType;          
 
        DefaultEvent(EventFuncType EventFunc) noexcept : EventFunc(EventFunc) {}
 
        virtual ~DefaultEvent() {}
 
    private:
        virtual void InvokeChild(ModuleInstance& Instance) const override { EventFunc(&Instance); }
 
        const EventFuncType EventFunc;
    };
 
    class ModuleDataBase : public Util::ISynchronizedPointerLockable
    {
    public:
        using EventPtrType = std::unique_ptr<EventBase>;
 
        using EventQueueType = std::queue<EventPtrType>;
 
    protected:
        template <typename>
        struct dispatch_tag {};
 
    private:
        class ModuleBaseOnlyType
        {
            friend class ModuleDataBase;
            friend class ModuleBase;
 
            constexpr ModuleBaseOnlyType(ModuleDataBase& Parent) noexcept : Parent(Parent) {}
 
            void Reset() { Parent.Reset(); }                                                
 
            auto& GetNewEventNotifier() noexcept { return Parent.GetNewEventNotifier(); }   
 
            ModuleDataBase& Parent;         
        };
 
        class ModuleThreadOnlyType
        {
            friend class ModuleDataBase;
            friend int ModuleThreadMain(ModuleInstance, ModuleBase* const);
 
            constexpr ModuleThreadOnlyType(ModuleDataBase& Parent) noexcept : Parent(Parent) {}
 
            auto& GetNewEventNotifier() noexcept { return Parent.GetNewEventNotifier(); }                                   
            void SetException(std::exception_ptr ModuleException) noexcept { Parent.ModuleException = ModuleException; }    
 
            ModuleDataBase& Parent;         
        };
 
    public:
        ModuleDataBase() : ModuleBaseOnly(*this), ModuleThreadOnly(*this) {}
        virtual ~ModuleDataBase() {}
 
 
        void EnqueueEvent(EventPtrType&& Event);
        
        EventPtrType PopEvent();
        
        const auto& GetEventFront() const noexcept { return *EventQueue.front().get(); }
 
        auto& GetEventFront() noexcept { return *EventQueue.front().get(); }
 
        size_t GetNumEnqueuedEvents() const noexcept { return EventQueue.size(); }
 
        auto GetException() const noexcept { return ModuleException; }
 
        ModuleBaseOnlyType ModuleBaseOnly;              
        ModuleThreadOnlyType ModuleThreadOnly;          
 
    private:
        Util::OneToOneNotifier& GetNewEventNotifier() noexcept { return NewEventNotifier; }
        
 
        void Reset();
 
        virtual void ResetImpl(dispatch_tag<ModuleDataBase>) {}
 
        EventQueueType EventQueue;
 
        Util::OneToOneNotifier NewEventNotifier;
 
        std::exception_ptr ModuleException;
    };
 
    class ModuleParamsBase : public RunnableObjectParams
    {
        friend class ModuleBase;
 
        template <typename>
        friend ModulePtrType MakeModule(const std::thread::id, ParamsBasePtrType&&);
 
    public:
        ModuleParamsBase(ItemIDType ID, const DynExpCore& Core) : RunnableObjectParams(ID, Core) {}
 
        virtual ~ModuleParamsBase() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "ModuleParamsBase"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<RunnableObjectParams>) override final { ConfigureParamsImpl(dispatch_tag<ModuleParamsBase>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<ModuleParamsBase>) {}         
 
        // Usage parameters may be used in the future also by modules.
        bool ConfigureUsageTypeChild() const noexcept override final { return false; }
 
        std::unique_ptr<ModuleDataBase> ModuleData;
 
        DummyParam Dummy = { *this };                                               
    };
 
    class ModuleConfiguratorBase : public RunnableObjectConfigurator
    {
    public:
        using ObjectType = ModuleBase;
        using ParamsType = ModuleParamsBase;
 
        ModuleConfiguratorBase() = default;
        virtual ~ModuleConfiguratorBase() = 0;
    };
 
    class ModuleBase : public RunnableObject
    {
        class ModuleThreadOnlyType
        {
            friend class ModuleBase;
            friend int ModuleThreadMain(ModuleInstance, ModuleBase* const);
 
            constexpr ModuleThreadOnlyType(ModuleBase& Parent) noexcept : Parent(Parent) {}
 
            void HandleEvent(ModuleInstance& Instance) { Parent.HandleEvent(Instance); }                                                        //<! @copydoc ModuleBase::HandleEvent
            Util::DynExpErrorCodes::DynExpErrorCodes ModuleMainLoop(ModuleInstance& Instance) { return Parent.ExecModuleMainLoop(Instance); }   //<! @copydoc ModuleBase::ExecModuleMainLoop
            void OnPause(ModuleInstance& Instance) { Parent.OnPause(Instance); }                                                                //<! @copydoc ModuleBase::OnPause
            void OnResume(ModuleInstance& Instance) { Parent.OnResume(Instance); }                                                              //<! @copydoc ModuleBase::OnResume
            void OnError(ModuleInstance& Instance) { Parent.OnError(Instance); }                                                                //<! @copydoc ModuleBase::OnError
 
            void SetReasonWhyPaused(std::string Description) { Parent.ModuleSetReasonWhyPaused(std::move(Description)); }                       //<! @copydoc ModuleBase::ModuleSetReasonWhyPaused
 
            ModuleBase& Parent;     
        };
 
        class EventListenersOnlyType
        {
            friend class ModuleBase;
 
            template <typename...>
            friend class TypedEventListeners;
 
            constexpr EventListenersOnlyType(ModuleBase& Parent) noexcept : Parent(Parent) {}
 
            void AddRegisteredEvent(EventListenersBase& EventListeners) const { Parent.AddRegisteredEvent(EventListeners); }                    
            void RemoveRegisteredEvent(EventListenersBase& EventListeners) const { Parent.RemoveRegisteredEvent(EventListeners); }              
 
            ModuleBase& Parent;     
        };
 
    public:
        using ParamsType = ModuleParamsBase;                                                                
        using ConfigType = ModuleConfiguratorBase;                                                          
        
        using ModuleDataType = ModuleDataBase;
 
        using ModuleDataTypeSyncPtrType = Util::SynchronizedPointer<ModuleDataType>;
 
        using ModuleDataTypeSyncPtrConstType = Util::SynchronizedPointer<const ModuleDataType>;
 
        constexpr static auto Category() noexcept { return ""; }
 
        ModuleBase(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);
 
        virtual ~ModuleBase() = 0;
 
        virtual std::string GetCategory() const override { return Category(); }
 
 
        virtual bool HasUI() const noexcept { return false; }
 
        virtual bool TreatModuleExceptionsAsWarnings() const { return true; }
 
        virtual std::chrono::milliseconds GetMainLoopDelay() const { return std::chrono::milliseconds(10); }
 
        static constexpr auto GetModuleDataTimeoutDefault = std::chrono::milliseconds(1000);
 
        ModuleThreadOnlyType ModuleThreadOnly;          
        EventListenersOnlyType EventListenersOnly;      
 
 
        void RestoreWindowStatesFromParams() { RestoreWindowStatesFromParamsChild(); }
 
        void UpdateParamsFromWindowStates() { UpdateParamsFromWindowStatesChild(); }
 
        ModuleDataTypeSyncPtrType GetModuleData(const std::chrono::milliseconds Timeout = GetModuleDataTimeoutDefault);
 
        ModuleDataTypeSyncPtrConstType GetModuleData(const std::chrono::milliseconds Timeout = GetModuleDataTimeoutDefault) const;
 
        void EnqueueEvent(ModuleDataBase::EventPtrType&& Event) const;
 
        template <typename ReceiverType, typename EventType, typename... ArgsTs>
        void MakeAndEnqueueEvent(ReceiverType* Receiver, EventType EventFuncPtr, ArgsTs&& ...Args) const;
 
        using ModuleDataGetterType = Util::CallableMemberWrapper<ModuleBase,
            ModuleDataTypeSyncPtrType (ModuleBase::*)(const std::chrono::milliseconds)>;
 
    private:
 
        ModuleDataTypeSyncPtrType GetNonConstModuleData(const std::chrono::milliseconds Timeout = GetModuleDataTimeoutDefault) const;
 
    protected:
        static auto GetExceptionUnsafe(const ModuleDataTypeSyncPtrConstType& ModuleDataPtr) { return ModuleDataPtr->GetException(); }
 
    private:
 
        void HandleEvent(ModuleInstance& Instance);
 
        void AddRegisteredEvent(EventListenersBase& EventListeners);
 
        void RemoveRegisteredEvent(EventListenersBase& EventListeners);
 
        Util::DynExpErrorCodes::DynExpErrorCodes ExecModuleMainLoop(ModuleInstance& Instance);
 
        void OnPause(ModuleInstance& Instance);
 
        void OnResume(ModuleInstance& Instance);
 
        void OnError(ModuleInstance& Instance);
 
        virtual void OnPauseChild(ModuleInstance& Instance) const {}    
        virtual void OnResumeChild(ModuleInstance& Instance) const {}   
        virtual void OnErrorChild(ModuleInstance& Instance) const {}    
 
        virtual void RestoreWindowStatesFromParamsChild() {}            
        virtual void UpdateParamsFromWindowStatesChild() {}             
 
        virtual Util::DynExpErrorCodes::DynExpErrorCodes ModuleMainLoop(ModuleInstance& Instance) = 0;
 
        void ResetImpl(dispatch_tag<RunnableObject>) override final;
        virtual void ResetImpl(dispatch_tag<ModuleBase>) = 0;           
 
        void ModuleSetReasonWhyPaused(std::string Description) { SetReasonWhyPaused(std::move(Description)); }
 
        void RunChild() override final;
        void NotifyChild() override final;
        void TerminateChild(const std::chrono::milliseconds Timeout) override final;
        std::unique_ptr<BusyDialog> MakeStartupBusyDialogChild(QWidget* ParentWidget) const override final;
 
        std::exception_ptr GetExceptionChild([[maybe_unused]] const std::chrono::milliseconds Timeout) const override final;
        bool IsReadyChild() const override final;
 
 
        virtual void OnInit(ModuleInstance* Instance) const {}
 
        virtual void OnExit(ModuleInstance* Instance) const {}
 
        void OnDeregisterEvents(ModuleInstance* Instance) const;
 
        const std::unique_ptr<ModuleDataType> ModuleData;
 
        std::vector<EventListenersBase*> RegisteredEvents;
    };
 
    template <typename ReceiverType, typename... ArgsTs>
    auto MakeEvent(ReceiverType* Receiver,
        typename DefaultEvent<ReceiverType, std::tuple<std::remove_reference_t<ArgsTs>...>>::EventFuncPtrType EventFuncPtr,
        ArgsTs&& ...Args)
    {
        if (!EventFuncPtr)
            throw Util::InvalidArgException("EventFuncPtr cannot be nullptr.");
 
        // Use EventArgTs instead of std::tuple<ArgsTs...> since the latter would create a tuple of references!
        using EventArgTs = Util::remove_first_from_tuple_t<Util::argument_of_t<decltype(EventFuncPtr)>>;
 
        auto EventFunc = typename DefaultEvent<ReceiverType, EventArgTs>::EventFuncType(*Receiver, EventFuncPtr,
            Util::argument_of_t<decltype(EventFuncPtr)>(nullptr, std::forward<ArgsTs>(Args)...));
 
        return std::make_unique<DefaultEvent<ReceiverType, EventArgTs>>(EventFunc);
    }
 
    template <typename ReceiverType, typename EventType, typename... ArgsTs>
    void ModuleBase::MakeAndEnqueueEvent(ReceiverType* Receiver, EventType EventFuncPtr, ArgsTs&& ...Args) const
    {
        if (Receiver != this)
            throw Util::InvalidArgException("Receiver cannot point to a module different from the instance MakeAndEnqueueEvent() is called on.");
 
        EnqueueEvent(MakeEvent(Receiver, EventFuncPtr, std::forward<ArgsTs>(Args)...));
    }
 
    class ModuleInstance : public RunnableInstance
    {
    public:
        ModuleInstance(ModuleBase& Owner, std::promise<void>&& ThreadExitedPromise,
            const ModuleBase::ModuleDataGetterType ModuleDataGetter);
 
        ModuleInstance(ModuleInstance&& Other);
 
        ~ModuleInstance() = default;
 
        void Exit() noexcept { ShouldExit = true; }
 
        bool IsExiting() const noexcept { return ShouldExit; }
 
        const ModuleBase::ModuleDataGetterType ModuleDataGetter;
 
    private:
        bool ShouldExit = false;
    };
 
    template <typename To, typename From, std::enable_if_t<
        std::is_same_v<ModuleDataBase, std::remove_cv_t<From>>, int> = 0
    >
    auto dynamic_ModuleData_cast(Util::SynchronizedPointer<From>&& ModuleDataPtr)
    {
        if (!ModuleDataPtr)
            throw Util::InvalidArgException("ModuleDataPtr must not be nullptr.");
 
        return Util::SynchronizedPointer<
            std::conditional_t<std::is_const_v<From>, std::add_const_t<typename To::ModuleDataType>, typename To::ModuleDataType>
        >(std::move(ModuleDataPtr));
    }
 
    class EventListenersBase : public Util::ILockable
    {
    protected:
        EventListenersBase() = default;
        virtual ~EventListenersBase() {};
 
    public:
        virtual void Deregister(const ModuleBase& Listener, const std::chrono::milliseconds Timeout = std::chrono::milliseconds(0)) = 0;
    };
 
    template <typename... EventFuncArgs>
    class TypedEventListeners : public EventListenersBase
    {
    public:
        using EventFunctionType = std::function<void(ModuleInstance*, EventFuncArgs...)>;
 
        TypedEventListeners() = default;
        virtual ~TypedEventListeners() = default;
 
        template <typename CallableT>
        void Register(const ModuleBase& Listener, CallableT EventFunc, const std::chrono::milliseconds Timeout = std::chrono::milliseconds(0))
        {
            auto lock = AcquireLock(Timeout);
            RegisterUnsafe(Listener, EventFunc);
        }
 
        virtual void Deregister(const ModuleBase& Listener, const std::chrono::milliseconds Timeout = std::chrono::milliseconds(0)) override
        {
            auto lock = AcquireLock(Timeout);
            DeregisterUnsafe(Listener);
        }
 
        EventFunctionType GetFunc(const ModuleBase& Listener, const std::chrono::milliseconds Timeout = DefaultTimeout) const
        {
            auto lock = AcquireLock(Timeout);
            return GetFuncUnsafe(Listener);
        }
 
    private:
        template <typename CallableT>
        void RegisterUnsafe(const ModuleBase& Listener, CallableT EventFunc) 
        {
            Listeners[&Listener] = [&Listener, EventFunc](ModuleInstance* Instance, EventFuncArgs... Args) {
                (dynamic_cast<std::add_const_t<typename Util::member_fn_ptr_traits<CallableT>::instance_type>&>(Listener).*EventFunc)(Instance, Args...);
            };
 
            Listener.EventListenersOnly.AddRegisteredEvent(*this);
        }
 
        void DeregisterUnsafe(const ModuleBase& Listener)
        {
            auto ListenerIt = Listeners.find(&Listener);
            if (ListenerIt == Listeners.cend())
                return;
 
            Listeners.erase(ListenerIt);
            Listener.EventListenersOnly.RemoveRegisteredEvent(*this);
        }
 
        EventFunctionType GetFuncUnsafe(const ModuleBase& Listener) const
        {
            auto ListenerIt = Listeners.find(&Listener);
            return ListenerIt != Listeners.cend() ? ListenerIt->second : nullptr;
        }
 
        std::unordered_map<const ModuleBase*, EventFunctionType> Listeners;
    };
 
    class InterModuleEventBase : public EventBase
    {
    public:
        InterModuleEventBase() = default;
        virtual ~InterModuleEventBase() = 0;
    };
 
    template <typename DerivedEvent, typename... EventFuncArgs>
    class InterModuleEvent : public InterModuleEventBase
    {
    public:
        using EventListenersType = TypedEventListeners<EventFuncArgs...>;
 
        InterModuleEvent() = default;
        virtual ~InterModuleEvent() {}
 
        template <typename CallableT>
        static void Register(const ModuleBase& Listener, CallableT EventFunc) { Listeners.Register(Listener, EventFunc); }
 
        static void Deregister(const ModuleBase& Listener) { Listeners.Deregister(Listener); }
 
    private:
        virtual void InvokeChild(ModuleInstance& Instance) const override final
        {
            auto EventFunc = Listeners.GetFunc(static_cast<const ModuleBase&>(Instance.GetOwner()));
 
            if (EventFunc)
                InvokeWithParamsChild(Instance, EventFunc);
        }
 
 
        virtual void InvokeWithParamsChild(ModuleInstance& Instance, EventListenersType::EventFunctionType EventFunc) const = 0;
 
        static EventListenersType Listeners;
    };
 
    template <typename DerivedEvent, typename... EventFuncArgs>
    typename InterModuleEvent<DerivedEvent, EventFuncArgs...>::EventListenersType InterModuleEvent<DerivedEvent, EventFuncArgs...>::Listeners;
 
    class QModuleWidget : public QWidget
    {
        Q_OBJECT
 
        friend class QModuleBase;
 
    public:
        constexpr static Qt::WindowFlags GetQtWindowFlagsResizable();
 
        constexpr static Qt::WindowFlags GetQtWindowFlagsNonResizable();
 
        QModuleWidget(QModuleBase& Owner, QWidget* Parent = nullptr);
 
        ~QModuleWidget() = default;
 
        const auto& GetOwner() const noexcept { return Owner; }
 
 
        virtual bool AllowResize() const noexcept { return false; }
 
        Qt::WindowFlags GetQtWindowFlags() const noexcept;
 
        std::string GetDataSaveDirectory() const;
 
        void SetDataSaveDirectory(std::string_view Directory) const;
 
    private:
        void EnableDockWindowShortcut(bool Enable) noexcept;
 
        virtual void closeEvent(QCloseEvent* Event) override;
 
        QModuleBase& Owner;                     
        DynExpManager* DynExpMgr;               
 
        QShortcut* DockWindowShortcut;          
        QShortcut* FocusMainWindowShortcut;     
 
    private slots:
        void OnDockWindow();                    
        void OnFocusWindow();                   
        void OnFocusMainWindow();               
    };
 
    class QModuleDockWidget : public QDockWidget
    {
        Q_OBJECT
 
    public:
        QModuleDockWidget(QModuleBase& Owner, QWidget* Parent, Qt::WindowFlags Flags);
 
        ~QModuleDockWidget() = default;
 
    private:
        virtual void closeEvent(QCloseEvent* Event) override;
 
        virtual void keyPressEvent(QKeyEvent* Event) override;
 
        QModuleBase& Owner;                     
    };
 
    class QModuleDataBase : public ModuleDataBase
    {
    public:
        QModuleDataBase() = default;
        virtual ~QModuleDataBase() = default;
 
    private:
        void ResetImpl(dispatch_tag<ModuleDataBase>) override final;
        virtual void ResetImpl(dispatch_tag<QModuleDataBase>) {};       
    };
 
    class WindowStyleParamsExtension
    {
    public:
        enum WindowStateType { Normal, Minimized, Maximized };
        enum WindowDockingStateType { Docked, Undocked };
        WindowStyleParamsExtension(ParamsBase& Owner, const std::string& Prefix = "")
            : WindowPosX{ Owner, Prefix + "WindowPosX" },
            WindowPosY{ Owner, Prefix + "WindowPosY" },
            WindowWidth{ Owner, Prefix + "WindowWidth" },
            WindowHeight{ Owner, Prefix + "WindowHeight" },
            WindowState{ Owner, Prefix + "WindowState", WindowStateType::Normal },
            WindowDockingState{ Owner, Prefix + "WindowDockingState", WindowDockingStateType::Docked }
        {}
 
        void ApplyTo(QWidget& Widget, bool Show = true) const;
 
        void FromWidget(const QWidget& Widget);
 
        ParamsBase::Param<int> WindowPosX;                              
        ParamsBase::Param<int> WindowPosY;                              
        ParamsBase::Param<unsigned int> WindowWidth;                    
        ParamsBase::Param<unsigned int> WindowHeight;                   
        ParamsBase::Param<WindowStateType> WindowState;                 
        ParamsBase::Param<WindowDockingStateType> WindowDockingState;   
    };
 
    class QModuleParamsBase : public ModuleParamsBase
    {
    public:
        QModuleParamsBase(ItemIDType ID, const DynExpCore& Core)
            : ModuleParamsBase(ID, Core), WindowStyleParams(*this) {}
 
        virtual ~QModuleParamsBase() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "QModuleParamsBase"; }
 
        WindowStyleParamsExtension WindowStyleParams;                           
 
    private:
        void ConfigureParamsImpl(dispatch_tag<ModuleParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<QModuleParamsBase>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<QModuleParamsBase>) {}    
    };
 
    class QModuleConfiguratorBase : public ModuleConfiguratorBase
    {
    public:
        using ObjectType = QModuleBase;
        using ParamsType = QModuleParamsBase;
 
        QModuleConfiguratorBase() = default;
        virtual ~QModuleConfiguratorBase() = 0;
    };
 
    class QModuleBase : public ModuleBase
    {
    public:
        using ParamsType = QModuleParamsBase;                                   
        using ConfigType = QModuleConfiguratorBase;                             
        using ModuleDataType = QModuleDataBase;                                 
 
        QModuleBase(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params);
 
        virtual ~QModuleBase() = 0;
 
        bool HasUI() const noexcept override final { return true; }
 
 
        QAction& InitUI(DynExpManager& DynExpMgr, QMdiArea* const MdiArea);
 
        void HideUI();                      
        void DisableUI();                   
        void UpdateUI();                    
 
        void UpdateModuleWindowFocusAction();
 
        void DockWindow() noexcept;         
        void UndockWindow() noexcept;       
        void DockUndockWindow() noexcept;   
        void SetFocus() noexcept;           
        void FocusMainWindow() noexcept;    
 
        void SendKeyPressEventToMainWindow(QKeyEvent* Event) noexcept;
        
        bool IsWindowDocked() noexcept;
 
        bool IsActiveWindow();
 
    protected:
        template <typename SenderType, typename SignalType, typename ReceiverType, typename EventType>
        void Connect(SenderType* Sender, SignalType Signal, ReceiverType* Receiver, EventType Event);
 
        template <typename WidgetType>
        WidgetType* GetWidget() const;
 
    private:
        virtual void RestoreWindowStatesFromParamsChild() override;
        virtual void UpdateParamsFromWindowStatesChild() override;
 
        void SetWidgetProperties(QWidget* const WindowWidget) const;
 
        void ResetImpl(dispatch_tag<ModuleBase>) override final;
        virtual void ResetImpl(dispatch_tag<QModuleBase>) = 0;  
 
 
        virtual std::unique_ptr<QModuleWidget> MakeUIWidget() = 0;
 
        virtual void UpdateUIChild(const ModuleBase::ModuleDataGetterType& ModuleDataGetter) {}
 
        QModuleWidget* Widget;                                  
        std::unique_ptr<QMdiSubWindow> MdiSubWindow;            
        std::unique_ptr<QModuleDockWidget> DockWidget;          
        std::unique_ptr<QAction> ModuleWindowFocusAction;       
 
        QMdiArea* MdiArea;                                      
    };
 
    template <typename SenderType, typename SignalType, typename ReceiverType, typename EventType>
    void QModuleBase::Connect(SenderType* Sender, SignalType Signal, ReceiverType* Receiver, EventType Event)
    {
        EnsureCallFromOwningThread();
 
        if (!Sender || !Receiver)
            throw Util::InvalidArgException("Sender and Receiver cannot be nullptr.");
 
        // Arguments must not be passed by reference or by pointer to Event since Event is invoked later when
        // references/pointers might not be valid anymore.
        auto Connection = QObject::connect(Sender, Signal, [this, Receiver, Event](auto... Args) {
            try
            {
                MakeAndEnqueueEvent(Receiver, Event, std::move(Args)...);
            }
            catch (const Util::Exception& e)
            {
                Util::EventLog().Log("Posting an event from a module's UI to the module's thread, the error listed below occurred.", Util::ErrorType::Error);
                Util::EventLog().Log(e);
            }
            catch (const std::exception& e)
            {
                Util::EventLog().Log("Posting an event from a module's UI to the module's thread, the error listed below occurred.", Util::ErrorType::Error);
                Util::EventLog().Log(e.what());
            }
            catch (...)
            {
                Util::EventLog().Log("Posting an event from a module's UI to the module's thread, an unknown error occurred.", Util::ErrorType::Error);
            }
        });
 
        if (!Connection)
            throw Util::InvalidArgException("QObject::connect() cannot establish a connection for the given sender and signal types.");
    }
 
    template <typename WidgetType>
    WidgetType* QModuleBase::GetWidget() const
    {
        // EnsureCallFromOwningThread(); considered here, but it also prohibits legitimate calls
        // to thread-safe (probably const) member functions of the widget. Note, accessing the UI
        // objects from another thread than the application's main thread is strongly forbidden!
 
        if (!Widget)
            throw Util::InvalidStateException("UI widget has not been created yet.");
 
        // Throws if it fails.
        return &dynamic_cast<WidgetType&>(*Widget);
    }
}
 
namespace DynExpModule {};