trunk/Common/NsmPluginMain.cpp

#include "NsmPluginMain.h"

#include <vector>

#include <shlwapi.h>
#if defined(_MSC_VER)
#pragma comment(lib, "shlwapi.lib")
#endif

#include "dummy.h"

extern HINSTANCE g_hInstance;

namespace Regnessem
{
        namespace Common
        {
                // NsmPluginMain --------------------------------------------------------------

                NsmPluginMain::NsmPluginMain()
                        :Initialized()
                {
                        PluginInfo[NMPI_APIVER] = NSM_API_VERSION;
                }

                NsmPluginMain::~NsmPluginMain()
                {
                }

                void NsmPluginMain::Initialize(const TNsmPluginInitInfo& initInfo)
                {
                        if(!Initialized)
                        {
                                Initialized = true;
                                InitInfo = initInfo;
                                DoInitialize();
                        }
                }

                void NsmPluginMain::Terminate()
                {
                        if(Initialized)
                        {
                                Initialized = false;
                                DoTerminate();
                        }
                }

                void NsmPluginMain::DoInitialize()
                {
                }

                void NsmPluginMain::DoTerminate()
                {
                }

                tstring NsmPluginMain::GetPluginInfo(int index) const
                {
                        if(0 <= index && index < std::tuple_size<decltype(PluginInfo)>::value)
                                return PluginInfo[index];

                        return tstring();
                }

                void NsmPluginMain::SetPluginInfo(int index,const tstring &value)
                {
                        if(0 <= index && index < std::tuple_size<decltype(PluginInfo)>::value)
                                PluginInfo[index] = value;
                }


                bool NsmPluginMain::IsInitialized() const
                {
                        return Initialized;
                }

                tstring NsmPluginMain::GetDllFileName()
                {
                        std::array<TCHAR, MAX_PATH> buff;
                        GetModuleFileName(g_hInstance, buff.data(), std::tuple_size<decltype(buff)>::value);

                        return buff.data();
                }

                tstring NsmPluginMain::GetWorkDir()
                {
                        const tstring dllPath = GetDllFileName();

                        std::vector<TCHAR> path(dllPath.size() + 2);

#ifdef _MSC_VER
                        dllPath._Copy_s(&path[0], path.size(), dllPath.size());
#else
                        dllPath.copy(&path[0], dllPath.size());
#endif

                        PathRemoveExtension(&path[0]);
                        PathAddBackslash(&path[0]);

                        return &path[0];
                }

                tstring NsmPluginMain::GetIniFileName()
                {
                        const tstring dllName = ExtractFileName(GetDllFileName());

                        std::vector<TCHAR> filename(dllName.size() + 1);
#ifdef _MSC_VER
                        dllName._Copy_s(&filename[0], filename.size(), dllName.size());
#else
                        dllName.copy(&filename[0], dllName.size());
#endif

                        PathRemoveExtension(&filename[0]);

                        return GetWorkDir() + &filename[0] + TEXT(".ini");
                }

                HNsmService NsmPluginMain::CreateNsmService(const tstring &serviceName,const TNsmServiceProc procAddr) const
                {
                        return InitInfo.CreateNsmService(t2c(serviceName).c_str(),procAddr);
                }

                HNsmService NsmPluginMain::GetService(const tstring &serviceName) const
                {
                        return InitInfo.GetService(t2c(serviceName).c_str());
                }

                LONG_PTR NsmPluginMain::CallService(const tstring &serviceName,const WPARAM wParam,const LPARAM lParam) const
                {
                        HNsmService hService = GetService(serviceName);

                        if(hService)
                                return InitInfo.CallService(hService, wParam, lParam);

                        return 0;
                }

                HNsmEvent NsmPluginMain::CreateNsmEvent(const tstring &eventName) const
                {
                        return InitInfo.CreateNsmEvent(t2c(eventName).c_str());
                }

                HNsmEvent NsmPluginMain::GetEvent(const tstring &eventName) const
                {
                        return InitInfo.GetEvent(t2c(eventName).c_str());
                }

                int NsmPluginMain::NotifyEvent(const HNsmEvent eventHandle,const WPARAM wParam,const LPARAM lParam) const
                {
                        return InitInfo.NotifyEvent(eventHandle, wParam, lParam);
                }

                int NsmPluginMain::HookEvent(const tstring &eventName,const TNsmEventProc procAddr) const
                {
                        return InitInfo.HookEvent(t2c(eventName).c_str(), procAddr);
                }

                int NsmPluginMain::UnhookEvent(const tstring &eventName,const TNsmEventProc procAddr) const
                {
                        return InitInfo.UnhookEvent(t2c(eventName).c_str(), procAddr);
                }
        }
}