Esempio n. 1
0
        public MigemoWrapper(string pathMigemoDll, string pathDict)
        {
            if (!String.IsNullOrEmpty(pathMigemoDll) && !String.IsNullOrEmpty(pathDict))
            {
                hMoudleMigemo = LoadLibrary(pathMigemoDll);

                if (hMoudleMigemo != IntPtr.Zero)
                {
                    IntPtr pOpen     = GetProcAddress(hMoudleMigemo, "migemo_open");
                    IntPtr pQuery    = GetProcAddress(hMoudleMigemo, "migemo_query");
                    IntPtr pRelease  = GetProcAddress(hMoudleMigemo, "migemo_release");
                    IntPtr pClose    = GetProcAddress(hMoudleMigemo, "migemo_close");
                    IntPtr pIsEnable = GetProcAddress(hMoudleMigemo, "migemo_is_enable");

                    bool fSuccess = pOpen != IntPtr.Zero &&
                                    pQuery != IntPtr.Zero &&
                                    pRelease != IntPtr.Zero &&
                                    pClose != IntPtr.Zero &&
                                    pIsEnable != IntPtr.Zero;

                    if (fSuccess)
                    {
                        migemo_open mOpen = Marshal.GetDelegateForFunctionPointer(pOpen, typeof(migemo_open)) as migemo_open;
                        mQuery    = Marshal.GetDelegateForFunctionPointer(pQuery, typeof(migemo_query)) as migemo_query;
                        mRlease   = Marshal.GetDelegateForFunctionPointer(pRelease, typeof(migemo_release)) as migemo_release;
                        mClose    = Marshal.GetDelegateForFunctionPointer(pClose, typeof(migemo_close)) as migemo_close;
                        mIsEnable = Marshal.GetDelegateForFunctionPointer(pIsEnable, typeof(migemo_is_enable)) as migemo_is_enable;

                        if (mOpen != null &&
                            mQuery != null &&
                            mRlease != null &&
                            mClose != null &&
                            mIsEnable != null)
                        {
                            pMigemo = mOpen(pathDict);

                            if (IsEnable)
                            {
                                return;
                            }
                            else if (pMigemo != IntPtr.Zero)
                            {
                                mClose(pMigemo);
                            }
                        }
                    }

                    FreeLibrary(hMoudleMigemo);
                    hMoudleMigemo = IntPtr.Zero;
                }
            }

            throw new ArgumentException();
        }
Esempio n. 2
0
        public MigemoWrapper(string pathMigemoDll, string pathDict)
        {
            if(!String.IsNullOrEmpty(pathMigemoDll) && !String.IsNullOrEmpty(pathDict)) {
                hModuleMigemo = LoadLibrary(pathMigemoDll);

                if(hModuleMigemo != IntPtr.Zero) {
                    IntPtr pOpen = GetProcAddress(hModuleMigemo, "migemo_open");
                    IntPtr pQuery = GetProcAddress(hModuleMigemo, "migemo_query");
                    IntPtr pRelease = GetProcAddress(hModuleMigemo, "migemo_release");
                    IntPtr pClose = GetProcAddress(hModuleMigemo, "migemo_close");
                    IntPtr pIsEnable = GetProcAddress(hModuleMigemo, "migemo_is_enable");

                    bool fSuccess = pOpen != IntPtr.Zero &&
                                    pQuery != IntPtr.Zero &&
                                    pRelease != IntPtr.Zero &&
                                    pClose != IntPtr.Zero &&
                                    pIsEnable != IntPtr.Zero;

                    if(fSuccess) {
                        migemo_open mOpen = Marshal.GetDelegateForFunctionPointer(pOpen, typeof(migemo_open)) as migemo_open;
                        mQuery = Marshal.GetDelegateForFunctionPointer(pQuery, typeof(migemo_query)) as migemo_query;
                        mRelease = Marshal.GetDelegateForFunctionPointer(pRelease, typeof(migemo_release)) as migemo_release;
                        mClose = Marshal.GetDelegateForFunctionPointer(pClose, typeof(migemo_close)) as migemo_close;
                        mIsEnable = Marshal.GetDelegateForFunctionPointer(pIsEnable, typeof(migemo_is_enable)) as migemo_is_enable;

                        if(mOpen != null &&
                            mQuery != null &&
                            mRelease != null &&
                            mClose != null &&
                            mIsEnable != null) {
                            pMigemo = mOpen(pathDict);

                            if(IsEnable) {
                                return;
                            }
                            else if(pMigemo != IntPtr.Zero) {
                                mClose(pMigemo);
                            }
                        }
                    }

                    FreeLibrary(hModuleMigemo);
                    hModuleMigemo = IntPtr.Zero;
                }
            }

            throw new ArgumentException();
        }