/*++ Copyright (c) 1990-1999 Microsoft Corporation, All Rights Reserved Module Name: ddis.c ++*/ #include #include #include #include #include #include #include #include HWND hCrtDlg = NULL; /**********************************************************************/ /* ImeInquire() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL WINAPI ImeInquire( // initialized data structure of IME LPIMEINFO lpImeInfo, // IME specific data report to IMM LPTSTR lpszWndCls, // the class name of UI DWORD dwSystemInfoFlags) { if (!lpImeInfo) { return (FALSE); } lpImeInfo->dwPrivateDataSize = sizeof(PRIVCONTEXT); lpImeInfo->fdwProperty = IME_PROP_KBD_CHAR_FIRST| #ifdef UNICODE IME_PROP_UNICODE| #endif IME_PROP_CANDLIST_START_FROM_1| IME_PROP_IGNORE_UPKEYS; lpImeInfo->fdwConversionCaps = IME_CMODE_NATIVE|IME_CMODE_FULLSHAPE| IME_CMODE_CHARCODE|IME_CMODE_SOFTKBD|IME_CMODE_NOCONVERSION; lpImeInfo->fdwSentenceCaps = 0; // IME will have different distance base multiple of 900 escapement lpImeInfo->fdwUICaps = UI_CAP_ROT90|UI_CAP_SOFTKBD; // composition string is the reading string for simple IME lpImeInfo->fdwSCSCaps = SCS_CAP_COMPSTR|SCS_CAP_MAKEREAD; // IME want to decide conversion mode on ImeSelect lpImeInfo->fdwSelectCaps = (DWORD)0; lstrcpy(lpszWndCls, (LPTSTR)szUIClassName); if ( lpImeL ) { if ( dwSystemInfoFlags & IME_SYSINFO_WINLOGON ) { // the client app is running in logon mode. lpImeL->fWinLogon = TRUE; } else lpImeL->fWinLogon = FALSE; } return (TRUE); } #if defined(CROSSREF) /**********************************************************************/ /* ReverseConversionList() */ /**********************************************************************/ void PASCAL ReverseConversionList(HWND hLayoutListBox) { int nLayouts, i, nIMEs; TCHAR szTmpImeName[24]; HKL FAR *lpKLMem; LoadString(hInst, IDS_NONE, szTmpImeName, sizeof(szTmpImeName)/sizeof(TCHAR)); SendMessage(hLayoutListBox, LB_INSERTSTRING, 0, (LPARAM)szTmpImeName); SendMessage(hLayoutListBox, LB_SELECTSTRING, 0, (LPARAM)szTmpImeName); SendMessage(hLayoutListBox, LB_SETITEMDATA, 0, (LPARAM)(HKL)NULL); nLayouts = GetKeyboardLayoutList(0, NULL); lpKLMem = GlobalAlloc(GPTR, sizeof(HKL) * nLayouts); if (!lpKLMem) { return; } GetKeyboardLayoutList(nLayouts, lpKLMem); for (i = 0, nIMEs = 0; i < nLayouts; i++) { HKL hKL; hKL = *(lpKLMem + i); if (LOWORD(hKL) != NATIVE_LANGUAGE) { // not support other language continue; } if (!ImmGetConversionList(hKL, (HIMC)NULL, NULL, NULL, 0, GCL_REVERSECONVERSION)) { // this IME not support reverse conversion continue; } if (!ImmEscape(hKL, (HIMC)NULL, IME_ESC_IME_NAME, szTmpImeName)) { // this IME does not report the IME name continue; } if( lstrcmp(szTmpImeName, szImeName) == 0) continue; nIMEs++; SendMessage(hLayoutListBox, LB_INSERTSTRING, nIMEs, (LPARAM)szTmpImeName); if (hKL == sImeG.hRevKL) { SendMessage(hLayoutListBox, LB_SELECTSTRING, nIMEs, (LPARAM)szTmpImeName); } SendMessage(hLayoutListBox, LB_SETITEMDATA, nIMEs, (LPARAM)hKL); } GlobalFree((HGLOBAL)lpKLMem); return; } #endif //CROSSREF /**********************************************************************/ /* ImeSetDlgProc() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL FAR PASCAL ImeSetDlgProc( // dialog procedure of configuration HWND hDlg, UINT uMessage, WORD wParam, LONG lParam) { RECT rc; LONG DlgWidth, DlgHeight; static DWORD TempParam; #ifdef CROSSREF HIMC hIMC; LPINPUTCONTEXT lpIMC; HWND hLayoutListBox; static HIMC hOldIMC; #endif //CROSSREF switch (uMessage) { case WM_INITDIALOG: hCrtDlg = hDlg; // reset position GetWindowRect(hDlg, &rc); DlgWidth = rc.right - rc.left; DlgHeight = rc.bottom - rc.top; SetWindowPos(hDlg, HWND_TOP, (int)(sImeG.rcWorkArea.right - DlgWidth)/2, (int)(sImeG.rcWorkArea.bottom - DlgHeight)/2, (int)0, (int)0, SWP_NOSIZE); TempParam = sImeG.IC_Trace; CheckDlgButton (hDlg, IDC_TRACE, sImeG.IC_Trace); #ifdef CROSSREF hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST); hIMC = ImmGetContext(hLayoutListBox); if(hIMC){ ImmSetOpenStatus(hIMC, FALSE); } ImmReleaseContext(hLayoutListBox, hIMC); // put all reverse conversion hKL into this list ReverseConversionList(hLayoutListBox); #endif //CROSSREF return (TRUE); // don't want to set focus to special control case WM_COMMAND: switch (wParam) { case IDOK: { HKEY hKeyCurrVersion; HKEY hKeyGB; DWORD retCode; //CHAR Buf[LINE_LEN]; sImeG.IC_Trace = TempParam; retCode = OpenReg_PathSetup(&hKeyCurrVersion); if (retCode) { RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion); } #if defined(COMBO_IME) if ( hKeyCurrVersion != NULL ) { retCode = RegCreateKeyEx(hKeyCurrVersion, szImeRegName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyGB, NULL); } #else if ( hKeyCurrVersion != NULL ) { retCode = RegCreateKeyEx(hKeyCurrVersion, szImeName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyGB, NULL); } #endif //COMBO_IME if (hKeyGB != NULL){ RegSetValueEx (hKeyGB, szTrace, (DWORD)0, REG_DWORD, (LPBYTE)&sImeG.IC_Trace, sizeof(DWORD)); RegCloseKey(hKeyGB); } if ( hKeyCurrVersion ) RegCloseKey(hKeyCurrVersion); #ifdef CROSSREF { HWND hLayoutListBox; int iCurSel; HKL hKL; DWORD retCode; hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST); iCurSel = (int)SendMessage(hLayoutListBox, LB_GETCURSEL, 0, 0); hKL = (HKL)SendMessage(hLayoutListBox, LB_GETITEMDATA, iCurSel, 0); if (sImeG.hRevKL != hKL) { WORD nRevMaxKey; HKEY hKeyAppUser, hKeyIMEUser; LPPRIVCONTEXT lpImcP; sImeG.hRevKL = hKL; //set reverse layout to registry retCode = OpenReg_PathSetup(&hKeyAppUser); if (retCode) { RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion); } #if defined(COMBO_IME) retCode = RegCreateKeyEx(hKeyAppUser, szImeRegName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS , NULL, &hKeyIMEUser, NULL); if (retCode) { DWORD dwDisposition; retCode = RegCreateKeyEx (hKeyCurrVersion, szImeRegName, 0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyGB, &dwDisposition); } #else retCode = RegCreateKeyEx(hKeyAppUser, szImeName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS , NULL, &hKeyIMEUser, NULL); if (retCode) { DWORD dwDisposition; retCode = RegCreateKeyEx (hKeyCurrVersion, szImeName, 0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKeyGB, &dwDisposition); } #endif //COMBO_IME RegSetValueEx(hKeyIMEUser, szRegRevKL, 0, REG_DWORD, (LPBYTE)&hKL,sizeof(hKL)); // get the new size nRevMaxKey = (WORD)ImmEscape(hKL, (HIMC)NULL, IME_ESC_MAX_KEY, NULL); if (lpImeL->nMaxKey != nRevMaxKey) { if(lpImeL->nMaxKey < nRevMaxKey) lpImeL->nMaxKey = nRevMaxKey; // set the width & height for composition window lpImeL->rcCompText.right = lpImeL->rcCompText.left + sImeG.xChiCharWi * ((lpImeL->nMaxKey+2)/2); lpImeL->xCompWi = lpImeL->rcCompText.right + lpImeL->cxCompBorder * (2 + 4); //generate message to broadcast change comp win size hIMC = (HIMC)ImmGetContext(hDlg); if (!hIMC) { return TRUE; } lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC); if (!lpIMC) { return TRUE; } lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate); if (!lpImcP) { goto ChgConfigUnlockIMC; } lpImcP->fdwImeMsg |= MSG_IMN_COMPOSITIONPOS; GenerateMessage(hIMC, lpIMC, lpImcP); ImmUnlockIMCC(lpIMC->hPrivate); ChgConfigUnlockIMC: ImmUnlockIMC(hIMC); } //end of change nMaxKey RegSetValueEx(hKeyIMEUser, szRegRevMaxKey, 0, REG_DWORD, (LPBYTE)&lpImeL->nMaxKey,sizeof(DWORD)); RegCloseKey(hKeyAppUser); RegCloseKey(hKeyIMEUser); } //end of change RegRevKL } #endif //CROSSREF } #ifdef CROSSREF hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST); hIMC = ImmGetContext(hLayoutListBox); if(hIMC) { ImmSetOpenStatus(hIMC, TRUE); } ImmReleaseContext(hLayoutListBox, hIMC); #endif //CROSSREF EndDialog(hDlg, FALSE); break; case IDCANCEL: #ifdef CROSSREF hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST); hIMC = ImmGetContext(hLayoutListBox); if(hIMC) { ImmSetOpenStatus(hIMC, TRUE); } ImmReleaseContext(hLayoutListBox, hIMC); #endif //CROSSREF EndDialog(hDlg, FALSE); break; case IDC_TRACE: // Set Current InputMode Param(temp) TempParam = (TempParam ^ 0x00000001) & 0x00000001; break; default: return (FALSE); } return (TRUE); case WM_PAINT: { RECT rc; GetClientRect(hDlg, &rc); DrawConvexRect(GetDC(hDlg), rc.left + 7, rc.top + 7, rc.right - 7 - 1, rc.bottom - 40 - 1); DrawConvexRectP(GetDC(hDlg), rc.left + 7, rc.top + 7, rc.right - 7, rc.bottom - 40); } return (FALSE); case WM_CLOSE: #ifdef CROSSREF hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST); hIMC = ImmGetContext(hLayoutListBox); if(hIMC) { ImmSetOpenStatus(hIMC, TRUE); } ImmReleaseContext(hLayoutListBox, hIMC); #endif //CROSSREF EndDialog(hDlg, FALSE); return (TRUE); default: return (FALSE); } return (TRUE); } /**********************************************************************/ /* ImeConfigure() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ /*BOOL WINAPI ImeConfigure( // configurate the IME setting HKL hKL, // hKL of this IME HWND hAppWnd, // the owner window DWORD dwMode) // mode of dialog {*/ BOOL WINAPI ImeConfigure( // configurate the IME setting HKL hKL, // hKL of this IME HWND hAppWnd, // the owner window DWORD dwMode, LPVOID lpData) // mode of dialog { switch (dwMode) { case IME_CONFIG_GENERAL: DialogBox(hInst, TEXT("ImeSet"), (HWND)hAppWnd, (DLGPROC)ImeSetDlgProc); break; default: return (FALSE); break; } return (TRUE); } /**********************************************************************/ /* XGBConversion() */ /**********************************************************************/ DWORD PASCAL XGBConversion( LPCTSTR lpszReading, LPCANDIDATELIST lpCandList, UINT uBufLen) { UINT MAX_COMP; UINT uMaxCand; UINT iRet; WORD wCode; LPPRIVCONTEXT lpImcP; HGLOBAL hImcP; int i; DWORD dwSize; if (!(lstrlen (lpszReading) == 4)) { return (0); } hImcP = GlobalAlloc (GMEM_MOVEABLE,sizeof (PRIVCONTEXT)); if(!hImcP){ return(0); } lpImcP= GlobalLock (hImcP); if(!lpImcP){ GlobalFree(hImcP); return(0); } lstrcpy (lpImcP->bSeq,lpszReading); if(lpImcP->bSeq[3] == TEXT('?')){ MAX_COMP = 178; } else { MAX_COMP = 1; } dwSize = // similar to ClearCand // header length sizeof(CANDIDATELIST) + // candidate string pointers sizeof(DWORD) * MAX_COMP + // string plus NULL terminator (sizeof(WORD) + sizeof(TCHAR)) * MAX_COMP; if (!uBufLen) { return (dwSize); } uMaxCand = uBufLen - sizeof(CANDIDATELIST); uMaxCand /= sizeof(DWORD) + sizeof(WORD) + sizeof(TCHAR); if (!uMaxCand) { // can not even put one string return (0); } lpCandList->dwSize = dwSize; lpCandList->dwStyle = IME_CAND_READ; // candidate having same reading lpCandList->dwCount = 0; lpCandList->dwSelection = 0; lpCandList->dwPageSize = CANDPERPAGE; lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) * (uMaxCand - 1); lpImcP->bSeq[0] = 0; lpImcP->bSeq[1] = 0; lpImcP->bSeq[2] = 0; lpImcP->bSeq[3] = 0; for (i=0;i<4;i++) { iRet = XGBProcessKey(*(LPBYTE)((LPBYTE)lpszReading+i),lpImcP); if (iRet == CST_INPUT) { lpImcP->bSeq[i] = *(LPBYTE)((LPBYTE)lpszReading+i); } else { return (DWORD)0; } } wCode = XGBEngine(lpImcP); wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8); for (i = 0; i < (0x7e-0x40+1); i++, wCode++) { XGBAddCodeIntoCand(lpCandList, wCode); } wCode ++; for (i = 0; i < (0xfe-0x80+1); i++, wCode++) { XGBAddCodeIntoCand(lpCandList, wCode); } GlobalUnlock (hImcP); GlobalFree (hImcP); return (dwSize); } /**********************************************************************/ /* Conversion() */ /**********************************************************************/ DWORD PASCAL Conversion( LPCTSTR lpszReading, LPCANDIDATELIST lpCandList, UINT uBufLen) { UINT MAX_COMP,i; UINT uMaxCand; UINT iRet; WORD wCode; LPPRIVCONTEXT lpImcP; HGLOBAL hImcP; DWORD dwSize; if (!(lstrlen (lpszReading) == 4)) { return (0); } hImcP = GlobalAlloc (GMEM_MOVEABLE,sizeof (PRIVCONTEXT)); if(!hImcP){ return(0); } lpImcP= GlobalLock (hImcP); if(!lpImcP){ GlobalFree(hImcP); return(0); } lstrcpy (lpImcP->bSeq,lpszReading); if(lpImcP->bSeq[3] == TEXT('?')){ MAX_COMP = 94; } else { MAX_COMP = 1; } dwSize = // similar to ClearCand // header length sizeof(CANDIDATELIST) + // candidate string pointers sizeof(DWORD) * MAX_COMP + // string plus NULL terminator (sizeof(WORD) + sizeof(TCHAR)) * MAX_COMP; if (!uBufLen) { return (dwSize); } uMaxCand = uBufLen - sizeof(CANDIDATELIST); uMaxCand /= sizeof(DWORD) + sizeof(WORD) + sizeof(TCHAR); if (!uMaxCand) { // can not even put one string return (0); } lpCandList->dwSize = dwSize; lpCandList->dwStyle = IME_CAND_READ; // candidate having same reading lpCandList->dwCount = 0; lpCandList->dwSelection = 0; lpCandList->dwPageSize = CANDPERPAGE; lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) * (uMaxCand - 1); lpImcP->bSeq[0] = 0; lpImcP->bSeq[1] = 0; lpImcP->bSeq[2] = 0; lpImcP->bSeq[3] = 0; for (i=0;i<4;i++) { iRet = GBProcessKey(*(LPBYTE)((LPBYTE)lpszReading+i),lpImcP); if (iRet == CST_INPUT) { lpImcP->bSeq[i] = *(LPBYTE)((LPBYTE)lpszReading+i); } else { return (DWORD)0; } } wCode = GBEngine (lpImcP); wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8); for (i = 0; i < MAX_COMP;i++, wCode++) { AddCodeIntoCand(lpCandList, wCode); } GlobalUnlock (hImcP); GlobalFree (hImcP); return (dwSize); } /************************************************************************** BOOL DBCSToGBCode ( WORD wCode, BYTE AbSeq[5]) ***************************************************************************/ BOOL DBCSToGBCode ( WORD wCode, TCHAR AbSeq[5]) { WORD AreaCode; #ifdef UNICODE //Converte Unicode to GBK // change CP_ACP to 936, so that it can work under Multilingul Env. WideCharToMultiByte(NATIVE_ANSI_CP, WC_COMPOSITECHECK, &wCode, 1, (char *)&AreaCode, 2, NULL, NULL); wCode = AreaCode; #endif //check valid GB range code first #if defined(COMBO_IME) if(sImeL.dwRegImeIndex==INDEX_GB){ if(LOBYTE(wCode) < 0xa1 || LOBYTE(wCode) > 0xfe || HIBYTE(wCode) < 0xa1 || HIBYTE(wCode) > 0xfe) return FALSE; AbSeq[1] = ((wCode -0xa0) % 256) % 10; AbSeq[0] = ((wCode -0xa0) % 256) / 10; AreaCode = (wCode - 0xa0 -AbSeq[0] * 10 -AbSeq[1])/256; AbSeq[3] = ((AreaCode -0xa0) % 256) % 10; AbSeq[2] = ((AreaCode -0xa0) % 256) / 10; AbSeq[4] = TEXT('\0';) }else if(sImeL.dwRegImeIndex==INDEX_GBK || sImeL.dwRegImeIndex==INDEX_UNICODE){ WORD tmp; tmp = HIBYTE(wCode) | (LOBYTE(wCode)<<8); wsprintf(AbSeq,TEXT("%04x"), tmp); } else return FALSE; #else //COMBO_IME #ifdef GB if(LOBYTE(wCode) < 0xa1 || LOBYTE(wCode) > 0xfe || HIBYTE(wCode) < 0xa1 || HIBYTE(wCode) > 0xfe) return FALSE; AbSeq[1] = ((wCode -0xa0) % 256) % 10; AbSeq[0] = ((wCode -0xa0) % 256) / 10; AreaCode = (wCode - 0xa0 -AbSeq[0] * 10 -AbSeq[1])/256; AbSeq[3] = ((AreaCode -0xa0) % 256) % 10; AbSeq[2] = ((AreaCode -0xa0) % 256) / 10; AbSeq[4] = TEXT('\0'); #else { WORD tmp; tmp = HIBYTE(wCode) | (LOBYTE(wCode)<<8); wsprintf(AbSeq,TEXT("%04x"), tmp); } #endif //GB #endif //COMBO_IME return TRUE; } /*************************************************************************** BOOL AreaToGB ( BYTE AbSeq[5],BYTE GbSeq[5]) ***************************************************************************/ BOOL AreaToGB ( TCHAR AbSeq[5], TCHAR GbSeq[5]) { TCHAR MbSeq[3]; // Temp string // Area turn wsprintf (MbSeq,TEXT("%lx"),(AbSeq[0] * 10 + AbSeq[1]+0xa0)); GbSeq[0] = MbSeq[0]; GbSeq[1] = MbSeq[1]; //position turn wsprintf (MbSeq,TEXT("%lx"),(AbSeq[2] * 10 + AbSeq[3]+0xa0)); GbSeq[2] = MbSeq[0]; GbSeq[3] = MbSeq[1]; GbSeq[4] = TEXT('\0'); return TRUE; } #if defined(COMBO_IME) /**********************************************************************/ /* UnicodeReverseConversion() */ /**********************************************************************/ DWORD PASCAL UnicodeReverseConversion( WORD wCode, LPCANDIDATELIST lpCandList, UINT uBufLen) { UINT MAX_COMP = 1; UINT nMaxKey = 4; TCHAR AbSeq[5]; UINT uMaxCand; DWORD dwSize = // similar to ClearCand // header length sizeof(CANDIDATELIST) + // candidate string pointers sizeof(DWORD) * MAX_COMP + // string plus NULL terminator (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); if (!uBufLen) { return (dwSize); } uMaxCand = uBufLen - sizeof(CANDIDATELIST); uMaxCand /= sizeof(DWORD) + (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); if (uMaxCand == 0) { // can not put one string return (0); } lpCandList->dwSize = sizeof(CANDIDATELIST) + sizeof(DWORD) * uMaxCand + (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); lpCandList->dwStyle = IME_CAND_READ; lpCandList->dwCount = 0; lpCandList->dwSelection = 0; //lpCandList->dwPageSize = CANDPERPAGE; New Spac lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ; #ifndef UNICODE { WCHAR szWideStr[2]; int i; memset(szWideStr, 0, sizeof(szWideStr)); // change CP_ACP to 936, so that it can work under Multilingul Env. MultiByteToWideChar(NATIVE_ANSI_CP, 0, (LPCSTR)&wCode, sizeof(WORD), szWideStr, sizeof(szWideStr)); wCode = HIBYTE((WORD)szWideStr[0]) | (LOBYTE((WORD)szWideStr[0]) << 8 ); } if(!DBCSToGBCode (wCode, AbSeq)) return 0; //actual is DBCSToGBInternalCode #endif wsprintf(AbSeq,TEXT("%04x"), wCode); lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq); // string count ++ lpCandList->dwCount = 1; return (dwSize); } #endif //COMBO_IME /**********************************************************************/ /* XGBReverseConversion() */ /**********************************************************************/ DWORD PASCAL XGBReverseConversion( WORD wCode, LPCANDIDATELIST lpCandList, UINT uBufLen) { UINT MAX_COMP = 1; UINT nMaxKey = 4; TCHAR AbSeq[5]; UINT uMaxCand; DWORD dwSize = // similar to ClearCand // header length sizeof(CANDIDATELIST) + // candidate string pointers sizeof(DWORD) * MAX_COMP + // string plus NULL terminator (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); if (!uBufLen) { return (dwSize); } uMaxCand = uBufLen - sizeof(CANDIDATELIST); uMaxCand /= sizeof(DWORD) + (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); if (uMaxCand == 0) { // can not put one string return (0); } lpCandList->dwSize = sizeof(CANDIDATELIST) + sizeof(DWORD) * uMaxCand + (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); lpCandList->dwStyle = IME_CAND_READ; lpCandList->dwCount = 0; lpCandList->dwSelection = 0; //lpCandList->dwPageSize = CANDPERPAGE; New Spac lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ; if(!DBCSToGBCode (wCode, AbSeq)) return 0; //actual is DBCSToGBInternalCode lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq); // string count ++ lpCandList->dwCount = 1; return (dwSize); } /**********************************************************************/ /* ReverseConversion() */ /**********************************************************************/ DWORD PASCAL ReverseConversion( WORD wCode, LPCANDIDATELIST lpCandList, UINT uBufLen) { UINT MAX_COMP = 2; UINT nMaxKey = 4; TCHAR AbSeq[5]; TCHAR GbSeq[5]; UINT uMaxCand; DWORD dwSize = // similar to ClearCand // header length sizeof(CANDIDATELIST) + // candidate string pointers sizeof(DWORD) * MAX_COMP + // string plus NULL terminator (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); if (!uBufLen) { return (dwSize); } uMaxCand = uBufLen - sizeof(CANDIDATELIST); uMaxCand /= sizeof(DWORD) + (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); if (uMaxCand == 0) { // can not put one string return (0); } lpCandList->dwSize = sizeof(CANDIDATELIST) + sizeof(DWORD) * uMaxCand + (sizeof(TCHAR) * nMaxKey + sizeof(TCHAR)); lpCandList->dwStyle = IME_CAND_READ; lpCandList->dwCount = 0; lpCandList->dwSelection = 0; //lpCandList->dwPageSize = CANDPERPAGE; New Spac lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ; if(!DBCSToGBCode (wCode, AbSeq)) return 0; AreaToGB (AbSeq, GbSeq); AbSeq[1] +=TEXT('0'); AbSeq[0] +=TEXT('0'); AbSeq[3] +=TEXT('0'); AbSeq[2] +=TEXT('0'); lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq); lpCandList->dwOffset[1] = lpCandList->dwOffset[0] + 4*sizeof(TCHAR) + sizeof(TCHAR); lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[1]),GbSeq); // string count ++ lpCandList->dwCount = 2; return (dwSize); } /**********************************************************************/ /* ImeConversionList() */ /**********************************************************************/ DWORD WINAPI ImeConversionList( HIMC hIMC, LPCTSTR lpszSrc, LPCANDIDATELIST lpCandList, DWORD uBufLen, UINT uFlag) { WORD wCode; LPINPUTCONTEXT lpIMC; LPPRIVCONTEXT lpImcP; if (!uBufLen) { } else if (!lpszSrc) { return (0); } else if (!*lpszSrc) { return (0); } else if (!lpCandList) { return (0); } else if (uBufLen <= sizeof(CANDIDATELIST)) { // buffer size can not even put the header information return (0); } switch (uFlag) { case GCL_CONVERSION: lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC); if (!lpIMC) { return (FALSE); } lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate); if (!lpImcP) { ImmUnlockIMC(hIMC); return (FALSE); } #if defined(COMBO_IME) if(sImeL.dwRegImeIndex==INDEX_GB) return (Conversion(lpszSrc, lpCandList, uBufLen)); else if(sImeL.dwRegImeIndex==INDEX_GBK) return (XGBConversion(lpszSrc, lpCandList, uBufLen)); else if(sImeL.dwRegImeIndex==INDEX_UNICODE) return (XGBConversion(lpszSrc, lpCandList, uBufLen)); #else //COMBO_IME #ifdef GB return (Conversion(lpszSrc, lpCandList, uBufLen)); #else return (XGBConversion(lpszSrc, lpCandList, uBufLen)); #endif //GB #endif //COMBO_IME break; case GCL_REVERSECONVERSION: if (!uBufLen) { #if defined(COMBO_IME) return 1; #else //COMBO_IME #ifdef GB return 1; #else return 1; #endif //GB #endif //COMBO_IME } // only support one DBCS char reverse conversion if (*(LPTSTR)((LPBYTE)lpszSrc + sizeof(WORD)) != TEXT('\0')) { return (0); } wCode = *(LPWORD)lpszSrc; // swap lead byte & second byte, UNICODE don't need it // wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8); For Big5 #if defined(COMBO_IME) if(sImeL.dwRegImeIndex==INDEX_GB) return (ReverseConversion(wCode, lpCandList, uBufLen)); else if(sImeL.dwRegImeIndex==INDEX_GBK) return (XGBReverseConversion(wCode, lpCandList, uBufLen)); else if(sImeL.dwRegImeIndex==INDEX_UNICODE) return (UnicodeReverseConversion(wCode, lpCandList, uBufLen)); #else //COMBO_IME #ifdef GB return (ReverseConversion(wCode, lpCandList, uBufLen)); #else return (XGBReverseConversion(wCode, lpCandList, uBufLen)); #endif //GB #endif //COMBO_IME break; default: return (0); break; } return (0); } /**********************************************************************/ /* ImeDestroy() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL WINAPI ImeDestroy( // this dll is unloaded UINT uReserved) { if (uReserved) { return (FALSE); } return (TRUE); } /**********************************************************************/ /* ImeEscape() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ #define IME_INPUTKEYTOSEQUENCE 0x22 LRESULT WINAPI ImeEscape( // escape function of IMEs HIMC hIMC, UINT uSubFunc, LPVOID lpData) { LRESULT lRet; switch (uSubFunc) { case IME_ESC_QUERY_SUPPORT: if ( lpData == NULL ) return FALSE; switch (*(LPUINT)lpData) { case IME_ESC_QUERY_SUPPORT: case IME_ESC_MAX_KEY: case IME_ESC_IME_NAME: case IME_ESC_GETHELPFILENAME: return (TRUE); case IME_ESC_SEQUENCE_TO_INTERNAL: case IME_ESC_GET_EUDC_DICTIONARY: case IME_ESC_SET_EUDC_DICTIONARY: case IME_INPUTKEYTOSEQUENCE: // will not supported in next version return (FALSE); // will not supported in GB IME default: return (FALSE); } break; case IME_ESC_SEQUENCE_TO_INTERNAL: case IME_ESC_GET_EUDC_DICTIONARY: case IME_ESC_SET_EUDC_DICTIONARY: case IME_INPUTKEYTOSEQUENCE: return (FALSE); case IME_ESC_MAX_KEY: return ((WORD) 4); case IME_ESC_IME_NAME: if ( lpData == NULL ) return FALSE; lstrcpy(lpData, szImeName); return (TRUE); case IME_ESC_GETHELPFILENAME: { TCHAR szIMEGUDHlpName[MAX_PATH]; if (lpData == NULL ) return FALSE; szIMEGUDHlpName[0] = 0; GetWindowsDirectory((LPTSTR)szIMEGUDHlpName, MAX_PATH); lstrcat((LPTSTR)szIMEGUDHlpName, TEXT("\\HELP\\WINGB.CHM")); lstrcpy(lpData, szIMEGUDHlpName); return TRUE; } default: return (FALSE); } return (lRet); } /**********************************************************************/ /* InitCompStr() */ /**********************************************************************/ void PASCAL InitCompStr( // init setting for composing string LPCOMPOSITIONSTRING lpCompStr) { if (!lpCompStr) { return; } lpCompStr->dwCompReadAttrLen = 0; lpCompStr->dwCompReadClauseLen = 0; lpCompStr->dwCompReadStrLen = 0; lpCompStr->dwCompAttrLen = 0; lpCompStr->dwCompClauseLen = 0; lpCompStr->dwCompStrLen = 0; lpCompStr->dwCursorPos = 0; lpCompStr->dwDeltaStart = 0; lpCompStr->dwResultReadClauseLen = 0; lpCompStr->dwResultReadStrLen = 0; lpCompStr->dwResultClauseLen = 0; lpCompStr->dwResultStrLen = 0; return; } /**********************************************************************/ /* ClearCompStr() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL PASCAL ClearCompStr( LPINPUTCONTEXT lpIMC) { HIMCC hMem; LPCOMPOSITIONSTRING lpCompStr; DWORD dwSize; if(!lpIMC) { return (FALSE); } dwSize = // header length sizeof(COMPOSITIONSTRING) + // composition reading attribute plus NULL terminator lpImeL->nMaxKey * sizeof(BYTE) + sizeof(BYTE) + // composition reading clause sizeof(DWORD) + sizeof(DWORD) + // composition reading string plus NULL terminator lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD) + // result reading clause sizeof(DWORD) + sizeof(DWORD) + // result reading string plus NULL terminateor lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD) + // result clause sizeof(DWORD) + sizeof(DWORD) + // result string plus NULL terminateor MAXSTRLEN * sizeof(WORD) + sizeof(WORD); if (!lpIMC->hCompStr) { // it maybe free by other IME, init it lpIMC->hCompStr = ImmCreateIMCC(dwSize); } else if (hMem = ImmReSizeIMCC(lpIMC->hCompStr, dwSize)) { lpIMC->hCompStr = hMem; } else { ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = ImmCreateIMCC(dwSize); return (FALSE); } if (!lpIMC->hCompStr) { return (FALSE); } lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr); if (!lpCompStr) { ImmDestroyIMCC(lpIMC->hCompStr); lpIMC->hCompStr = ImmCreateIMCC(dwSize); return (FALSE); } lpCompStr->dwSize = dwSize; // 1. composition (reading) string - simple IME // 2. result reading string // 3. result string lpCompStr->dwCompReadAttrLen = 0; lpCompStr->dwCompReadAttrOffset = sizeof(COMPOSITIONSTRING); lpCompStr->dwCompReadClauseLen = 0; lpCompStr->dwCompReadClauseOffset = lpCompStr->dwCompReadAttrOffset + lpImeL->nMaxKey * sizeof(TCHAR) + sizeof(TCHAR); lpCompStr->dwCompReadStrLen = 0; lpCompStr->dwCompReadStrOffset = lpCompStr->dwCompReadClauseOffset + sizeof(DWORD) + sizeof(DWORD); // composition string is the same with composition reading string // for simple IMEs lpCompStr->dwCompAttrLen = 0; lpCompStr->dwCompAttrOffset = lpCompStr->dwCompReadAttrOffset; lpCompStr->dwCompClauseLen = 0; lpCompStr->dwCompClauseOffset = lpCompStr->dwCompReadClauseOffset; lpCompStr->dwCompStrLen = 0; lpCompStr->dwCompStrOffset = lpCompStr->dwCompReadStrOffset; lpCompStr->dwCursorPos = 0; lpCompStr->dwDeltaStart = 0; lpCompStr->dwResultReadClauseLen = 0; lpCompStr->dwResultReadClauseOffset = lpCompStr->dwCompStrOffset + lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD); lpCompStr->dwResultReadStrLen = 0; lpCompStr->dwResultReadStrOffset = lpCompStr->dwResultReadClauseOffset + sizeof(DWORD) + sizeof(DWORD); lpCompStr->dwResultClauseLen = 0; lpCompStr->dwResultClauseOffset = lpCompStr->dwResultReadStrOffset + lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD); lpCompStr->dwResultStrOffset = 0; lpCompStr->dwResultStrOffset = lpCompStr->dwResultClauseOffset + sizeof(DWORD) + sizeof(DWORD); GlobalUnlock((HGLOBAL)lpIMC->hCompStr); return (TRUE); } /**********************************************************************/ /* ClearCand() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL PASCAL ClearCand( LPINPUTCONTEXT lpIMC) { HIMCC hMem; LPCANDIDATEINFO lpCandInfo; LPCANDIDATELIST lpCandList; DWORD dwSize = // header length sizeof(CANDIDATEINFO) + sizeof(CANDIDATELIST) + // candidate string pointers sizeof(DWORD) * (MAXCAND + 1) + // string plus NULL terminator (sizeof(WORD) + sizeof(WORD)) * (MAXCAND + 1); if (!lpIMC) { return (FALSE); } if (!lpIMC->hCandInfo) { // it maybe free by other IME, init it lpIMC->hCandInfo = ImmCreateIMCC(dwSize); } else if (hMem = ImmReSizeIMCC(lpIMC->hCandInfo, dwSize)) { lpIMC->hCandInfo = hMem; } else { ImmDestroyIMCC(lpIMC->hCandInfo); lpIMC->hCandInfo = ImmCreateIMCC(dwSize); return (FALSE); } if (!lpIMC->hCandInfo) { return (FALSE); } lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo); if (!lpCandInfo) { ImmDestroyIMCC(lpIMC->hCandInfo); lpIMC->hCandInfo = ImmCreateIMCC(dwSize); return (FALSE); } // ordering of strings are // buffer size lpCandInfo->dwSize = dwSize; lpCandInfo->dwCount = 0; lpCandInfo->dwOffset[0] = sizeof(CANDIDATEINFO); lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo + lpCandInfo->dwOffset[0]); // whole candidate info size - header lpCandList->dwSize = lpCandInfo->dwSize - sizeof(CANDIDATEINFO); lpCandList->dwStyle = IME_CAND_READ; lpCandList->dwCount = 0; lpCandList->dwSelection = 0; lpCandList->dwPageSize = CANDPERPAGE; lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) * (MAXCAND ); ImmUnlockIMCC(lpIMC->hCandInfo); return (TRUE); } /**********************************************************************/ /* ClearGuideLine() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL PASCAL ClearGuideLine( LPINPUTCONTEXT lpIMC) { HIMCC hMem; LPGUIDELINE lpGuideLine; DWORD dwSize = sizeof(GUIDELINE) + sImeG.cbStatusErr; if (!lpIMC->hGuideLine) { // it maybe free by IME lpIMC->hGuideLine = ImmCreateIMCC(dwSize); } else if (hMem = ImmReSizeIMCC(lpIMC->hGuideLine, dwSize)) { lpIMC->hGuideLine = hMem; } else { ImmDestroyIMCC(lpIMC->hGuideLine); lpIMC->hGuideLine = ImmCreateIMCC(dwSize); } lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine); if (!lpGuideLine) { return (FALSE); } lpGuideLine->dwSize = dwSize; lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE; lpGuideLine->dwIndex = GL_ID_UNKNOWN; lpGuideLine->dwStrLen = 0; lpGuideLine->dwStrOffset = sizeof(GUIDELINE); CopyMemory((LPBYTE)lpGuideLine + lpGuideLine->dwStrOffset, sImeG.szStatusErr, sImeG.cbStatusErr); ImmUnlockIMCC(lpIMC->hGuideLine); return (TRUE); } /**********************************************************************/ /* InitContext() */ /**********************************************************************/ void PASCAL InitContext( LPINPUTCONTEXT lpIMC) { if (lpIMC->fdwInit & INIT_STATUSWNDPOS) { } else if (!lpIMC->hWnd) { } else { #ifdef MUL_MONITOR RECT rcWorkArea; rcWorkArea = ImeMonitorWorkAreaFromWindow(lpIMC->hWnd); lpIMC->ptStatusWndPos.x = rcWorkArea.left; lpIMC->ptStatusWndPos.y = rcWorkArea.bottom - sImeG.yStatusHi; #else POINT ptWnd; ptWnd.x = 0; ptWnd.y = 0; ClientToScreen(lpIMC->hWnd, &ptWnd); if (ptWnd.x < sImeG.rcWorkArea.left) { lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.left; } else if (ptWnd.x + sImeG.xStatusWi > sImeG.rcWorkArea.right) { lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.right - sImeG.xStatusWi; } else { lpIMC->ptStatusWndPos.x = ptWnd.x; } lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.bottom - sImeG.yStatusHi; #endif lpIMC->fdwInit |= INIT_STATUSWNDPOS; } if (lpIMC->fdwInit & INIT_COMPFORM) { } else if (!lpIMC->hWnd) { } else { POINT ptWnd; ptWnd = lpImeL->ptDefComp; ScreenToClient(lpIMC->hWnd, &ptWnd); lpIMC->cfCompForm.dwStyle = CFS_DEFAULT; lpIMC->cfCompForm.ptCurrentPos = ptWnd; lpIMC->fdwInit |= INIT_COMPFORM; } return; } /**********************************************************************/ /* Select() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL PASCAL Select( HIMC hIMC, LPINPUTCONTEXT lpIMC, BOOL fSelect) { LPPRIVCONTEXT lpImcP; UINT i; if (fSelect) { if (!ClearCompStr(lpIMC)) return FALSE; if (!ClearCand(lpIMC)) return FALSE; ClearGuideLine(lpIMC); } if (lpIMC->cfCandForm[0].dwIndex != 0) lpIMC->cfCandForm[0].dwStyle = CFS_DEFAULT; // We add this hack for switching from other IMEs, this IME has a bug. // Before this bug fixed in this IME, it depends on this hack. if (lpIMC->cfCandForm[0].dwStyle == CFS_DEFAULT) { lpIMC->cfCandForm[0].dwIndex = (DWORD)-1; } if (!lpIMC->hPrivate) return FALSE; lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate); if (!lpImcP) return FALSE; if (fSelect) { // // init fields of hPrivate // lpImcP->iImeState = CST_INIT; lpImcP->fdwImeMsg = (DWORD)0; lpImcP->dwCompChar = (DWORD)0; lpImcP->fdwGcsFlag = (DWORD)0; lpImcP->uSYHFlg = (UINT)0; lpImcP->uDYHFlg = (UINT)0; lpImcP->uDSMHCount = (UINT)0; lpImcP->uDSMHFlg = (UINT)0; //lpImcP->fdwSentence = (DWORD)NULL; // // reset SK State // *(LPDWORD)lpImcP->bSeq = 0; #ifdef CROSSREF lpImcP->hRevCandList = (HIMCC) NULL; #endif //CROSSREF lpIMC->fOpen = TRUE; if (!(lpIMC->fdwInit & INIT_CONVERSION)) { lpIMC->fdwConversion = (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) | IME_CMODE_NATIVE; lpIMC->fdwInit |= INIT_CONVERSION; } if (lpIMC->fdwInit & INIT_SENTENCE) { } else if (lpImeL->fModeConfig & MODE_CONFIG_PREDICT) { lpIMC->fdwSentence = IME_SMODE_PHRASEPREDICT; lpIMC->fdwInit |= INIT_SENTENCE; } if (!(lpIMC->fdwInit & INIT_LOGFONT)) { HDC hDC; HGDIOBJ hSysFont; //hSysFont = GetStockObject(SYSTEM_FONT); hDC = GetDC(NULL); hSysFont = GetCurrentObject(hDC, OBJ_FONT); GetObject(hSysFont, sizeof(LOGFONT), &lpIMC->lfFont.A); ReleaseDC(NULL, hDC); lpIMC->fdwInit |= INIT_LOGFONT; } InitContext(lpIMC); // // Set Caps status // { DWORD fdwConversion; if (GetKeyState(VK_CAPITAL) & 0x01) { // // Change to alphanumeric mode. // fdwConversion = lpIMC->fdwConversion & ~(IME_CMODE_NATIVE | IME_CMODE_CHARCODE | IME_CMODE_EUDC); } else { // // Change to native mode // fdwConversion = (lpIMC->fdwConversion | IME_CMODE_NATIVE) & ~(IME_CMODE_CHARCODE | IME_CMODE_EUDC ); } ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence); } } else { if (lpImeL->hSKMenu) { DestroyMenu(lpImeL->hSKMenu); lpImeL->hSKMenu = NULL; } if (lpImeL->hPropMenu) { DestroyMenu(lpImeL->hPropMenu); lpImeL->hPropMenu = NULL; } if (hCrtDlg) { SendMessage(hCrtDlg, WM_CLOSE, (WPARAM)NULL, (LPARAM)NULL); hCrtDlg = NULL; } } ImmUnlockIMCC(lpIMC->hPrivate); return (TRUE); } /**********************************************************************/ /* ImeSelect() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL WINAPI ImeSelect( HIMC hIMC, BOOL fSelect) { LPINPUTCONTEXT lpIMC; BOOL fRet; if (!hIMC) { return (FALSE); } lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC); if (!lpIMC) { return (FALSE); } fRet = Select(hIMC, lpIMC, fSelect); ImmUnlockIMC(hIMC); return (fRet); } /**********************************************************************/ /* ImeSetActiveContext() */ /* Return Value: */ /* TRUE - successful, FALSE - failure */ /**********************************************************************/ BOOL WINAPI ImeSetActiveContext( HIMC hIMC, BOOL fOn) { if (!fOn) { } else if (!hIMC) { } else { LPINPUTCONTEXT lpIMC; lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC); if (!lpIMC) { return (FALSE); } InitContext(lpIMC); ImmUnlockIMC(hIMC); } return (TRUE); } /**********************************************************************/ //OpenReg_PathSetup(HKEY *phKey); /**********************************************************************/ LONG OpenReg_PathSetup(HKEY *phKey) { return RegOpenKeyEx (HKEY_CURRENT_USER, REGSTR_PATH_SETUP, 0, KEY_ENUMERATE_SUB_KEYS | KEY_EXECUTE | KEY_QUERY_VALUE, phKey); } /**********************************************************************/ //LONG OpenReg_User(HKEY hKey, // handle of open key // LPCTSTR lpszSubKey, // address of name of subkey to open // PHKEY phkResult); // address of handle of open key /**********************************************************************/ LONG OpenReg_User(HKEY hKey, // handle of open key LPCTSTR lpszSubKey, // address of name of subkey to open PHKEY phkResult) // address of handle of open key { return RegOpenKeyEx (hKey, lpszSubKey, 0, KEY_ALL_ACCESS, phkResult); } VOID InfoMessage(HANDLE hWnd,WORD wMsgID) { TCHAR szStr[256]; LoadString(NULL,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR)); MessageBox(hWnd,szStr,szWarnTitle,MB_ICONINFORMATION|MB_OK); } VOID FatalMessage(HANDLE hWnd,WORD wMsgID) { TCHAR szStr[256]; LoadString(NULL,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR)); MessageBox(hWnd,szStr,szErrorTitle,MB_ICONSTOP|MB_OK); }