726 lines
22 KiB
C
726 lines
22 KiB
C
#include <windows.h>
|
|
#include <setupapi.h>
|
|
#include <malloc.h>
|
|
#include "common.h"
|
|
#include "chs.h"
|
|
extern TCHAR ImeDataDirectory[MAX_PATH];
|
|
extern TCHAR szMsgBuf[];
|
|
extern BOOL g_bCHSWin98;
|
|
|
|
BYTE EmbName[IMENUM][MAXIMENAME]={
|
|
"winpy.emb",
|
|
"winsp.emb",
|
|
"winzm.emb"
|
|
// "winbx.emb"
|
|
};
|
|
|
|
BYTE XEmbName[IMENUM][MAXIMENAME]={
|
|
"winxpy.emb",
|
|
"winxsp.emb",
|
|
"winxzm.emb"
|
|
// "winxbx.emb"
|
|
};
|
|
|
|
BOOL IsSizeReasonable(DWORD dwSize)
|
|
{
|
|
DWORD dwTemp = (dwSize - sizeof(WORD)) / sizeof(REC95);
|
|
|
|
if (((dwSize - sizeof(WORD)) - (dwTemp * sizeof(REC95))) == 0) {
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/******************************Public*Routine******************************\
|
|
* OpenEMBFile
|
|
*
|
|
* Get Win95 IME phrase data from system directory.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* UCHAR * FileName - EMB file name.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* HANDLE: Success - file handle of EMB file. Fail - 0;
|
|
*
|
|
* History:
|
|
*
|
|
\**************************************************************************/
|
|
|
|
HANDLE OpenEMBFile(UCHAR * FileName)
|
|
{
|
|
HFILE hf;
|
|
TCHAR FilePath[MAX_PATH];
|
|
|
|
lstrcpy(FilePath, ImeDataDirectory);
|
|
|
|
lstrcat(FilePath, FileName);
|
|
|
|
hf = _lopen(FilePath,OF_READ);
|
|
if (hf == HFILE_ERROR) {
|
|
DebugMsg(("OpenEMBFile,[%s] failed!\r\n",FileName));
|
|
return 0;
|
|
}
|
|
else {
|
|
DebugMsg(("OpenEMBFile,[%s] OK!\r\n",FileName));
|
|
return (HANDLE)hf;
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* ImeDataConvertChs
|
|
*
|
|
* Convert Windows 95 IME phrase data to Windows NT 5.0.
|
|
*
|
|
* Arguments:
|
|
*
|
|
* HANDLE hSource - source file handle.
|
|
* HANDLE hTarget - target file handle.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* BOOL: TRUE-Success, FALSE-FAIL.
|
|
*
|
|
* History:
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL ImeDataConvertChs(HFILE hSource, HFILE hTarget)
|
|
{
|
|
HANDLE hPhrase95, hPhraseNT;
|
|
BYTE *szPhrase95;
|
|
WCHAR *szPhraseNT;
|
|
DWORD fsize;
|
|
BOOL bReturn = TRUE;
|
|
int i;
|
|
|
|
hPhrase95 = GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,
|
|
sizeof(REC95)*MAXNUMBER_EMB+sizeof(WORD));
|
|
|
|
hPhraseNT = GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,
|
|
sizeof(RECNT)*MAXNUMBER_EMB+sizeof(WORD));
|
|
|
|
if (!hPhraseNT || !hPhrase95 ) {
|
|
DebugMsg(("ImeDataConvertChs failed!,!hPhraseNT || !hPhrase95 \r\n"));
|
|
|
|
bReturn = FALSE;
|
|
goto Convert_Finish;
|
|
}
|
|
|
|
szPhrase95 = GlobalLock(hPhrase95);
|
|
szPhraseNT = GlobalLock(hPhraseNT);
|
|
|
|
fsize = _lread(hSource,szPhrase95,sizeof(REC95)*MAXNUMBER_EMB+sizeof(WORD));
|
|
|
|
if (fsize != *((WORD*)&szPhrase95[0])*sizeof(REC95)+2)
|
|
{
|
|
DebugMsg(("ImeDataConvertChs ,Warnning fsize ! %d, rec no = %d\r\n",fsize,*((WORD *) szPhrase95)));
|
|
|
|
if (IsSizeReasonable(fsize)) {
|
|
*((WORD *) szPhrase95) = (WORD)((fsize - sizeof(WORD)) / sizeof(REC95));
|
|
DebugMsg(("ImeDataConvertChs ,Fixed rec number = %d\r\n",*((WORD *) szPhrase95)));
|
|
} else {
|
|
DebugMsg(("ImeDataConvertChs ,Data file maybe wrong !\r\n"));
|
|
bReturn = FALSE;
|
|
goto Convert_Finish;
|
|
}
|
|
}
|
|
|
|
//phrase count
|
|
szPhraseNT[0] = *((WORD*)&szPhrase95[0]);
|
|
|
|
for (i=0; i<szPhraseNT[0]; i++)
|
|
{
|
|
MultiByteToWideChar(936,
|
|
MB_PRECOMPOSED,
|
|
(LPCSTR)(szPhrase95+sizeof(WORD)+i*sizeof(REC95)),
|
|
sizeof(REC95),
|
|
(LPWSTR)((LPBYTE)szPhraseNT+ sizeof(WORD) + i*sizeof(RECNT)),
|
|
sizeof(RECNT));
|
|
}
|
|
if (WriteFile((HANDLE)hTarget, szPhraseNT, sizeof(RECNT)*MAXNUMBER_EMB+sizeof(WORD), &fsize, NULL)) {
|
|
DebugMsg(("ImeDataConvertChs WriteFile OK\r\n"));
|
|
}
|
|
else {
|
|
DebugMsg(("ImeDataConvertChs WriteFile Failed [%d]\r\n",GetLastError()));
|
|
}
|
|
|
|
Convert_Finish:
|
|
if (hPhrase95) {
|
|
GlobalUnlock(hPhrase95);
|
|
GlobalFree(hPhrase95);
|
|
}
|
|
if (hPhraseNT) {
|
|
GlobalUnlock(hPhraseNT);
|
|
GlobalFree(hPhraseNT);
|
|
}
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL IsFileExist(LPCTSTR lpszFileName)
|
|
{
|
|
LONG lResult;
|
|
|
|
lResult = GetFileAttributes(lpszFileName);
|
|
|
|
if (lResult == 0xFFFFFFFF) { // file does not exist
|
|
return FALSE;
|
|
} else if (lResult & FILE_ATTRIBUTE_DIRECTORY) {
|
|
return FALSE;
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
LPBYTE MergeGBandGBKEMBWorker(
|
|
PBYTE pGBEmbPtr,
|
|
PBYTE pGBKEmbPtr)
|
|
{
|
|
PBYTE pNewBufPtr;
|
|
|
|
WORD nGBRecNum;
|
|
WORD nGBKRecNum;
|
|
|
|
REC95* pGBRecPtr;
|
|
REC95* pGBKRecPtr;
|
|
|
|
WORD nNewRecNum;
|
|
|
|
WORD i,j;
|
|
|
|
if (pGBEmbPtr == NULL || pGBKEmbPtr == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
nGBRecNum = * ((WORD *) pGBEmbPtr);
|
|
pGBRecPtr = (REC95*)(pGBEmbPtr + sizeof(WORD));
|
|
|
|
nGBKRecNum = * ((WORD *) pGBKEmbPtr);
|
|
pGBKRecPtr = (REC95*)(pGBKEmbPtr + sizeof(WORD));
|
|
|
|
nNewRecNum = 0;
|
|
pNewBufPtr = (PBYTE) malloc(sizeof(WORD));
|
|
|
|
if (pNewBufPtr == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
for (i=0,j=0; i<nGBRecNum && j<nGBKRecNum; ) {
|
|
int nResult;
|
|
|
|
nNewRecNum++;
|
|
pNewBufPtr = (PBYTE) realloc(pNewBufPtr,sizeof(WORD)+(nNewRecNum)*sizeof(REC95));
|
|
|
|
DebugMsg(("MergeGBandGBKEMBWorker,Memory size = [%d]!\r\n",_msize(pNewBufPtr)));
|
|
|
|
if (pNewBufPtr == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWorker,realloc error,[%d]!\r\n",GetLastError()));
|
|
return NULL;
|
|
}
|
|
nResult = memcmp(pGBRecPtr[i].CODE,pGBKRecPtr[j].CODE,MAXCODELENTH);
|
|
|
|
DebugMsg(("1. %s, %s\n2. %s, %s\n%d\n",pGBRecPtr[i].CODE,pGBRecPtr[i].PHRASE,pGBKRecPtr[j].CODE,pGBKRecPtr[j].PHRASE,nResult));
|
|
|
|
if (nResult < 0) {
|
|
CopyMemory(pNewBufPtr+sizeof(WORD)+(nNewRecNum-1)*sizeof(REC95),
|
|
&pGBRecPtr[i],
|
|
sizeof(REC95));
|
|
i++;
|
|
} else if (nResult == 0) {
|
|
nResult = memcmp(pGBRecPtr[i].PHRASE,pGBKRecPtr[j].PHRASE,MAXWORDLENTH);
|
|
if (nResult == 0) {
|
|
j++;
|
|
}
|
|
|
|
CopyMemory(pNewBufPtr+sizeof(WORD)+(nNewRecNum-1)*sizeof(REC95),
|
|
&pGBRecPtr[i],
|
|
sizeof(REC95));
|
|
i++;
|
|
|
|
|
|
} else {
|
|
memcpy(pNewBufPtr+sizeof(WORD)+(nNewRecNum-1)*sizeof(REC95),
|
|
&pGBKRecPtr[j],
|
|
sizeof(REC95));
|
|
j++;
|
|
}
|
|
|
|
}
|
|
DebugMsg(("MergeGBandGBKEMBWorker [%d,%d ] i=%d, j=%d!\r\n",nGBRecNum,nGBKRecNum,i,j));
|
|
|
|
if (i == nGBRecNum && j == nGBKRecNum) {
|
|
* (WORD*)pNewBufPtr = nNewRecNum;
|
|
DebugMsg((szMsgBuf,"nNewRecNum = %d",* (WORD*)pNewBufPtr));
|
|
return pNewBufPtr;
|
|
}
|
|
|
|
if (i==nGBRecNum) {
|
|
for ( ; j<nGBKRecNum;j++) {
|
|
|
|
nNewRecNum++;
|
|
pNewBufPtr = (PBYTE) realloc(pNewBufPtr,sizeof(WORD)+(nNewRecNum)*sizeof(REC95));
|
|
if (pNewBufPtr == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWorker,2.realloc error,[%d]!\r\n",GetLastError()));
|
|
return NULL;
|
|
}
|
|
CopyMemory(pNewBufPtr+sizeof(WORD)+(nNewRecNum-1)*sizeof(REC95),
|
|
&pGBKRecPtr[j],
|
|
sizeof(REC95));
|
|
}
|
|
} else {
|
|
for ( ; i<nGBRecNum;i++) {
|
|
|
|
nNewRecNum++;
|
|
pNewBufPtr = (PBYTE) realloc(pNewBufPtr,sizeof(WORD)+(nNewRecNum)*sizeof(REC95));
|
|
if (pNewBufPtr == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWorker,3.realloc error,[%d]!\r\n",GetLastError()));
|
|
return NULL;
|
|
}
|
|
CopyMemory(pNewBufPtr+sizeof(WORD)+(nNewRecNum-1)*sizeof(REC95),
|
|
&pGBRecPtr[i],
|
|
sizeof(REC95));
|
|
}
|
|
}
|
|
*(WORD *)pNewBufPtr = nNewRecNum;
|
|
DebugMsg(("nNewRecNum = %d\r\n",* (WORD*)pNewBufPtr));
|
|
|
|
return pNewBufPtr;
|
|
}
|
|
|
|
BOOL MergeGBandGBKEMBWrapper(
|
|
LPCTSTR lpszGBFileName,
|
|
LPCTSTR lpszGBKFileName,
|
|
LPCTSTR lpszNewFileName)
|
|
{
|
|
HANDLE hGBEmb;
|
|
HANDLE hGBKEmb;
|
|
|
|
HANDLE hGBEmbMapping;
|
|
HANDLE hGBKEmbMapping;
|
|
|
|
PBYTE pGBEmbPtr;
|
|
PBYTE pGBKEmbPtr;
|
|
PBYTE pNewFilePtr;
|
|
|
|
HANDLE hNewFile;
|
|
DWORD dwByteWritten;
|
|
BOOL bRet =FALSE;
|
|
|
|
DWORD dwSizeGB,dwSizeGBK,dwHigh;
|
|
|
|
DebugMsg(("MergeGBandGBKEMBWrapper, Starting ...!\r\n"));
|
|
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,lpszGBFileName=%s!\r\n",lpszGBFileName));
|
|
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,lpszGBKFileName=%s!\r\n",lpszGBKFileName));
|
|
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,lpszNewFileName=%s!\r\n",lpszNewFileName));
|
|
|
|
hGBEmb = CreateFile(lpszGBFileName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
if (hGBEmb == INVALID_HANDLE_VALUE) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,CreateFile error=%s,[%d]!\r\n",lpszGBFileName,GetLastError()));
|
|
goto Err0;
|
|
}
|
|
|
|
hGBKEmb = CreateFile(lpszGBKFileName,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hGBKEmb == INVALID_HANDLE_VALUE) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,CreateFile error=%s,[%d]!\r\n",lpszGBKFileName,GetLastError()));
|
|
goto Err1;
|
|
}
|
|
|
|
|
|
hGBEmbMapping = CreateFileMapping(hGBEmb,
|
|
NULL,
|
|
PAGE_READWRITE,
|
|
0,0,0);
|
|
|
|
if (hGBEmbMapping == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,1. CreateFileMapping error,[%d]!\r\n",GetLastError()));
|
|
goto Err2;
|
|
}
|
|
|
|
hGBKEmbMapping = CreateFileMapping(hGBKEmb,
|
|
NULL,
|
|
PAGE_READWRITE,
|
|
0,0,0);
|
|
|
|
|
|
if (hGBKEmbMapping == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,2. CreateFileMapping error,[%d]!\r\n",GetLastError()));
|
|
goto Err3;
|
|
}
|
|
|
|
pGBEmbPtr = (PBYTE) MapViewOfFile(hGBEmbMapping,
|
|
FILE_MAP_ALL_ACCESS,
|
|
0,0,0);
|
|
|
|
if (pGBEmbPtr == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,1. MapViewOfFile error,[%d]!\r\n",GetLastError()));
|
|
goto Err3;
|
|
}
|
|
|
|
pGBKEmbPtr = (PBYTE) MapViewOfFile(hGBKEmbMapping,
|
|
FILE_MAP_ALL_ACCESS,
|
|
0,0,0);
|
|
|
|
if (pGBKEmbPtr == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,2. MapViewOfFile error,[%d]!\r\n",GetLastError()));
|
|
goto Err4;
|
|
}
|
|
|
|
dwSizeGB = GetFileSize(hGBEmb,&dwHigh);
|
|
dwSizeGBK = GetFileSize(hGBKEmb,&dwHigh);
|
|
|
|
|
|
if (dwSizeGB != (sizeof(WORD)+sizeof(REC95) * (*(WORD *)pGBEmbPtr ))) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper: Warnning Real table size is different from info in record\r\n"));
|
|
|
|
DebugMsg(("[%s] sizeGB = %d, no=%d, calculated = %d\r\n",lpszGBFileName,
|
|
dwSizeGB,
|
|
*(WORD *)pGBEmbPtr,
|
|
sizeof(WORD)+sizeof(REC95) * (*(WORD *)pGBEmbPtr)
|
|
));
|
|
if (IsSizeReasonable(dwSizeGB) == FALSE) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper: Fatal error, file size is strange %d we need to give up this %s!\r\n",dwSizeGB,lpszGBFileName));
|
|
goto Err5;
|
|
}
|
|
|
|
(*(WORD *)pGBEmbPtr) = (WORD) ((dwSizeGB - sizeof(WORD)) / sizeof(REC95));
|
|
DebugMsg((
|
|
"MergeGBandGBKEMBWrapper: Adjust record number = %d\r\n",(*(WORD *)pGBEmbPtr)
|
|
));
|
|
}
|
|
|
|
if (dwSizeGBK != (sizeof(WORD)+sizeof(REC95) * (*(WORD *)pGBKEmbPtr ))) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper: Warnning Real table size is different from info in record\r\n"));
|
|
|
|
DebugMsg(("[%s] sizeGBK = %d, no=%d, calculated = %d\r\n",lpszGBKFileName,
|
|
dwSizeGBK,
|
|
*(WORD *)pGBKEmbPtr,
|
|
sizeof(WORD)+sizeof(REC95) * (*(WORD *)pGBKEmbPtr)
|
|
));
|
|
if (IsSizeReasonable(dwSizeGBK) == FALSE) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper: Fatal error, file size is strange %d we need to give up this %s!\r\n",dwSizeGBK,lpszGBKFileName));
|
|
goto Err5;
|
|
}
|
|
|
|
(*(WORD *)pGBKEmbPtr) = (WORD) ((dwSizeGBK - sizeof(WORD)) / sizeof(REC95));
|
|
DebugMsg(("MergeGBandGBKEMBWrapper: Adjust record number = %d\r\n",(*(WORD *)pGBKEmbPtr)));
|
|
}
|
|
|
|
pNewFilePtr = MergeGBandGBKEMBWorker(pGBEmbPtr,pGBKEmbPtr);
|
|
|
|
if (pNewFilePtr == NULL) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,MergeGBandGBKEMBWorker[%s,%s] error,[%d]!\r\n",
|
|
lpszGBFileName,lpszGBKFileName,GetLastError()));
|
|
goto Err5;
|
|
}
|
|
|
|
hNewFile = CreateFile(lpszNewFileName,
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL);
|
|
|
|
if (hNewFile == INVALID_HANDLE_VALUE) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,CreateFile error %s,[%d]!\r\n",lpszNewFileName,GetLastError()));
|
|
goto Err5;
|
|
}
|
|
|
|
if (WriteFile(hNewFile,
|
|
pNewFilePtr,
|
|
sizeof(WORD)+ *((WORD *) pNewFilePtr) * sizeof(REC95),
|
|
&dwByteWritten,
|
|
NULL) == 0) {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,WriteFile error %s,[%d]!\r\n",lpszNewFileName,GetLastError()));
|
|
goto Err6;
|
|
} else {
|
|
DebugMsg(("MergeGBandGBKEMBWrapper,WriteFile %s OK !\r\n",lpszNewFileName));
|
|
}
|
|
|
|
free (pNewFilePtr);
|
|
|
|
bRet = TRUE;
|
|
|
|
Err6:
|
|
CloseHandle(hNewFile);
|
|
Err5:
|
|
UnmapViewOfFile(pGBKEmbPtr);
|
|
Err4:
|
|
UnmapViewOfFile(pGBEmbPtr);
|
|
Err3:
|
|
CloseHandle(hGBEmbMapping);
|
|
Err2:
|
|
CloseHandle(hGBKEmb);
|
|
Err1:
|
|
CloseHandle(hGBEmb);
|
|
Err0:
|
|
DebugMsg(("MergeGBandGBKEMBWrapper, Finished ...!\r\n"));
|
|
return bRet;
|
|
|
|
}
|
|
|
|
BOOL MergeGBandGBKEMB(LPCTSTR lpszSourcePath)
|
|
//
|
|
// Warnning, lpszSourcePath, this string must be ended with "\"
|
|
//
|
|
{
|
|
int i;
|
|
|
|
TCHAR szGBEmbPath[MAX_PATH];
|
|
TCHAR szGBKEmbPath[MAX_PATH];
|
|
TCHAR szTmpEMBPath[MAX_PATH];
|
|
|
|
UINT uFileExistingStatus = 0;
|
|
|
|
DebugMsg(("MergeGBandGBKEMB,Starting ...!\r\n"));
|
|
DebugMsg(("MergeGBandGBKEMB, lpszSourcePath = %s!\r\n",lpszSourcePath));
|
|
|
|
for (i=0; i<IMENUM; i++) {
|
|
lstrcpy(szGBEmbPath,lpszSourcePath);
|
|
lstrcat(szGBEmbPath,EmbName[i]);
|
|
|
|
lstrcpy(szGBKEmbPath,lpszSourcePath);
|
|
lstrcat(szGBKEmbPath,XEmbName[i]);
|
|
|
|
if (IsFileExist(szGBEmbPath)) {
|
|
uFileExistingStatus |= 1;
|
|
DebugMsg(("MergeGBandGBKEMB,EMB %s exsiting !\r\n",szGBEmbPath));
|
|
} else {
|
|
DebugMsg(("MergeGBandGBKEMB,EMB %s not exsiting !\r\n",szGBEmbPath));
|
|
}
|
|
|
|
if (IsFileExist(szGBKEmbPath)) {
|
|
uFileExistingStatus |= 2;
|
|
DebugMsg(("MergeGBandGBKEMB,EMB %s exsiting !\r\n",szGBKEmbPath));
|
|
} else {
|
|
DebugMsg(("MergeGBandGBKEMB,EMB %s not exsiting !\r\n",szGBKEmbPath));
|
|
}
|
|
|
|
lstrcpy(szTmpEMBPath,szGBEmbPath);
|
|
lstrcat(szTmpEMBPath,TEXT("_"));
|
|
|
|
switch (uFileExistingStatus) {
|
|
case 1: // only GB emb
|
|
if (CopyFile(szGBEmbPath,szTmpEMBPath,FALSE)) {
|
|
DebugMsg(("MergeGBandGBKEMB,copy %s to %s OK!\r\n",szGBEmbPath,szTmpEMBPath));
|
|
} else {
|
|
DebugMsg(("MergeGBandGBKEMB,copy %s to %s failed!\r\n",szGBEmbPath,szTmpEMBPath));
|
|
}
|
|
break;
|
|
case 2: // only GBK emb
|
|
if (CopyFile(szGBKEmbPath,szTmpEMBPath,FALSE)) {
|
|
DebugMsg(("MergeGBandGBKEMB,copy %s to %s OK!\r\n",szGBKEmbPath,szTmpEMBPath));
|
|
} else {
|
|
DebugMsg(("MergeGBandGBKEMB,copy %s to %s failed!\r\n",szGBKEmbPath,szTmpEMBPath));
|
|
}
|
|
break;
|
|
case 3: // both
|
|
if (MergeGBandGBKEMBWrapper(szGBEmbPath,szGBKEmbPath,szTmpEMBPath)) {
|
|
DebugMsg(("MergeGBandGBKEMB,merge %s , %s to %s OK!\r\n",szGBEmbPath,szGBKEmbPath,szTmpEMBPath));
|
|
} else {
|
|
DebugMsg(("MergeGBandGBKEMB,merge %s , %s to %s failed!\r\n",szGBEmbPath,szGBKEmbPath,szTmpEMBPath));
|
|
}
|
|
break;
|
|
case 0: // none of them
|
|
default:
|
|
DebugMsg(("MergeGBandGBKEMB,None of them !\r\n"));
|
|
|
|
continue;
|
|
}
|
|
|
|
}
|
|
DebugMsg(("MergeGBandGBKEMB,Finished ...!\r\n"));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Test above routines.
|
|
BOOL ConvertChsImeData(void)
|
|
{
|
|
HANDLE hs, ht;
|
|
int i,len;
|
|
TCHAR szName[MAX_PATH];
|
|
TCHAR szMergedName[MAX_PATH];
|
|
TCHAR szMigTempDir[MAX_PATH];
|
|
TCHAR szSys32Dir[MAX_PATH];
|
|
LPSTR pszMigTempDirPtr;
|
|
LPSTR pszSys32Ptr;
|
|
|
|
|
|
//
|
|
// Get Winnt System 32 directory
|
|
//
|
|
len = GetSystemDirectory((LPSTR)szSys32Dir, MAX_PATH);
|
|
if (szSys32Dir[len - 1] != '\\') { // consider C:\ ;
|
|
szSys32Dir[len++] = '\\';
|
|
szSys32Dir[len] = 0;
|
|
}
|
|
DebugMsg(("ConvertChsImeData, System Directory = %s !\r\n",szSys32Dir));
|
|
|
|
//
|
|
// detect if IME98 directory there, if it is,
|
|
// then just copy files to system32 dir from temporary dir
|
|
// because Win98 IME's EMB tables are compatibile with NT
|
|
//
|
|
lstrcpy(szMigTempDir,ImeDataDirectory);
|
|
|
|
if (g_bCHSWin98) {
|
|
|
|
DebugMsg(("ConvertChsImeData ,This is win98 !\r\n"));
|
|
|
|
pszMigTempDirPtr = szMigTempDir+lstrlen(szMigTempDir);
|
|
pszSys32Ptr = szSys32Dir+lstrlen(szSys32Dir);
|
|
|
|
for (i=0; i<IMENUM; i++) {
|
|
lstrcat(pszMigTempDirPtr,EmbName[i]);
|
|
lstrcat(pszSys32Ptr,EmbName[i]);
|
|
if (CopyFile(szMigTempDir,szSys32Dir,FALSE)) {
|
|
DebugMsg(("ConvertChsImeData,copy %s to %s OK!\r\n",szMigTempDir,szSys32Dir));
|
|
} else {
|
|
DebugMsg(("ConvertChsImeData,doesn't copy %s to %s !\r\n",szMigTempDir,szSys32Dir));
|
|
}
|
|
*pszMigTempDirPtr = TEXT('\0');
|
|
*pszSys32Ptr = TEXT('\0');
|
|
}
|
|
return TRUE;
|
|
}
|
|
//
|
|
// end of detecting Win98
|
|
//
|
|
|
|
//
|
|
// if you're here, then it means we're not doing CHS win98 migration
|
|
//
|
|
// then we need to convert EMB to be compatibile with NT
|
|
//
|
|
if (! MergeGBandGBKEMB(ImeDataDirectory)) {
|
|
DebugMsg(("ConvertChsImeData, calling MergeGBandGBKEMB failed !\r\n"));
|
|
}
|
|
else {
|
|
DebugMsg(("ConvertChsImeData, calling MergeGBandGBKEMB OK !\r\n"));
|
|
}
|
|
|
|
for (i=0; i< IMENUM; i++)
|
|
{
|
|
lstrcpy(szMergedName,EmbName[i]);
|
|
lstrcat(szMergedName,TEXT("_"));
|
|
if (hs = OpenEMBFile(szMergedName))
|
|
{
|
|
|
|
lstrcat(szSys32Dir, EmbName[i]);
|
|
|
|
ht = CreateFile(szSys32Dir,
|
|
GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_NEW,
|
|
FILE_ATTRIBUTE_ARCHIVE, NULL);
|
|
|
|
DebugMsg(("ConvertChsImeData, ImeDataConvertChs Old = %s,New = %s!\r\n",szMergedName,szSys32Dir));
|
|
ImeDataConvertChs((HFILE)hs, (HFILE)ht);
|
|
CloseHandle(hs);
|
|
CloseHandle(ht);
|
|
szSys32Dir[len]=0;
|
|
}
|
|
else {
|
|
if (GetLastError() != ERROR_FILE_NOT_FOUND) {
|
|
DebugMsg(("ConvertChsImeData failed!\r\n"));
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CHSBackupWinABCUserDict(LPCTSTR lpszSourcePath)
|
|
{
|
|
TCHAR szDstName[MAX_PATH];
|
|
TCHAR szSrcName[MAX_PATH];
|
|
int len;
|
|
|
|
int i;
|
|
TCHAR ChsDataFile[4][15]={"winbx.emb",
|
|
"winxbx.emb",
|
|
"user.rem",
|
|
"tmmr.rem"};
|
|
|
|
for (i=0; i<4; i++) {
|
|
lstrcpy(szSrcName,lpszSourcePath);
|
|
ConcatenatePaths(szSrcName,ChsDataFile[i],MAX_PATH);
|
|
|
|
if (! IsFileExist(szSrcName)) {
|
|
DebugMsg(("CHSBackupWinABCUserDict, no user dic file, %s!\r\n",szSrcName));
|
|
continue;
|
|
}
|
|
|
|
len = GetSystemDirectory((LPSTR)szDstName, MAX_PATH);
|
|
ConcatenatePaths(szDstName,ChsDataFile[i],MAX_PATH);
|
|
|
|
if (CopyFile(szSrcName,szDstName,FALSE)) {
|
|
DebugMsg(("CHSBackupWinABCUserDict,copy %s to %s OK!\r\n",szSrcName,szDstName));
|
|
} else {
|
|
DebugMsg(("CHSBackupWinABCUserDict,copy %s to %s failed!\r\n",szSrcName,szDstName));
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CHSDeleteGBKKbdLayout()
|
|
{
|
|
#define ID_LEN 9
|
|
TCHAR szKeyboardLayouts[][ID_LEN] = {"E0060804",
|
|
"E0070804",
|
|
"E0080804"
|
|
// "E0090804",
|
|
};
|
|
|
|
HKEY hKey;
|
|
LONG lResult;
|
|
int i;
|
|
|
|
|
|
lResult = RegOpenKey(HKEY_LOCAL_MACHINE,
|
|
TEXT("System\\CurrentControlSet\\Control\\Keyboard Layouts"),
|
|
&hKey);
|
|
|
|
if (lResult != ERROR_SUCCESS) {
|
|
DebugMsg(("CHSDeleteGBKKbdLayout, Open keyboard layout registry failed failed [%d] !\r\n",lResult));
|
|
return FALSE;
|
|
}
|
|
|
|
for (i=0; i<sizeof(szKeyboardLayouts) / ID_LEN; i++) {
|
|
lResult = RegDeleteKey(hKey,szKeyboardLayouts[i]);
|
|
if (lResult != ERROR_SUCCESS) {
|
|
DebugMsg(("CHSDeleteGBKKbdLayout, Delete key %s failed %X!\r\n",szKeyboardLayouts[i],lResult));
|
|
}
|
|
else {
|
|
DebugMsg(("CHSDeleteGBKKbdLayout, Delete key %s OK %X!\r\n",szKeyboardLayouts[i]));
|
|
}
|
|
}
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
|
|
|