ModuleManager.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#if defined(_WIN32)
// On Windows, NDEVR commands use the stdcall convention
#define NDEVRAPI_ATTR
#define NDEVRAPI_CALL __stdcall
#define NDEVRAPI_PTR  NDEVRAPI_CALL
#elif !QT_BUILD && defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
#error "NDEVR isn't supported for the 'armeabi' NDK ABI"
#elif !QT_BUILD && defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
// On Android 32-bit ARM targets, NDEVR functions use the "hardfloat"
// calling convention, i.e. float parameters are passed in registers. This
// is true even if the rest of the application passes floats on the stack,
// as it does by default when compiling for the armeabi-v7a NDK ABI.
#define NDEVRAPI_ATTR __attribute__((pcs("aapcs-vfp")))
#define NDEVRAPI_CALL
#define NDEVRAPI_PTR  VKAPI_ATTR
#else
// On other platforms, use the default calling convention
#define NDEVRAPI_ATTR
#define NDEVRAPI_CALL
#define NDEVRAPI_PTR
#endif
#include <NDEVR/SoftwareService.h>
#include <NDEVR/String.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/File.h>
#include <NDEVR/TranslatedString.h>
typedef void (NDEVRAPI_PTR* PFN_NDEVRVoidFunction)(void);
namespace NDEVR
{
    struct Module;
    class QTModelManager;
    class QTWindowManager;
    class Exception;
    class ModuleResourceManager;
}
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_InitializeForNDEVR)(NDEVR::Module& module);//InitializeForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupRegistrationForNDEVR)();//SetupRegistrationForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupMetatypesForNDEVR)();//SetupMetatypesForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_RegisterUserSettingsForNDEVR)();//RegisterUserSettingsForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupFileStructureForNDEVR)();//SetupFileStructureForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupFactoriesForNDEVR)();//SetupFileStructureForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetUpdateCheckerForNDEVR)();//SetupFileStructureForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupManualsForNDEVR)();//SetupManualsForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_SetupUIThemesForNDEVR)();//SetupUIThemesForNDEVR
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_FactoryResetNDEVR)();//FactoryReset
typedef void(*PFN_SetupUIForNDEVR)(NDEVR::QTModelManager* model_manager, NDEVR::QTWindowManager* window_manager);
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_DefineModuleResourcesForNDEVR)(NDEVR::ModuleResourceManager* resources);
typedef PFN_NDEVRVoidFunction(NDEVRAPI_PTR* PFN_OnNDEVRExit)();//
 
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Base class for extensions, typically added as external DLL's that can modify or enhance the
        behavior of the software.
    **/
    struct NDEVR_BASE_API Module : public SoftwareService
    {
        enum ModuleType : uint04
        {
              e_application
            , e_utility
            , e_library_dependency
            , e_undefined
        };
        mutable Dictionary<String, void*> loaded_functions;
        String name;
        String version;
        File library;
        TranslatedString display_name;
        String icon;
        TranslatedString description;
        String license_agreement;
        String website;
        String activation_id;
        bool allow_user_toggle_active = false;
        bool is_active = true;
        ModuleType type = ModuleType::e_undefined;
        Module();
        Module(const String& name);
        Module(const String& name, const File& library);
        bool isValid() const;
        void initialize();
        void callModuleFunction(const String& function) const;
        void callModuleFunction(const String& function, QTModelManager* model_manager, QTWindowManager* window_manager) const;
        void defineModuleResources(ModuleResourceManager* resources) const;
    protected:
        void* module_ptr = nullptr;
    };
    
    /**--------------------------------------------------------------------------------------------------
    \brief Logic for the program-wide storage and execution of Modules. Called in software setup
        to allow modules to perform actions to modify or enhance the software.
    **/
    class NDEVR_BASE_API ModuleManager : public SoftwareServiceManager
    {
    public:
        static File MainModuleFolder();
        static void SetMainProgramModuleName(const String& name);
        static void FindModules(const File& module_folder);
        static void FindModules(const Buffer<String>& module_list, const File& module_folder);
        static void FindModules(const File& module_list, const File& module_folder);
        static void AddModule(const File& module_file);
        static void CallModuleFunction(const String& function);
        static void CallModuleFunction(const String& function, QTModelManager* model_manager, QTWindowManager* window_manager);
        static void DefineModuleResources(const String& module_name, ModuleResourceManager* resources);
        static void AddModule(const Module& module);
        static void SaveModuleSettings();
        static void SetupModuleRegistration();
        static void OnExit();
        static bool HasActiveModule(const String& module_name);
        static bool IsModuleActive(const String& module_name);
        static void ReadModuleSettings();
        static void SetErrorCallback(const std::function<void(const Exception& e)>& callback);
        static void* LoadDynamicLibrary(const String& library);
        static void* LoadFromDynamicLibrary(void* library, const String& function);
        static void* LoadFromDynamicLibrary(const String& library, const String& function);
        static Buffer<String> ordered_modules;
        static Dictionary<String, Module> modules;
        static Dictionary<String, bool> module_active_list;
        static Dictionary<String, Dictionary<String, void*>> functions;
        static String main_program_module_name;
    };
    template class NDEVR_BASE_API StringStream<Module::ModuleType>;
}