init.c

蒙古文输入法源码

    RegCloseKey(hKeyIMESetting);

    return;
}

/**********************************************************************/
/* InitImeLocalData()                                                 */
/**********************************************************************/
BOOL PASCAL InitImeLocalData(
    HINSTANCE hInstL)
{
    int      cxBorder, cyBorder;

    int   iContentHi;


    // iContentHi is to get the maximum value of predefined COMP_TEXT_Y and
    // a real Chinese character's height in the current HDC.

    iContentHi = COMP_TEXT_Y;

    if ( iContentHi < sImeG.yChiCharHi )
       iContentHi = sImeG.yChiCharHi ;


    lpImeL->hInst = hInstL;

    lpImeL->nMaxKey = COMP_MAX_KEY;

    // border + raising edge + sunken edge
    cxBorder = GetSystemMetrics(SM_CXBORDER);
    cyBorder = GetSystemMetrics(SM_CYBORDER);
                                        
    // text position relative to the composition window
    lpImeL->cxCompBorder = cxBorder * 2;
    lpImeL->cyCompBorder = cyBorder * 2;

    lpImeL->rcCompText.left = cxBorder;
    lpImeL->rcCompText.top = cyBorder;

    lpImeL->rcCompText.right = lpImeL->rcCompText.left + sImeG.xChiCharWi * ((6 + 2) / 2);
    lpImeL->rcCompText.bottom = lpImeL->rcCompText.top + iContentHi;
    // set the width & height for composition window
    lpImeL->xCompWi=lpImeL->rcCompText.right+lpImeL->cxCompBorder*2+cxBorder*4;
    lpImeL->yCompHi=lpImeL->rcCompText.bottom+lpImeL->cyCompBorder*2+cyBorder*4;

    // default position of composition window
    lpImeL->ptDefComp.x = sImeG.rcWorkArea.right -
    lpImeL->xCompWi - cxBorder * 2;
    lpImeL->ptDefComp.y = sImeG.rcWorkArea.bottom -
    lpImeL->yCompHi - cyBorder * 2;

    lpImeL->fModeConfig = MODE_CONFIG_QUICK_KEY|MODE_CONFIG_PREDICT;

    return (TRUE);
}

/**********************************************************************/
/* RegisterIme()                                                      */
/**********************************************************************/
void PASCAL RegisterIme(
    HINSTANCE hInstance)
{
    HKEY  hKeyCurrVersion;
    HKEY  hKeyGB;
    DWORD retCode;
    TCHAR Buf[LINE_LEN];
    DWORD ValueType;
    DWORD ValueSize;

    // init ime charact
    lstrcpy(sImeG.UsedCodes, MongolAsciiTable );//TEXT("`@#$^*()-_\\|qwWeErRtyuiop[{]}asdfghHjkKlL;:'\"zZxXcvbnNm,<.>/?"));
    sImeG.wNumCodes = (WORD)lstrlen(sImeG.UsedCodes);
    sImeG.IC_Enter = 0;
    sImeG.IC_Trace = 0;
    
    retCode = OpenReg_PathSetup(&hKeyCurrVersion);
    if (retCode) {
        RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion);
    }

    retCode = OpenReg_User (hKeyCurrVersion,
                            szImeRegName,
                            &hKeyGB);
    if (retCode) {
        DWORD dwDisposition;
        DWORD Value;
        
        retCode = RegCreateKeyEx (hKeyCurrVersion,
                                  szImeRegName,
                                  0,
                                  0,
                                  REG_OPTION_NON_VOLATILE,
                                  KEY_ALL_ACCESS,
                                  NULL,
                                  &hKeyGB,
                                  &dwDisposition);

        Value = 1;
        RegSetValueEx(hKeyGB, 
                      szTrace,
                      (DWORD)0,
                      REG_DWORD,
                      (LPBYTE)&Value,
                      sizeof(DWORD));
    }

    ValueSize = sizeof(DWORD);
    if (RegQueryValueEx(hKeyGB, 
                        szTrace,
                        NULL,
                        (LPDWORD)&ValueType,
                        (LPBYTE)&sImeG.IC_Trace,
                        (LPDWORD)&ValueSize) != ERROR_SUCCESS)
    {
        DWORD Value = 1;
        RegSetValueEx(hKeyGB,
                      szTrace,
                      (DWORD)0,
                      REG_DWORD,
                      (LPBYTE)&Value,
                      sizeof(DWORD));

        RegQueryValueEx(hKeyGB, 
                        szTrace,
                        NULL,
                        (LPDWORD)&ValueType,
                        (LPBYTE)&sImeG.IC_Trace,
                        (LPDWORD)&ValueSize);
    }
        
        

#ifdef CROSSREF                 
    if(RegQueryValueEx(hKeyGB, 
                       szRegRevKL,
                       NULL,
                       NULL,                  // null-terminate string
                       (LPBYTE)&sImeG.hRevKL, // &bData,
                       &ValueSize) != ERROR_SUCCESS)
    sImeG.hRevKL = NULL;
    if(RegQueryValueEx (hKeyGB, 
                        szRegRevMaxKey,
                        NULL,
                        NULL,                       //null-terminate string
                        (LPBYTE)&sImeG.nRevMaxKey,  //&bData,
                        &ValueSize) != ERROR_SUCCESS)
    sImeG.hRevKL = NULL;
#endif

    RegCloseKey(hKeyGB);
    RegCloseKey(hKeyCurrVersion);

    return;
}

/**********************************************************************/
/* RegisterImeClass()                                                 */
/**********************************************************************/
void PASCAL RegisterImeClass(
    HINSTANCE hInstance,
    HINSTANCE hInstL)
{
    WNDCLASSEX wcWndCls;

    // IME UI class
    // Register IME UI class
    wcWndCls.cbSize        = sizeof(WNDCLASSEX);
    wcWndCls.cbClsExtra    = 0;
    wcWndCls.cbWndExtra    = sizeof(INT_PTR) * 2;
    wcWndCls.hIcon         = LoadImage(hInstL, MAKEINTRESOURCE(IDI_IME),
    IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
    wcWndCls.hInstance     = hInstance;
    wcWndCls.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wcWndCls.hbrBackground = GetStockObject(NULL_BRUSH);
    wcWndCls.lpszMenuName  = (LPTSTR)NULL;
    wcWndCls.hIconSm       = LoadImage(hInstL, MAKEINTRESOURCE(IDI_IME),
    IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);

    // IME UI class
    if (!GetClassInfoEx(hInstance, szUIClassName, &wcWndCls)) {
    wcWndCls.style         = CS_IME;
    wcWndCls.lpfnWndProc   = UIWndProc;
    wcWndCls.lpszClassName = (LPTSTR)szUIClassName;

    RegisterClassEx(&wcWndCls);
    }

    wcWndCls.style         = CS_IME|CS_HREDRAW|CS_VREDRAW;
    wcWndCls.hbrBackground = GetStockObject(LTGRAY_BRUSH);


    // IME composition class
    // register IME composition class
    if (!GetClassInfoEx(hInstance, szCompClassName, &wcWndCls)) {
       wcWndCls.lpfnWndProc   = CompWndProc;
       wcWndCls.lpszClassName = (LPTSTR)szCompClassName;

       RegisterClassEx(&wcWndCls);
    }

    // IME candidate class
    // register IME candidate class
    if (!GetClassInfoEx(hInstance, szCandClassName, &wcWndCls)) {
       wcWndCls.lpfnWndProc   = CandWndProc;
       wcWndCls.lpszClassName = (LPTSTR)szCandClassName;

       RegisterClassEx(&wcWndCls);
    }

    // IME status class
    // register IME status class
    if (!GetClassInfoEx(hInstance, szStatusClassName, &wcWndCls)) {
       wcWndCls.lpfnWndProc   = StatusWndProc;
       wcWndCls.lpszClassName = (LPTSTR)szStatusClassName;

       RegisterClassEx(&wcWndCls);
    }

    // IME context menu class
    if (!GetClassInfoEx(hInstance, szCMenuClassName, &wcWndCls)) {
       wcWndCls.style         = 0;
       wcWndCls.hbrBackground = GetStockObject(NULL_BRUSH);
       wcWndCls.lpfnWndProc   = ContextMenuWndProc;
       wcWndCls.lpszClassName = (LPTSTR)szCMenuClassName;

       RegisterClassEx(&wcWndCls);
    }
    // IME softkeyboard menu class
    if (!GetClassInfoEx(hInstance, szSoftkeyMenuClassName, &wcWndCls)) {
       wcWndCls.style         = 0;
       wcWndCls.hbrBackground = GetStockObject(NULL_BRUSH);
       wcWndCls.lpfnWndProc   = SoftkeyMenuWndProc;
       wcWndCls.lpszClassName = (LPTSTR)szSoftkeyMenuClassName;

       RegisterClassEx(&wcWndCls);
    }

    return;
}

/**********************************************************************/
/* ImeDllInit()                                                       */
/* Return Value:                                                      */
/*      TRUE - successful                                             */
/*      FALSE - failure                                               */
/**********************************************************************/
BOOL CALLBACK ImeDllInit(
    HINSTANCE hInstance,        // instance handle of this library
    DWORD     fdwReason,        // reason called
    LPVOID    lpvReserve)       // reserve pointer
{
    switch (fdwReason) {
    case DLL_PROCESS_ATTACH:
         RegisterIme(hInstance);

    // init globaldata & load globaldata from resource
         {
            HKEY  hKeyCurrVersion;
            HKEY  hKeyGB;
            LONG  retCode;
            DWORD ValueType;
            DWORD ValueSize;

            retCode = OpenReg_PathSetup(&hKeyCurrVersion);

            if (retCode) {
               RegCreateKey(HKEY_CURRENT_USER, 
                            REGSTR_PATH_SETUP, 
                            &hKeyCurrVersion);
            }

            retCode = RegCreateKeyEx(hKeyCurrVersion, 
                             szImeRegName, 
                             0,
                             NULL, 
                             REG_OPTION_NON_VOLATILE,
                             KEY_ALL_ACCESS,
                             NULL,
                             &hKeyGB, 
                             NULL);

            ValueSize = sizeof(DWORD);
            retCode = RegQueryValueEx(hKeyGB,
                              szRegImeIndex,
                              NULL,
                              (LPDWORD)&ValueType,
                              (LPBYTE)&sImeL.dwRegImeIndex,
                              (LPDWORD)&ValueSize);

            if ( retCode != ERROR_SUCCESS )  {
                 //set GB/QW as default

               sImeL.dwRegImeIndex = 0;
               RegSetValueEx (hKeyGB, szRegImeIndex,
                           (DWORD)0,
                           REG_DWORD,
                           (LPBYTE)&sImeL.dwRegImeIndex,
                           sizeof(DWORD));  
            }

            sImeL.dwRegImeOutIndex = 0;
            //readout current ImeName
            szImeName = pszImeName[sImeL.dwRegImeIndex];
            szImeOutName = pszImeOutName[sImeL.dwRegImeOutIndex];

            RegCloseKey(hKeyGB);
            RegCloseKey(hKeyCurrVersion);
         }

         if (!hInst) {
            InitImeGlobalData(hInstance);
         }

         if (!lpImeL) {
            lpImeL = &sImeL;
            InitImeLocalData(hInstance);
         }

         RegisterImeClass(hInstance, hInstance);

         break;
    case DLL_PROCESS_DETACH:
         {
            WNDCLASSEX wcWndCls;

            if (GetClassInfoEx(hInstance, szCMenuClassName, &wcWndCls)) {
                UnregisterClass(szCMenuClassName, hInstance);
            }

            if (GetClassInfoEx(hInstance, szSoftkeyMenuClassName, &wcWndCls)) {
               UnregisterClass(szSoftkeyMenuClassName, hInstance);
            }

            if (GetClassInfoEx(hInstance, szStatusClassName, &wcWndCls)) {
               UnregisterClass(szStatusClassName, hInstance);
            }

            if (GetClassInfoEx(hInstance, szCandClassName, &wcWndCls)) {
               UnregisterClass(szCandClassName, hInstance);
            }

            if (GetClassInfoEx(hInstance, szCompClassName, &wcWndCls)) {
               UnregisterClass(szCompClassName, hInstance);
            }

            if (!GetClassInfoEx(hInstance, szUIClassName, &wcWndCls)) {
            } else if (!UnregisterClass(szUIClassName, hInstance)) {
            } else {
                      DestroyIcon(wcWndCls.hIcon);
                      DestroyIcon(wcWndCls.hIconSm);
                   }
         }
         break;
    default:
         break;
    }

    return (TRUE);
}

int strbytelen (LPTSTR lpStr)
{
    int i, len, iRet;

    len = lstrlen(lpStr);
    for (i = 0, iRet = 0; i < len; i++, iRet++) {
        if (lpStr[i] > 0x100)
            iRet++;
    }
    return iRet;
}