开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 输入法编程 > 查看源码
subs.c
资源名称：大熊猫输入法原码.zip　[点击查看]
上传用户：szljw888
上传日期：2010-04-11
资源大小：124k
文件大小：33k
源码类别：

输入法编程

开发平台：

C/C++

subs.c：源码内容
  1. /* 大熊猫输入法(Free Chinese Input)  由YJMSIR(yjmsir@163.com)编写
  2.  * 协议: GPL
  3.  * freeinput( A Chinese Input Method) by YJMSIR(yjmsir@163.com)
  4.  * Licence: GPL 
  5.  */
  7. #include "freepy.h"
  9. void GetRelativeTableDirList()
  10. {
  11. WIN32_FIND_DATA ffd;
  12. char szDirFile[1024];
  13. HANDLE hFind;
  14. sprintf(szDirFile,"%s//mb//*",InstallFromDir);
  15. hFind = FindFirstFile(szDirFile,&ffd);
  16. if (hFind != INVALID_HANDLE_VALUE)
  17. {
  18. int i=0;
  19. if(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY &&
  20. strcmp(ffd.cFileName,".") && 
  21. strcmp(ffd.cFileName,".."))
  22. {//确定找到一个目录并且不为 . 或 ..
  23. sprintf(RelativeTableDirList[i],"%s",ffd.cFileName);
  24. i++;
  25. }
  26. while(FindNextFile(hFind,&ffd))
  27. {
  28. if(ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY &&
  29. strcmp(ffd.cFileName,".") && 
  30. strcmp(ffd.cFileName,".."))
  31. {//确定找到一个目录并且不为 . 或 ..
  32. sprintf(RelativeTableDirList[i],"%s",ffd.cFileName);
  33. i++;
  34. }
  35. }
  36. FindClose(hFind);
  37. }
  38. }
  39. BOOL IsFileExist(LPCSTR pszFileName)
  40. {
  41.   WIN32_FIND_DATA FindFileData;
  42.   HANDLE hFind;
  44.   hFind = FindFirstFile(pszFileName, &FindFileData);
  46.   if (hFind == INVALID_HANDLE_VALUE) 
  47.       return FALSE;//not found
  48.   else
  49.   {
  50.       FindClose(hFind);
  51.       return TRUE;//found it
  52.   }
  53. }
  55. void ReadRegRecord()
  56. {
  57. HKEY hKey;
  58. DWORD dwData = sizeof(DWORD),dwData1 = MAX_PATH,dwData2 = MAX_PATH;
  59. if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  60. REGKEYNAME,
  61. 0,
  62. KEY_READ,
  63. &hKey) == ERROR_SUCCESS ){
  65. RegQueryValueEx( hKey,
  66. _T("InstallFromDir"),
  67. NULL,
  68. NULL,
  69. (LPBYTE)InstallFromDir,
  70. &dwData1);
  71. }
  72. RegCloseKey(hKey);
  73. }
  75. BOOL IsIMEOpen(HIMC hIMC)//输入法是否打开
  76. {
  77. BOOL fOpen;
  78. LPINPUTCONTEXT lpIMC;
  79. if (!(lpIMC = ImmLockIMC(hIMC)))
  80. return FALSE;
  82. fOpen = lpIMC->fOpen;
  83. ImmUnlockIMC(hIMC);
  84. return fOpen;
  85. }
  87. BOOL IsCompStr(HIMC hIMC)
  88. {
  89.     LPINPUTCONTEXT lpIMC;
  90.     LPCOMPOSITIONSTRING lpCompStr;
  91.     BOOL fRet = FALSE;
  93.     if (!(lpIMC = ImmLockIMC(hIMC)))
  94.         return FALSE;
  96.     if (ImmGetIMCCSize(lpIMC->hCompStr) < sizeof (COMPOSITIONSTRING))
  97.     {
  98.         ImmUnlockIMC(hIMC);
  99.         return FALSE;
  100.     }
  102.     lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  104.     fRet = (lpCompStr->dwCompStrLen > 0);
  106.     ImmUnlockIMCC(lpIMC->hCompStr);
  107.     ImmUnlockIMC(hIMC);
  109.     return fRet;
  110. }
  112. /**********************************************************************/
  113. /*                                                                    */
  114. /*      InitCompStr()                                                  */
  115. /*                                                                    */
  116. /**********************************************************************/
  117. void InitCompStr(LPCOMPOSITIONSTRING lpCompStr)
  118. {
  119. LPFREEPYCOMP lpFreePYComp;
  121. lpCompStr->dwSize = sizeof(MYCOMPSTR);
  123. lpCompStr->dwCompStrOffset = 
  124.             (DWORD)((LPMYCOMPSTR)lpCompStr)->szCompStr - (DWORD)lpCompStr;
  125. lpCompStr->dwCompStrLen = 0;
  126. *GETLPCOMPSTR(lpCompStr) = _T('');
  128. lpCompStr->dwResultStrOffset = 
  129.           (DWORD)((LPMYCOMPSTR)lpCompStr)->szResultStr - (DWORD)lpCompStr;
  130. lpCompStr->dwResultStrLen = 0;
  131. *GETLPRESULTSTR(lpCompStr) = _T('');
  133. lpCompStr->dwCursorPos = 0;
  135. lpFreePYComp= &(((LPMYCOMPSTR)lpCompStr)->FreePYComp);
  136. lpFreePYComp->szConvCompStr[0] = _T('');
  137. lpFreePYComp->szPaintCompStr[0] = _T('');
  138. lpFreePYComp->szPreResultStr[0] = _T('');
  139. lpFreePYComp->wEditCaret = 0;
  140. lpFreePYComp->wUnConvPos = 0;
  141. lpFreePYComp->wPYArrayLen = 0;
  142. lpFreePYComp->wPYArrayCurPos = 0;
  143. }
  145. void ClearCompStr(LPCOMPOSITIONSTRING lpCompStr)
  146. {
  147. LPFREEPYCOMP lpFreePYComp;
  149. lpCompStr->dwCursorPos = 0;
  150. lpCompStr->dwCompStrLen = 0;
  151. ((LPMYCOMPSTR)lpCompStr)->szCompStr[0] = _T('');
  152. lpCompStr->dwResultStrLen = 0;
  153. ((LPMYCOMPSTR)lpCompStr)->szResultStr[0] = _T('');
  155. lpFreePYComp= &(((LPMYCOMPSTR)lpCompStr)->FreePYComp);
  156. lpFreePYComp->szConvCompStr[0] = _T('');
  157. lpFreePYComp->szPaintCompStr[0] = _T('');
  158. lpFreePYComp->wEditCaret = 0;
  159. lpFreePYComp->wUnConvPos = 0;
  160. lpFreePYComp->wPYArrayLen = 0;
  161. lpFreePYComp->wPYArrayCurPos = 0;
  162. }
  164. BOOL IsCandidate(HIMC hIMC)
  165. {
  166.     LPINPUTCONTEXT lpIMC;
  167.     LPCANDIDATEINFO lpCandInfo;
  168. LPCANDIDATELIST lpCandList;
  169.     BOOL fRet = FALSE;
  171.     if (!(lpIMC = ImmLockIMC(hIMC)))
  172.         return FALSE;
  174.     if (ImmGetIMCCSize(lpIMC->hCandInfo) < sizeof (CANDIDATEINFO)){
  175. ImmUnlockIMC(hIMC);
  176.         return FALSE;
  177. }
  179.     lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  180. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  182.     fRet = (lpCandList->dwCount > 0);
  184.     ImmUnlockIMCC(lpIMC->hCandInfo);
  185. ImmUnlockIMC(hIMC);
  186.     return fRet;
  187. }
  189. void InitCandInfo(LPCANDIDATEINFO lpCandInfo)
  190. {
  191. LPCANDIDATELIST lpCandList;
  192. LPFREEPYCAND lpFreePYCand;
  193. int i;
  195. lpCandInfo->dwSize = sizeof(MYCAND);
  196. lpCandInfo->dwCount = 1;
  197. lpCandInfo->dwOffset[0] = (DWORD)(&(((LPMYCAND)lpCandInfo)->cl)) - (DWORD)lpCandInfo;
  199. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo + lpCandInfo->dwOffset[0]);
  200. for(i=0;i<MAXCANDSTRNUM;i++) {
  201. lpCandList->dwOffset[i] = (DWORD)((LPMYCAND)lpCandInfo)->szCandStr[i] - (DWORD)lpCandList;
  202. }
  203. lpCandList->dwSize = sizeof(MYCAND) - sizeof(CANDIDATEINFO); 
  204. lpCandList->dwCount = 0L;
  205. lpCandList->dwSelection = 0L;
  206. lpCandList->dwPageStart = 0L;
  207. lpCandList->dwPageSize = 0L;
  209. lpFreePYCand= &(((LPMYCAND)lpCandInfo)->FreePYCand);
  210. lpFreePYCand->wPhraseNum = 0;
  211. lpFreePYCand->wHZNum = 0;
  212. lpFreePYCand->wKeyLen = 0;
  213. lpFreePYCand->awKey[0] = 0;
  214. }
  216. void ClearCandidate(LPCANDIDATEINFO lpCandInfo)
  217. {
  218. LPFREEPYCAND lpFreePYCand;
  220.     ((LPMYCAND)lpCandInfo)->cl.dwCount =0L;
  221.     ((LPMYCAND)lpCandInfo)->cl.dwSelection =0L;
  222.     ((LPMYCAND)lpCandInfo)->cl.dwPageStart =0L;
  223.     ((LPMYCAND)lpCandInfo)->cl.dwPageSize =0L;
  225. lpFreePYCand= &(((LPMYCAND)lpCandInfo)->FreePYCand);
  226. lpFreePYCand->wPhraseNum = 0;
  227. lpFreePYCand->wHZNum = 0;
  228. lpFreePYCand->wKeyLen = 0;
  229. lpFreePYCand->awKey[0] = 0;
  230. }
  232. HKL GetMyHKL()
  233. {
  234.     DWORD dwSize;
  235.     DWORD dwi;
  236.     HKL hKL = 0;
  237.     HKL *lphkl;
  239.     dwSize = GetKeyboardLayoutList(0, NULL);
  241.     lphkl = (HKL *)GlobalAlloc(GPTR, dwSize * sizeof(DWORD));
  243.     if (!lphkl)
  244.         return NULL;
  246.     GetKeyboardLayoutList(dwSize, lphkl);
  249.     for (dwi = 0; dwi < dwSize; dwi++)
  250.     {
  251.         char szFile[32];
  252.         HKL hKLTemp = *(lphkl + dwi);
  253.         ImmGetIMEFileName(hKLTemp, szFile, sizeof(szFile));
  255.         if (!_tcsicmp(szFile, FREEPYFILENAME))
  256.         {
  257.              hKL = hKLTemp;
  258.              goto exit;
  259.         }
  260.     }
  261. exit:
  263.     GlobalFree((HANDLE)lphkl);
  264.     return hKL;
  265. }
  266. /*****************************************************************************
  267. *                                                                            *
  268. * UpdateIndicIcon( hIMC )                                                    *
  269. *                                                                            *
  270. *****************************************************************************/
  271. void UpdateIndicIcon(HIMC hIMC)
  272. {
  273.     HWND hwndIndicate;
  274.     BOOL fOpen = FALSE;
  275.     LPINPUTCONTEXT lpIMC;
  277.     if (!hFreePYKL)
  278.     {
  279.        hFreePYKL = GetMyHKL();
  280.        if (!hFreePYKL)
  281.            return;
  282.     }
  284.     hwndIndicate = FindWindow(INDICATOR_CLASS, NULL);
  286.     if (hIMC)
  287.     {
  288.         lpIMC = ImmLockIMC(hIMC);
  289.         if (lpIMC)
  290.         {
  291.             fOpen = lpIMC->fOpen;
  292.             ImmUnlockIMC(hIMC);
  293.         }
  294.     }
  296.     if (IsWindow(hwndIndicate))
  297.     {
  298.         ATOM atomTip;
  300.         atomTip = GlobalAddAtom(ATOMTIP1);
  301.         PostMessage(hwndIndicate, INDICM_SETIMEICON, 
  302.                     fOpen ? 1 : (-1), (LPARAM)hFreePYKL);
  303.         PostMessage(hwndIndicate, INDICM_SETIMETOOLTIPS, 
  304.                     fOpen ? atomTip : (-1), (LPARAM)hFreePYKL);
  305.         PostMessage(hwndIndicate, INDICM_REMOVEDEFAULTMENUITEMS, 
  306.                     // fOpen ? (RDMI_LEFT | RDMI_RIGHT) : 0, (LPARAM)hMyKL);
  307.                     fOpen ? (RDMI_LEFT) : 0, (LPARAM)hFreePYKL);
  308.     }
  309. }
  311. /**********************************************************************/
  312. /*                                                                    */
  313. /* MyIsIMEMessage(message)                                            */
  314. /*                                                                    */
  315. /* Any UI window should not pass the IME messages to DefWindowProc.   */
  316. /*                                                                    */
  317. /**********************************************************************/
  318. BOOL MyIsIMEMessage(UINT message)
  319. {
  320.     switch(message){
  321.             case WM_IME_STARTCOMPOSITION:
  322.             case WM_IME_ENDCOMPOSITION:
  323.             case WM_IME_COMPOSITION:
  324.             case WM_IME_NOTIFY:
  325.             case WM_IME_SETCONTEXT:
  326.             case WM_IME_CONTROL:
  327.             case WM_IME_COMPOSITIONFULL:
  328.             case WM_IME_SELECT:
  329.             case WM_IME_CHAR:
  330.                 return TRUE;
  331.     }
  333.     return FALSE;
  334. }
  336. BOOL MakeResultString( HIMC hIMC,BOOL fFlag)
  337. {
  338.     GENEMSG GnMsg;
  339.     LPCOMPOSITIONSTRING lpCompStr;
  340.     LPINPUTCONTEXT lpIMC;
  341. LPTSTR lpConvStr,lpPreResultStr,WubiCode,lpStr;
  342. LPCANDIDATEINFO lpCandInfo;
  343. LPCANDIDATELIST lpCandList;
  344. char AutoSaveWubiCode[5],AutoSaveWubiChr[3];
  345. WORD ConvStrLength,i;
  346. LPTSTR lpDest;
  347. static TCHAR PreThreeConvStr[3][MAXSTRHZLENGTH*3]={0};
  348. /*
  349.     if (!IsCompStr(hIMC))
  350.         return FALSE;
  351. */
  352. dwCurPhraseAttrib=0;
  354.     lpIMC = ImmLockIMC(hIMC);
  355.     lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  356. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  357. lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo  + lpCandInfo->dwOffset[0]);
  358. lpStr = GETLPCOMPSTR(lpCompStr);
  360. if(fFlag) {
  361. GnMsg.msg = WM_IME_NOTIFY;
  362. GnMsg.wParam = IMN_SETCOMPOSITIONWINDOW;
  363. GnMsg.lParam = 0;
  364. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  366. GnMsg.msg = WM_IME_NOTIFY;
  367. GnMsg.wParam = IMN_SETSTATUSWINDOWPOS;
  368. GnMsg.lParam = 0;
  369. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  371. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  372. if(PunctPushWordFlag){
  373. ImmUnlockIMCC(lpIMC->hCompStr);
  374. ImmUnlockIMCC(lpIMC->hCandInfo);
  375. ImmUnlockIMC(hIMC);
  376. return TRUE;
  377. }
  378. if(wConversionMode == CONVERSION_MODE_ENGLISH){
  379. _tcscpy(lpConvStr,lpStr);
  380. goto Noaddhistory;//Word_Existed_Hint_next;
  381. }
  382. lpPreResultStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPreResultStr;
  383. for(i=0;i<=1;i++){
  384. _tcscpy(PreThreeConvStr[2-i],PreThreeConvStr[1-i]);
  385. _tcscat(PreThreeConvStr[2-i],lpConvStr);
  386. }
  387. _tcscpy(PreThreeConvStr[0],lpPreResultStr);
  388. _tcscat(PreThreeConvStr[0],lpConvStr);
  390. _tcscpy(lpPreResultStr,lpConvStr);
  391. if(wConversionMode == CONVERSION_MODE_WUBI) _tcscpy(szPreResultCode,lpStr);
  392. //保存输入历史记录
  393. ConvStrLength=_tcslen(lpConvStr);
  394. InputAccumulateNum+=ConvStrLength;//输出数目的累积
  395. if(ConvStrLength%2 || wConversionMode != CONVERSION_MODE_WUBI) goto Noaddhistory;
  396. //如果是奇数位，可能产生错误，干脆取消
  398. if(_tcslen(WordHistoryStr)>MAXHISTORYNUM-100){
  399. _tcscpy(WordHistoryStr,WordHistoryStr+200);
  400. _tcscpy(HistoryTwoCodes,HistoryTwoCodes+200);
  401. }
  403. //自动保存编码首两位
  404. for(i=0;i<ConvStrLength;i+=2){
  405. AutoSaveWubiChr[0]=lpConvStr[i];
  406. AutoSaveWubiChr[1]=lpConvStr[i+1];
  407. AutoSaveWubiChr[2]='';
  408. //完备了，不会再产生错误了。
  409. if(wConversionSet &CONVERSION_SET_STANDARDSEARCH)
  410. {
  411. if(QueryQuickSearchTablegbk(AutoSaveWubiChr,AutoSaveWubiCode)){
  412. _tcscat(WordHistoryStr,AutoSaveWubiChr);
  413. AutoSaveWubiCode[2]='';
  414. _tcscat(HistoryTwoCodes,AutoSaveWubiCode);
  415. }
  416. }
  417. else
  418. if(WubiCode=FindWuBiCode (AutoSaveWubiChr)){
  419. _tcscat(WordHistoryStr,AutoSaveWubiChr);
  420. _tcscpy(AutoSaveWubiCode,WubiCode);
  421. AutoSaveWubiCode[2]='';
  422. _tcscat(HistoryTwoCodes,AutoSaveWubiCode);
  423. }
  424. }
  426. Noaddhistory:
  427. //
  428. if((wConversionSet & CONVERSION_SET_HISTORYREUSE) &&
  429. (wConversionMode == CONVERSION_MODE_WUBI)){
  430. _tcscpy(YJMMessage,"");
  431. if(lpDest = _tcsstr(WordHistoryStr,PreThreeConvStr[0])){
  432. lpDest+=_tcslen(PreThreeConvStr[0]);
  433. _tcsncpy(YJMMessage,lpDest,20);//10个汉字
  434. }
  435. }
  436. //
  437. if(wConversionSet & CONVERSION_SET_JP) 
  438. gb2jfb(GB2JP,lpConvStr);
  439. else if(wConversionSet & CONVERSION_SET_GBJT2FT) 
  440. gb2jfb(GB2FT,lpConvStr);
  441. else if(wConversionSet & CONVERSION_SET_BIG5) 
  442. gb2jfb(GB2BIG5,lpConvStr);
  444. _tcscpy(GETLPRESULTSTR(lpCompStr),lpConvStr);//?
  445. lpCompStr->dwResultStrLen = _tcslen(lpConvStr);
  446. }
  447. else{//false在此处理
  448. if(wConversionMode == CONVERSION_MODE_PHRASETOCHAR)
  449. wConversionMode =wPreConversionMode;
  451. lpCandList->dwCount = 0;
  452. lpCompStr->dwCompStrLen = 0;
  454. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  455. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  456. //_tcscpy(GETLPCANDSTR(lpCandList,2),_T(""));
  457. //_tcscpy(YJMMessage,"");
  459. ImmUnlockIMCC(lpIMC->hCompStr);
  460. ImmUnlockIMCC(lpIMC->hCandInfo);
  462. GnMsg.msg = WM_IME_COMPOSITION;
  463. GnMsg.wParam = 0;
  464. GnMsg.lParam = GCS_COMPSTR;
  465. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  467. GnMsg.msg = WM_IME_ENDCOMPOSITION;
  468. GnMsg.wParam = 0;
  469. GnMsg.lParam = 0;
  470. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  472.         goto my_makestring_exit;
  473. }
  475. lpCandList->dwCount = 0;
  476.     lpCompStr->dwCompStrLen = 0;
  478. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  479. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  480. //
  481. if((wConversionSet & CONVERSION_SET_HISTORYREUSE) &&
  482. (wConversionMode == CONVERSION_MODE_WUBI)&& _tcslen(YJMMessage)){
  483. _tcscpy(GETLPCANDSTR(lpCandList,2),YJMMessage);
  484. //_tcscpy(GETLPCANDSTR(lpCandList,3),_T("用法:\+数字"));
  485. lpCandList->dwCount=1;
  486. lpCompStr->dwCompStrLen = 0;
  487. }
  488. else if((wConversionSet1 & C_SET1_Word_Existed_Hint) &&
  489.     (wConversionMode == CONVERSION_MODE_WUBI)){
  490. for(i=0;i<=2;i++){
  491. if(_tcslen(PreThreeConvStr[2-i])>ConvStrLength && 
  492. (WubiCode=FindWuBiCode(PreThreeConvStr[2-i]))){
  493. _stprintf(YJMMessage,_T("已有词组：%s %s"),PreThreeConvStr[2-i],WubiCode);
  494. _tcscpy(GETLPCANDSTR(lpCandList,2),YJMMessage);
  495. lpCandList->dwCount=1;
  496. lpCompStr->dwCompStrLen = 0;
  497. goto Word_Existed_Hint_next;
  498. }
  499. }
  500. }
  501. Word_Existed_Hint_next:
  503. ImmUnlockIMCC(lpIMC->hCompStr);
  504. ImmUnlockIMCC(lpIMC->hCandInfo);
  506. GnMsg.msg = WM_IME_COMPOSITION;
  507. GnMsg.wParam = 0;
  508. GnMsg.lParam = GCS_RESULTSTR;
  509. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  511. GnMsg.msg = WM_IME_ENDCOMPOSITION;
  512. GnMsg.wParam = 0;
  513. GnMsg.lParam = 0;
  514. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  515. //
  516. my_makestring_exit:
  517. if(wConversionMode == CONVERSION_MODE_ATTACHLIB){
  518. AttachLibDictCurrentRecord=AttachLibDictHead->next;
  519. }
  520. else if(wConversionMode == CONVERSION_MODE_WUBI){
  521. wubiDictCurrentRecord=wubiDictHead->next;
  522. }
  523. else if(wConversionMode == CONVERSION_MODE_WUBIATTACHLIB){
  524. AttachLibDictCurrentRecord=AttachLibDictHead->next;
  525. wubiDictCurrentRecord=wubiDictHead->next;
  526. }
  527. if(fTempState){
  528. wConversionMode = wPreConversionMode;
  529. UpdateStatusByMessage(hIMC);
  530. fTempState=0;
  531. }
  532.     ImmUnlockIMC(hIMC);
  533.     return TRUE;
  534. }
  536. /**********************************************************************/
  537. /*                                                                    */
  538. /*      GenerateMessage()                                             */
  539. /*                                                                    */
  540. /*      Update the transrate key buffer.                              */
  541. /*                                                                    */
  542. /**********************************************************************/
  543. BOOL GenerateMessage(HIMC hIMC, LPDWORD lpdwTransKey,LPGENEMSG lpGeneMsg)
  544. {
  545.     LPINPUTCONTEXT lpIMC;
  547. if( (lpIMC = ImmLockIMC(hIMC)) == NULL ) return FALSE;
  549.     if (lpdwTransKey){
  550. ImmUnlockIMC(hIMC);
  551.         return GenerateMessageToTransKey(lpdwTransKey,lpGeneMsg);
  552. }
  553.     
  554.     if (IsWindow(lpIMC->hWnd)){
  555.         LPDWORD lpdw;
  556.         if (!(lpIMC->hMsgBuf = ImmReSizeIMCC(lpIMC->hMsgBuf,
  557. sizeof(DWORD) * (lpIMC->dwNumMsgBuf +1) * 3)))
  558.             return FALSE;
  560.         if (!(lpdw = (LPDWORD)ImmLockIMCC(lpIMC->hMsgBuf)))
  561.             return FALSE;
  563.         lpdw += (lpIMC->dwNumMsgBuf) * 3;
  564.         *((LPGENEMSG)lpdw) = *lpGeneMsg;
  565.         ImmUnlockIMCC(lpIMC->hMsgBuf);
  566.         lpIMC->dwNumMsgBuf++;
  568.         ImmGenerateMessage(hIMC);
  569.     }
  570. ImmUnlockIMC(hIMC);
  571.     return TRUE;
  572. }
  574. /**********************************************************************/
  575. /*      GenerateMessageToTransKey()                                   */
  576. /*                                                                    */
  577. /*      Update the transrate key buffer.                              */
  578. /**********************************************************************/
  579. BOOL GenerateMessageToTransKey(LPDWORD lpdwTransKey,LPGENEMSG lpGeneMsg)
  580. {
  581. LPDWORD lpdwTemp;
  583.     uNumTransKey++;
  584.     if (uNumTransKey >= (UINT)*lpdwTransKey)
  585.     {
  586.         fOverTransKey = TRUE;
  587.         return FALSE;
  588.     }
  590. lpdwTemp = (LPDWORD)lpdwTransKey + 1 + (uNumTransKey - 1)*3;
  591. *(lpdwTemp++) = lpGeneMsg->msg;
  592. *(lpdwTemp++) = lpGeneMsg->wParam;
  593. *(lpdwTemp++) = lpGeneMsg->lParam;
  594.     return TRUE;
  595. }
  597. /**********************************************************************/
  598. /*                                                                    */
  599. /* DrawUIBorder()                                                     */
  600. /*                                                                    */
  601. /* When draging the child window, this function draws the border.     */
  602. /*                                                                    */
  603. /**********************************************************************/
  604. void DrawUIBorder( LPRECT lprc )
  605. {
  606.     HDC hDC;
  607.     int sbx, sby;
  609.     hDC = CreateDC( "DISPLAY", NULL, NULL, NULL );
  610.     SelectObject( hDC, GetStockObject( GRAY_BRUSH ) );
  611.     sbx = GetSystemMetrics( SM_CXBORDER );
  612.     sby = GetSystemMetrics( SM_CYBORDER );
  613.     PatBlt( hDC, lprc->left, 
  614. lprc->top, 
  615. lprc->right - lprc->left-sbx, 
  616. sby, PATINVERT );
  617.     PatBlt( hDC, lprc->right - sbx, 
  618. lprc->top, 
  619. sbx, 
  620. lprc->bottom - lprc->top-sby, PATINVERT );
  621.     PatBlt( hDC, lprc->right, 
  622. lprc->bottom-sby, 
  623. -(lprc->right - lprc->left-sbx), 
  624. sby, PATINVERT );
  625.     PatBlt( hDC, lprc->left, 
  626. lprc->bottom, 
  627. sbx, 
  628. -(lprc->bottom - lprc->top-sby), PATINVERT );
  629.     DeleteDC( hDC );
  630. }
  632. void DragUI( HWND hWnd, HWND hWnd1,UINT message, WPARAM wParam, LPARAM lParam,BOOL fIsCompWnd)
  633. {
  634.     POINT     pt;
  635.     static    POINT ptdif,ptdif1;
  636.     static    RECT drc,drc1;
  637.     static    SIZE sz,sz1;
  638.     DWORD     dwT;
  640.     switch (message)
  641.     {
  642. case WM_SETCURSOR:
  643. if ( HIWORD(lParam) == WM_LBUTTONDOWN
  644. || HIWORD(lParam) == WM_RBUTTONDOWN ) 
  645. {
  646. GetCursorPos( &pt );
  647. SetCapture(hWnd);
  648. GetWindowRect(hWnd,&drc);
  649. ptdif.x = pt.x - drc.left;
  650. ptdif.y = pt.y - drc.top;
  651. sz.cx = drc.right - drc.left;
  652. sz.cy = drc.bottom - drc.top;
  654. if (IsWindow(hWnd1)) {
  655. GetWindowRect(hWnd1,&drc1);
  656. ptdif1.x = pt.x - drc1.left;
  657. ptdif1.y = pt.y - drc1.top;
  658. sz1.cx = drc1.right - drc1.left;
  659. sz1.cy = drc1.bottom - drc1.top;
  660. }
  662. SetWindowLong(hWnd,FIGWL_MOUSE,FIM_CAPUTURED);
  663. }
  664. break;
  666. case WM_MOUSEMOVE:
  667. dwT = GetWindowLong(hWnd,FIGWL_MOUSE);
  668. if (dwT & FIM_MOVED)
  669. {
  670. DrawUIBorder(&drc);
  671. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  672. GetCursorPos( &pt );
  673. drc.left   = pt.x - ptdif.x;
  674. drc.top    = pt.y - ptdif.y;
  675. drc.right  = drc.left + sz.cx;
  676. drc.bottom = drc.top + sz.cy;
  677. if (IsWindow(hWnd1)) {
  678. drc1.left   = pt.x - ptdif1.x;
  679. drc1.top    = pt.y - ptdif1.y;
  680. drc1.right  = drc1.left + sz1.cx;
  681. drc1.bottom = drc1.top + sz1.cy;
  682. }
  683. DrawUIBorder(&drc);
  684. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  685. }
  686. else if (dwT & FIM_CAPUTURED)
  687. {
  688. DrawUIBorder(&drc);
  689. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  690. SetWindowLong(hWnd,FIGWL_MOUSE,dwT | FIM_MOVED);
  691. }
  692. break;
  694. case WM_LBUTTONUP:
  695. case WM_RBUTTONUP:
  696. dwT = GetWindowLong(hWnd,FIGWL_MOUSE);
  698. if (dwT & FIM_CAPUTURED)
  699. {
  700. ReleaseCapture();
  701. if (dwT & FIM_MOVED)
  702. {
  703. DrawUIBorder(&drc);
  704. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  705. GetCursorPos( &pt );
  706. MoveWindow(hWnd,pt.x - ptdif.x,
  707. pt.y - ptdif.y,
  708. sz.cx,
  709. sz.cy,TRUE);
  711. if(fIsCompWnd) {
  712. HWND hUIWnd;
  713. LPARAM mylParam;
  715. *((LPWORD)(&mylParam)) = (WORD)(pt.x - ptdif.x);
  716. *((LPWORD)(&mylParam)+1) = (WORD)(pt.y - ptdif.y);
  718. hUIWnd = (HWND)GetWindowLong(hWnd,FIGWL_SVRWND);
  719. if (IsWindow(hUIWnd))
  720. SendMessage(hUIWnd,WM_UI_COMPMOVE,0,mylParam);
  721. }
  723. if (IsWindow(hWnd1)) {
  724. MoveWindow(hWnd1,pt.x - ptdif1.x,
  725. pt.y - ptdif1.y,
  726. sz1.cx,
  727. sz1.cy,TRUE);
  728. }
  729. }
  730. }
  731. break;
  732.     }
  733. }
  736. void SelectCandFromCandlist( HIMC hIMC, WORD wParam)
  737. {
  738. if( wParam >= _T('0') && wParam <= _T('9') ){
  739. DWORD dwIdx;
  740. LPTSTR lpConvStr,lpStr;
  741.     LPINPUTCONTEXT lpIMC;
  742. LPCANDIDATEINFO lpCandInfo;
  743. LPCANDIDATELIST lpCandList;
  744. LPCOMPOSITIONSTRING lpCompStr;
  745. UINT lpConvStrLen;
  747. lpIMC = ImmLockIMC(hIMC);
  748. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  749. lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo  + lpCandInfo->dwOffset[0]);
  750. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  751. lpStr = GETLPCOMPSTR(lpCompStr);
  753.     if( wParam == (WORD)_T('0')) dwIdx=9;
  754. else dwIdx = wParam - _T('1');
  756. if(dwIdx < lpCandList->dwPageSize ) {
  757. dwIdx += lpCandList->dwPageStart;
  758. //DebugLog(2,(DebugLogFile,"dwIdx: %dn",dwIdx));
  759. if( dwIdx < (lpCandList->dwCount + 2) && lpCandList->dwCount){
  760. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  761. _tcscpy(lpConvStr,GETLPCANDSTR(lpCandList,dwIdx));
  762. lpConvStrLen=_tcslen(lpConvStr);
  764. //DebugLog(2,(DebugLogFile,"lpConvStr: %sn",lpConvStr));
  766. //实现五笔的自动提示词的自动加入
  767. if(wConversionMode == CONVERSION_MODE_WUBI && HaveAutoCandList && 
  768. (dwIdx==CodeHintTextBegin+1)&&!_tcscmp(AutoWuBiCode1,AutoWuBiCode)){//lpCandList->dwCount+1
  769. if(wConversionSet1 & C_SET1_ERBIMAKEWORD) AutoGetWordErbiCode(AutoWuBiWord,1);
  770. else AutoGetWordWubiCode(AutoWuBiWord,1);
  771. _tcscpy(AutoWuBiCode1,_T(""));
  772. // SaveWubiUserDict();
  773. }
  775. //词频调整，加入if( wConversionSet & CONVERSION_SET_SORT)
  776. if((wConversionMode == CONVERSION_MODE_WUBI) && 
  777. (wConversionSet & CONVERSION_SET_SORT) &&
  778. (lpConvStrLen>2||wConversionSet1 & C_SET1_SingleHZAdjFre)) {
  779. //AdjustOrderByIndex (dwIdx-2);
  780. if(dwIdx>CodeHintTextBegin+1 && HaveAutoCandList)
  781. AdjustOrderByIndexToNo1(dwIdx-3,lpConvStr);
  782. else 
  783. AdjustOrderByIndexToNo1(dwIdx-2,lpConvStr);
  784. }
  786. //DebugLog(2,(DebugLogFile,"dwIdx: %d lpCandList->dwCount:%dn ",dwIdx,lpCandList->dwCount));
  787. MakeResultString(hIMC,TRUE);
  788. lpCandList->dwPageStart=2;
  789. }
  790. else if(PunctPushWordFlag){
  791. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  792. _tcscpy(lpConvStr,lpStr);
  793. lpConvStrLen=_tcslen(lpConvStr);
  794. }
  795. else MakeResultString(hIMC,FALSE);
  796. }
  797. //myexit:
  798. ImmUnlockIMCC(lpIMC->hCompStr);
  799. ImmUnlockIMCC(lpIMC->hCandInfo);
  800. ImmUnlockIMC(hIMC);
  801. }
  802. return;
  803. }
  805. void DeleteCharBackward(HIMC hIMC,WORD wParam)
  806. {
  807. if(wConversionMode == CONVERSION_MODE_PHRASETOCHAR){
  808. MakeResultString(hIMC,FALSE);
  809. }
  810. else if( wConversionMode == CONVERSION_MODE_I   || 
  811.  wConversionMode == CONVERSION_MODE_U   || 
  812.  wConversionMode == CONVERSION_MODE_V ) {
  813. //时间，自定义模式
  814.     LPINPUTCONTEXT lpIMC;
  815. LPCANDIDATEINFO lpCandInfo;
  816. LPCANDIDATELIST lpCandList;
  817. LPCOMPOSITIONSTRING lpCompStr;
  818. GENEMSG GnMsg;
  819. LPTSTR lpStr;
  821. lpIMC = ImmLockIMC(hIMC);
  822. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  823. lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo  + lpCandInfo->dwOffset[0]);
  824. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  826. if( !lpCandList->dwCount ) MakeResultString(hIMC,FALSE);
  827. else{
  828. lpCandList->dwCount = 0;
  830. lpStr = GETLPCOMPSTR(lpCompStr);
  831. lpStr = CharPrev(lpStr,lpStr + _tcslen(lpStr));
  832. *lpStr= _T('');
  834. lpStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPaintCompStr;
  835. lpStr = CharPrev(lpStr,lpStr + _tcslen(lpStr));
  836. *lpStr= _T('');
  838. GnMsg.msg = WM_IME_COMPOSITION;
  839. GnMsg.wParam = 0;
  840. GnMsg.lParam = GCS_COMPSTR;
  841. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  842. }
  843. ImmUnlockIMCC(lpIMC->hCompStr);
  844. ImmUnlockIMCC(lpIMC->hCandInfo);
  845. ImmUnlockIMC(hIMC);
  846. }
  847. else if( wConversionMode == CONVERSION_MODE_WUBIATTACHLIB) {
  848. //五笔附库模式//退格成功。
  849.     LPINPUTCONTEXT lpIMC;
  850. LPCOMPOSITIONSTRING lpCompStr;
  851. LPTSTR lpStr;
  852. WORD StrLen;
  854. lpIMC = ImmLockIMC(hIMC);
  855. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  857. lpStr = GETLPCOMPSTR(lpCompStr);
  858. StrLen=_tcslen(lpStr);
  859. lpStr = CharPrev(lpStr,lpStr + StrLen);
  860. *lpStr= _T('');
  862. if(StrLen<=1){
  863. ImmUnlockIMCC(lpIMC->hCompStr);
  864. ImmUnlockIMC(hIMC);
  865. MakeResultString(hIMC,FALSE);
  866. return;
  867. }
  869. lpStr = GETLPCOMPSTR(lpCompStr);
  870. StrLen=_tcslen(lpStr);
  871. wParam=*(lpStr+StrLen-1);
  872. *(lpStr+StrLen-1)=_T('');
  873. wubiDictCurrentRecord=wubiDictHead->next;//应对快速搜索
  874. AttachLibDictCurrentRecord=AttachLibDictHead->next;//应对快速搜索
  875. CodeForward=0;
  876. ImmUnlockIMCC(lpIMC->hCompStr);
  877. ImmUnlockIMC(hIMC);
  878. CharHandleWuBiAttachLib(hIMC,wParam,0) ;
  879. }
  880. else if( wConversionMode == CONVERSION_MODE_WUBI) {
  881. //五笔模式//退格成功。
  882.     LPINPUTCONTEXT lpIMC;
  883. LPCOMPOSITIONSTRING lpCompStr;
  884. LPTSTR lpStr;
  885. WORD StrLen;
  886. TCHAR cFirstChr;
  888. lpIMC = ImmLockIMC(hIMC);
  889. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  891. lpStr = GETLPCOMPSTR(lpCompStr);
  892. StrLen=_tcslen(lpStr);
  893. lpStr = CharPrev(lpStr,lpStr + StrLen);
  894. *lpStr= _T('');
  896. /*if(StrLen==0){
  897. ImmUnlockIMCC(lpIMC->hCompStr);
  898. ImmUnlockIMC(hIMC);
  899. return;
  900. }
  901. else*/ 
  902. if(StrLen<=1){
  903. ImmUnlockIMCC(lpIMC->hCompStr);
  904. ImmUnlockIMC(hIMC);
  905. MakeResultString(hIMC,FALSE);
  906. return;
  907. }
  908. lpStr = GETLPCOMPSTR(lpCompStr);
  909. StrLen=_tcslen(lpStr);
  910. wParam=*(lpStr+StrLen-1);
  911. *(lpStr+StrLen-1)=_T('');
  913. if(cFirstChr=*lpStr){
  914. SetwubiFirstLeadChr(cFirstChr);
  915. wubiDictCurrentRecord=wubiFirstLeadChr[cFirstChr-_T('!')];
  916. }
  917. else 
  918. wubiDictCurrentRecord=wubiDictHead->next;//应对快速搜索
  919. CodeForward=0;
  920. ImmUnlockIMCC(lpIMC->hCompStr);
  921. ImmUnlockIMC(hIMC);
  922. CharHandleWuBi(hIMC,wParam,0);
  923. }
  924. else if( wConversionMode == CONVERSION_MODE_ATTACHLIB||
  925.  wConversionMode == CONVERSION_MODE_TEMPATTACHLIB) {
  926. //附加词库模式//退格成功。
  927.     LPINPUTCONTEXT lpIMC;
  928. LPCOMPOSITIONSTRING lpCompStr;
  929. LPTSTR lpStr;
  930. WORD StrLen;
  932. lpIMC = ImmLockIMC(hIMC);
  933. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  935. lpStr = GETLPCOMPSTR(lpCompStr);
  936. StrLen=_tcslen(lpStr);
  937. lpStr = CharPrev(lpStr,lpStr + StrLen);
  938. *lpStr= _T('');
  940. if(StrLen<=1){
  941. ImmUnlockIMCC(lpIMC->hCompStr);
  942. ImmUnlockIMC(hIMC);
  943. MakeResultString(hIMC,FALSE);
  944. return;
  945. }
  946. lpStr = GETLPCOMPSTR(lpCompStr);
  947. StrLen=_tcslen(lpStr);
  948. wParam=*(lpStr+StrLen-1);
  949. *(lpStr+StrLen-1)=_T('');
  950. AttachLibDictCurrentRecord=AttachLibDictHead->next;//应对快速搜索
  951. CodeForward=0;
  952. ImmUnlockIMCC(lpIMC->hCompStr);
  953. ImmUnlockIMC(hIMC);
  954. CharHandleAttachLib(hIMC,wParam,0) ;
  955. }
  956. else AddChar(hIMC,wParam,EDIT_BACK);
  957. return;
  958. }
  960. void DeleteCharForward(HIMC hIMC,WORD wParam)
  961. {
  962. WORD WordHistoryStrLen=_tcslen(WordHistoryStr);
  963. if(wConversionMode == CONVERSION_MODE_WUBI) 
  964. *(WordHistoryStr+WordHistoryStrLen-2)=_T('');
  966. AddChar(hIMC,wParam,EDIT_DELETE);
  967. return;
  968. }
  970. void SpaceSelect(HIMC hIMC,WORD wParam)
  971. {
  972. WORD wCode;
  973. wCode = (WORD)_T('1');
  974. //DebugLog(2,(DebugLogFile,"wParam: %d  ",wParam));
  975. if(wConversionMode == CONVERSION_MODE_PHRASETOCHAR)
  976. CharHandlePhToCh( hIMC,wCode,0);
  977. else if( wConversionMode == CONVERSION_MODE_I   || 
  978. wConversionMode == CONVERSION_MODE_U   ||
  979. wConversionMode == CONVERSION_MODE_V   ||
  980. wConversionMode == CONVERSION_MODE_ATTACHLIB   ||
  981. wConversionMode == CONVERSION_MODE_TEMPATTACHLIB   ||
  982. wConversionMode == CONVERSION_MODE_WUBI ||
  983. wConversionMode == CONVERSION_MODE_WUBIATTACHLIB ) {
  985. SelectCandFromCandlist( hIMC, wCode);
  986. }
  987. else
  988. SelectCand(hIMC,wCode);
  989. return;
  990. }
  992. void SelectForwardFromCand(HIMC hIMC,LPCANDIDATELIST lpCandList)
  993. {
  994. HDC hDC;
  995. HFONT oldFont;
  996. TCHAR szTotal[200],szTemp[100];
  997. SIZE sz;
  998. WORD wPos;
  999. GENEMSG GnMsg;
  1000. //
  1001. /*if(wConversionMode == CONVERSION_MODE_WUBI&&
  1002. lpCandList->dwPageStart<lpCandList->dwCount-8){
  1003. lpCandList->dwPageStart+=10;
  1004. }*/
  1005. //DebugLog(2,(DebugLogFile,"1 start: %d  pagesize: %dn",lpCandList->dwPageStart,lpCandList->dwCount-8));
  1006. //
  1007. if(wConversionSet & CONVERSION_SET_SHAPE) {
  1008. wPos = (WORD) lpCandList->dwSelection;
  1009. if(wPos < lpCandList->dwCount) {
  1010. hDC = GetDC(NULL);
  1011. oldFont = SelectObject(hDC, hUIFont);
  1012. lpCandList->dwPageStart = wPos + 2;
  1013. _tcscpy(szTotal,"<>");
  1014. lpCandList->dwPageSize = 0;
  1015. while(wPos < lpCandList->dwCount && lpCandList->dwPageSize < CAND_PAGESIZE) {
  1016. _stprintf(szTemp,"%d%s ",1,GETLPCANDSTR(lpCandList,wPos+2));
  1017. _tcscat(szTotal,szTemp);
  1018. GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
  1019. if(sz.cx > sizeCand[1].cx*2) {//yjm
  1020. break;
  1021. }
  1022. (lpCandList->dwPageSize)++;
  1023. wPos++;
  1024. //DebugLog(2,(DebugLogFile,"4 wPos: %d  lpCandList->dwPageSize: %dn",wPos,lpCandList->dwPageSize));
  1025. }
  1026. SelectObject(hDC, oldFont);
  1027. ReleaseDC(NULL,hDC);
  1028. lpCandList->dwSelection = wPos;
  1029. if(lpCandList->dwPageStart > 2)
  1030. _tcscpy(GETLPCANDSTR(lpCandList,0),_T("<"));
  1031. else
  1032. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  1033. if(wPos < lpCandList->dwCount)
  1034. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(">"));
  1035. else
  1036. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  1038. GnMsg.msg = WM_IME_COMPOSITION;
  1039. GnMsg.wParam = 0;
  1040. GnMsg.lParam = GCS_COMPSTR;
  1041. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  1042. }
  1043. else MessageBeep(0xFFFFFFFF );
  1044. }
  1045. else{
  1046. if( lpCandList->dwPageStart + lpCandList->dwPageSize -2 < 
  1047. lpCandList->dwCount) {
  1048. lpCandList->dwPageStart += lpCandList->dwPageSize;
  1049. lpCandList->dwPageSize = CAND_PAGESIZE;
  1051. GnMsg.msg = WM_IME_COMPOSITION;
  1052. GnMsg.wParam = 0;
  1053. GnMsg.lParam = GCS_COMPSTR;
  1054. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  1055. }
  1056. else MessageBeep(0xFFFFFFFF );
  1057. }
  1058. }
  1060. void SelectBackwardFromCand(HIMC hIMC,LPCANDIDATELIST lpCandList)
  1061. {
  1062. HDC hDC;
  1063. HFONT oldFont;
  1064. TCHAR szTotal[200],szTemp[100];
  1065. SIZE sz;
  1066. WORD wCount;
  1067. GENEMSG GnMsg;
  1069. //
  1070. //DebugLog(2,(DebugLogFile,"1 start: %d  pagesize: %dn",lpCandList->dwPageStart,lpCandList->dwCount-8));
  1071. //
  1073. if(lpCandList->dwPageStart > 2) {
  1074. if(wConversionSet & CONVERSION_SET_SHAPE) {
  1075. hDC = GetDC(NULL);
  1076. oldFont = SelectObject(hDC, hUIFont);
  1077. lpCandList->dwSelection = (WORD)lpCandList->dwPageStart - 2;
  1078. wCount = (WORD)lpCandList->dwPageStart - 2;
  1079. _tcscpy(szTotal,"<>");
  1080. lpCandList->dwPageSize = 0;
  1081. while(wCount > 0 && lpCandList->dwPageSize < CAND_PAGESIZE) {
  1082. _stprintf(szTemp,"%d%s ",1,GETLPCANDSTR(lpCandList,wCount+2));
  1083. _tcscat(szTotal,szTemp);
  1084. GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
  1085. if(sz.cx > sizeCand[1].cx*2) {//yjm
  1086. break;
  1087. }
  1088. (lpCandList->dwPageSize)++;
  1089. wCount--;
  1090. }
  1091. SelectObject(hDC, oldFont);
  1092. ReleaseDC(NULL,hDC);
  1093. lpCandList->dwPageStart -= (lpCandList->dwSelection - wCount);
  1095. if(lpCandList->dwPageStart > 2)
  1096. _tcscpy(GETLPCANDSTR(lpCandList,0),_T("<"));
  1097. else
  1098. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  1100. if(lpCandList->dwSelection < lpCandList->dwCount)
  1101. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(">"));
  1102. else
  1103. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  1105. }
  1106. else {
  1108. if( (int)(lpCandList->dwPageStart) - (int)(lpCandList->dwPageSize)  >= 1){ 
  1109. lpCandList->dwPageStart -= lpCandList->dwPageSize;
  1110. }
  1111. }
  1112. GnMsg.msg = WM_IME_COMPOSITION;
  1113. GnMsg.wParam = 0;
  1114. GnMsg.lParam = GCS_COMPSTR;
  1115. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  1116. }
  1117. else MessageBeep(0xFFFFFFFF );
  1118. }
  1120. void SetPaintColor(HDC hDC, WORD wMode)
  1121. {
  1122. if(wMode == CONVERSION_MODE_PHRASETOCHAR) {
  1123. SetTextColor(hDC,RGB(0,0,128));
  1124. }
  1125. else if(wMode == CONVERSION_MODE_U||wMode == CONVERSION_MODE_WUBI) {
  1126. SetTextColor(hDC,RGB(128,0,0));
  1127. }
  1128. else if(wMode == CONVERSION_MODE_I) {
  1129. SetTextColor(hDC,RGB(0,128,128));
  1130. }
  1131. else if(wMode == CONVERSION_MODE_V) {
  1132. SetTextColor(hDC,RGB(128,0,128));
  1133. }
  1134. else{
  1135. SetTextColor(hDC,RGB(0,0,0));
  1136. }
  1137. }