StrRsc/src/StrRsc.cpp

#include "StrRsc.h"

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

#include "../../Common/dummy.h"
#include "../../Common/tstring.h"
#include "../../Common/StrResource.h"

#include "OptionDlg.h"
#include "StrRscConsts.h"

HINSTANCE g_hInstance;

namespace Regnessem
{
        namespace AddIn
        {
                namespace StrRsc
                {
                        StrRscMain g_strRscMain;

                        StrRscMain::StrRscMain()
                        {
                                SetPluginInfo(NMPI_APIVER               , NMP_INFO_APIVER);
                                SetPluginInfo(NMPI_MODULENAME   , NMP_INFO_MODULENAME);
                                SetPluginInfo(NMPI_TITLE                , NMP_INFO_TITLE);
                                SetPluginInfo(NMPI_DESCRIPTION  , NMP_INFO_DESCRIPTION);
                                SetPluginInfo(NMPI_AUTHOR               , NMP_INFO_AUTHOR);
                                SetPluginInfo(NMPI_COPYRIGHT    , NMP_INFO_COPYRIGHT);
                                SetPluginInfo(NMPI_PLUGINVER    , NMP_INFO_PLUGINVER);
                        }

                        // úť
                        void StrRscMain::DoInitialize()
                        {
                                IniFiles.clear();
                                g_StrResource.reset(new StrResource(InitInfo));
                                Config.LoadFromFile(GetIniFileName());

                                // T[rXĚo^
                                CreateNsmService(NMS_ADDIN_STRRSC_GETLOCALSTR, StrRscService::DoGetLocalStr);
                                CreateNsmService(NMS_ADDIN_STRRSC_SHOWOPTIONDIALOG, StrRscService::DoShowOptionDialog);

                                ChangeLangEvent = CreateNsmEvent(NME_ADDIN_STRRSC_CHANGELANGUAGE);
                        }

                        // IvV_CAO\Ś
                        INT_PTR StrRscMain::DoShowOptionDialog(HWND parent)
                        {
                                OptionDlg dlg;
                                dlg.Locale = Config.Locale;

                                INT_PTR result = dlg.ShowOptionDialog(parent);

                                if(result == IDOK && dlg.Locale != Config.Locale)
                                {
                                        Config.Locale = dlg.Locale;
                                        Config.SaveToFile(GetIniFileName());
                                        // OnChangeLanguageCxgĘm
                                        NotifyEvent(ChangeLangEvent, 0, 0);
                                }

                                return result;
                        }

                        void StrRscMain::RegisterIniFile(const tstring &pluginName)
                        {
                                std::array<TCHAR, MAX_PATH> exePath;
                                GetModuleFileName(NULL, exePath.data(), std::tuple_size<decltype(exePath)>::value);

                                const tstring filePath = ExtractFilePath(exePath.data())
                                        + TEXT("Plugins\\StrRsc\\Language\\")
                                        + Config.Locale + TEXT('\\')
                                        + pluginName + TEXT(".txt");

                                if(PathFileExists(filePath.c_str()))
                                        IniFiles.insert(std::make_pair(pluginName, filePath));
                        }

                        // žęt@CŠçśńćž
                        int StrRscMain::DoGetLocalStr(const NsmStrRsc &strRsc)
                        {
                                if(!strRsc.lpDefaultStr || !strRsc.lpMessageTag || !strRsc.lpPluginName || !strRsc.lpSectionName)
                                        return 0;

                                if(strRsc.nBufferSize < 1)
                                        return 0;

                                const tstring pluginName = c2t(strRsc.lpPluginName);

                                IniFilesTable::const_iterator it = IniFiles.find(pluginName);

                                if(it == IniFiles.end())
                                {
                                        RegisterIniFile(pluginName);
                                        it = IniFiles.find(pluginName);

                                        if(it == IniFiles.end())
                                        {
                                                StrToStrRsc(strRsc, c2t(strRsc.lpDefaultStr));

                                                return 0;
                                        }
                                }

                                std::vector<TCHAR> buff(strRsc.nBufferSize);
                                GetPrivateProfileString(
                                        c2t(strRsc.lpSectionName).c_str(),
                                        c2t(strRsc.lpMessageTag).c_str(),
                                        c2t(strRsc.lpDefaultStr).c_str(),
                                        &buff[0], static_cast<DWORD>(buff.size()), (*it).second.c_str());

                                if(!StrToStrRsc(strRsc, &buff[0]))
                                        return 0;

                                return 1;
                        }

                        // String->StrRsc ĎˇÖ
                        int StrRscMain::StrToStrRsc(const NsmStrRsc &strRsc, const tstring &source)
                        {
                                if(!strRsc.lpBuffer)
                                        return 0;

                                if(strRsc.nBufferSize < 1)
                                        return 0;

                                std::string tmp = t2c(source);

                                std::string::size_type len = std::min<std::string::size_type>(strRsc.nBufferSize - 1, tmp.size());

                                tmp.resize(len);

                                strcpy_s(strRsc.lpBuffer, strRsc.nBufferSize, tmp.c_str());

                                return static_cast<int>(len);
                        }

                        // ----------------------------------------------------------------------------

                        // T[rXÖ

                        LONG_PTR __stdcall StrRscService::DoShowOptionDialog(const WPARAM wParam, const LPARAM /* lParam */)
                        {
                                return g_strRscMain.DoShowOptionDialog(reinterpret_cast<HWND>(wParam));
                        }

                        LONG_PTR __stdcall StrRscService::DoGetLocalStr(const WPARAM wParam, const LPARAM /* lParam */)
                        {
                                if(!wParam)
                                        return 0;

                                return g_strRscMain.DoGetLocalStr(*reinterpret_cast<NsmStrRsc*>(wParam));
                        }
                }
        }
}

BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID /*lpvReserved*/)
{
        g_hInstance = hinstDLL;

        switch(fdwReason)
        {
        case DLL_PROCESS_ATTACH:
                break;
        case DLL_PROCESS_DETACH:
                break;
        case DLL_THREAD_ATTACH:
                break;
        case DLL_THREAD_DETACH:
                break;
        }

        return TRUE;
}

extern "C"
{
        // vOCÉÖˇéîńđÔˇ
        //
        // nInfoNo  : ćžľ˝˘îńĚÔ
        // lpBuffer : îńđi[ˇéobt@
        // nSize    : obt@ĚTCY
        //
        // Return   : ŔŰÉŤńžîńĚTCY
        //            nInfoNo ŞłřČç 0
        int WINAPI GetPluginInfo(const int nInfNo, LPSTR lpBuffer, const int nSize)
        {
                if(!lpBuffer)
                        return 0;

                if(nSize < 1)
                        return 0;

                std::string result = t2c(Regnessem::AddIn::StrRsc::g_strRscMain.GetPluginInfo(nInfNo));

                if(result.empty())
                        return 0;

                std::string::size_type len = std::min<std::string::size_type>(nSize-1, result.size());

                result.resize(len);
                strcpy_s(lpBuffer, nSize, result.c_str());

                return static_cast<int>(len);
        }

        // vOCĚúť
        //
        // lpPluginInitInfo   : vOCúťîń
        //
        // Return   : G[R[h
        int WINAPI Initialize(const Regnessem::PNsmPluginInitInfo lpNsmInitInfo)
        {
                if(!lpNsmInitInfo)
                        return Regnessem::NsmPluginState::InternalError;

                Regnessem::AddIn::StrRsc::g_strRscMain.Initialize(*lpNsmInitInfo);

                return Regnessem::NsmPluginState::AllRight;
        }

        // vOCĚIš
        //
        // Return   : G[R[h
        int WINAPI Terminate()
        {
                Regnessem::AddIn::StrRsc::g_strRscMain.Terminate();

                return Regnessem::NsmPluginState::AllRight;
        }
}