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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 输入法编程 > 查看源码
subs.c
资源名称：freepy22.zip　[点击查看]
上传用户：shdz666
上传日期：2007-01-03
资源大小：566k
文件大小：26k
源码类别：

输入法编程

开发平台：

Visual C++

subs.c：源码内容
  1. /*
  2.  * Copyright (C) 1999.4  Li ZhenChun
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License; or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that is will be useful, but
  10.  * WITHOUT ANY WARRANTY; without even the implied warranty of 
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12.  * General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 675 Mass Ave, Cambridge, M A 02139, USA.
  17.  *
  18.  * Author: Li ZhenChun  email: zhchli@163.net or zhchli@126.com
  19.  * 
  20.  */
  22. #include "freepy.h"
  24. BOOL IsCompStr(HIMC hIMC)
  25. {
  26.     LPINPUTCONTEXT lpIMC;
  27.     LPCOMPOSITIONSTRING lpCompStr;
  28.     BOOL fRet = FALSE;
  30.     if (!(lpIMC = ImmLockIMC(hIMC)))
  31.         return FALSE;
  33.     if (ImmGetIMCCSize(lpIMC->hCompStr) < sizeof (COMPOSITIONSTRING))
  34.     {
  35.         ImmUnlockIMC(hIMC);
  36.         return FALSE;
  37.     }
  39.     lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  41.     fRet = (lpCompStr->dwCompStrLen > 0);
  43.     ImmUnlockIMCC(lpIMC->hCompStr);
  44.     ImmUnlockIMC(hIMC);
  46.     return fRet;
  47. }
  49. /**********************************************************************/
  50. /*                                                                    */
  51. /*      InitCompStr()                                                  */
  52. /*                                                                    */
  53. /**********************************************************************/
  54. void InitCompStr(LPCOMPOSITIONSTRING lpCompStr)
  55. {
  56. LPFREEPYCOMP lpFreePYComp;
  58. lpCompStr->dwSize = sizeof(MYCOMPSTR);
  60. lpCompStr->dwCompStrOffset = 
  61.             (DWORD)((LPMYCOMPSTR)lpCompStr)->szCompStr - (DWORD)lpCompStr;
  62. lpCompStr->dwCompStrLen = 0;
  63. *GETLPCOMPSTR(lpCompStr) = _T('');
  65. lpCompStr->dwResultStrOffset = 
  66.           (DWORD)((LPMYCOMPSTR)lpCompStr)->szResultStr - (DWORD)lpCompStr;
  67. lpCompStr->dwResultStrLen = 0;
  68. *GETLPRESULTSTR(lpCompStr) = _T('');
  70. lpCompStr->dwCursorPos = 0;
  72. lpFreePYComp= &(((LPMYCOMPSTR)lpCompStr)->FreePYComp);
  73. lpFreePYComp->szConvCompStr[0] = _T('');
  74. lpFreePYComp->szPaintCompStr[0] = _T('');
  75. lpFreePYComp->szPreResultStr[0] = _T('');
  76. lpFreePYComp->wEditCaret = 0;
  77. lpFreePYComp->wUnConvPos = 0;
  78. lpFreePYComp->wPYArrayLen = 0;
  79. lpFreePYComp->wPYArrayCurPos = 0;
  80. }
  82. void ClearCompStr(LPCOMPOSITIONSTRING lpCompStr)
  83. {
  84. LPFREEPYCOMP lpFreePYComp;
  86. lpCompStr->dwCursorPos = 0;
  87. lpCompStr->dwCompStrLen = 0;
  88. ((LPMYCOMPSTR)lpCompStr)->szCompStr[0] = _T('');
  89. lpCompStr->dwResultStrLen = 0;
  90. ((LPMYCOMPSTR)lpCompStr)->szResultStr[0] = _T('');
  92. lpFreePYComp= &(((LPMYCOMPSTR)lpCompStr)->FreePYComp);
  93. lpFreePYComp->szConvCompStr[0] = _T('');
  94. lpFreePYComp->szPaintCompStr[0] = _T('');
  95. lpFreePYComp->wEditCaret = 0;
  96. lpFreePYComp->wUnConvPos = 0;
  97. lpFreePYComp->wPYArrayLen = 0;
  98. lpFreePYComp->wPYArrayCurPos = 0;
  99. }
  101. BOOL IsCandidate(HIMC hIMC)
  102. {
  103.     LPINPUTCONTEXT lpIMC;
  104.     LPCANDIDATEINFO lpCandInfo;
  105. LPCANDIDATELIST lpCandList;
  106.     BOOL fRet = FALSE;
  108.     if (!(lpIMC = ImmLockIMC(hIMC)))
  109.         return FALSE;
  111.     if (ImmGetIMCCSize(lpIMC->hCandInfo) < sizeof (CANDIDATEINFO)){
  112. ImmUnlockIMC(hIMC);
  113.         return FALSE;
  114. }
  116.     lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  117. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  119.     fRet = (lpCandList->dwCount > 0);
  121.     ImmUnlockIMCC(lpIMC->hCandInfo);
  122. ImmUnlockIMC(hIMC);
  123.     return fRet;
  124. }
  126. void InitCandInfo(LPCANDIDATEINFO lpCandInfo)
  127. {
  128. LPCANDIDATELIST lpCandList;
  129. LPFREEPYCAND lpFreePYCand;
  130. int i;
  132. lpCandInfo->dwSize = sizeof(MYCAND);
  133. lpCandInfo->dwCount = 1;
  134. lpCandInfo->dwOffset[0] = 
  135. (DWORD)(&(((LPMYCAND)lpCandInfo)->cl)) - (DWORD)lpCandInfo;
  137. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  138. for(i=0;i<MAXCANDSTRNUM;i++) {
  139. lpCandList->dwOffset[i] = 
  140.                    (DWORD)((LPMYCAND)lpCandInfo)->szCandStr[i] - (DWORD)lpCandList;
  141. }
  142. lpCandList->dwSize = sizeof(MYCAND) - sizeof(CANDIDATEINFO); 
  143. lpCandList->dwCount = 0L;
  144. lpCandList->dwSelection = 0L;
  145. lpCandList->dwPageStart = 0L;
  146. lpCandList->dwPageSize = 0L;
  148. lpFreePYCand= &(((LPMYCAND)lpCandInfo)->FreePYCand);
  149. lpFreePYCand->wPhraseNum = 0;
  150. lpFreePYCand->wHZNum = 0;
  151. lpFreePYCand->wKeyLen = 0;
  152. lpFreePYCand->abKey[0] = 0;
  153. }
  155. void ClearCandidate(LPCANDIDATEINFO lpCandInfo)
  156. {
  157. LPFREEPYCAND lpFreePYCand;
  159.     ((LPMYCAND)lpCandInfo)->cl.dwCount =0L;
  160.     ((LPMYCAND)lpCandInfo)->cl.dwSelection =0L;
  161.     ((LPMYCAND)lpCandInfo)->cl.dwPageStart =0L;
  162.     ((LPMYCAND)lpCandInfo)->cl.dwPageSize =0L;
  164. lpFreePYCand= &(((LPMYCAND)lpCandInfo)->FreePYCand);
  165. lpFreePYCand->wPhraseNum = 0;
  166. lpFreePYCand->wHZNum = 0;
  167. lpFreePYCand->wKeyLen = 0;
  168. lpFreePYCand->abKey[0] = 0;
  169. }
  171. HKL GetMyHKL()
  172. {
  173.     DWORD dwSize;
  174.     DWORD dwi;
  175.     HKL hKL = 0;
  176.     HKL *lphkl;
  178.     dwSize = GetKeyboardLayoutList(0, NULL);
  180.     lphkl = (HKL *)GlobalAlloc(GPTR, dwSize * sizeof(DWORD));
  182.     if (!lphkl)
  183.         return NULL;
  185.     GetKeyboardLayoutList(dwSize, lphkl);
  188.     for (dwi = 0; dwi < dwSize; dwi++)
  189.     {
  190.         char szFile[32];
  191.         HKL hKLTemp = *(lphkl + dwi);
  192.         ImmGetIMEFileName(hKLTemp, szFile, sizeof(szFile));
  194.         if (!_tcsicmp(szFile, FREEPYFILENAME))
  195.         {
  196.              hKL = hKLTemp;
  197.              goto exit;
  198.         }
  199.     }
  200. exit:
  202.     GlobalFree((HANDLE)lphkl);
  203.     return hKL;
  204. }
  205. /*****************************************************************************
  206. *                                                                            *
  207. * UpdateIndicIcon( hIMC )                                                    *
  208. *                                                                            *
  209. *****************************************************************************/
  210. void UpdateIndicIcon(HIMC hIMC)
  211. {
  212.     HWND hwndIndicate;
  213.     BOOL fOpen = FALSE;
  214.     LPINPUTCONTEXT lpIMC;
  216.     if (!hFreePYKL)
  217.     {
  218.        hFreePYKL = GetMyHKL();
  219.        if (!hFreePYKL)
  220.            return;
  221.     }
  223.     hwndIndicate = FindWindow(INDICATOR_CLASS, NULL);
  225.     if (hIMC)
  226.     {
  227.         lpIMC = ImmLockIMC(hIMC);
  228.         if (lpIMC)
  229.         {
  230.             fOpen = lpIMC->fOpen;
  231.             ImmUnlockIMC(hIMC);
  232.         }
  233.     }
  235.     if (IsWindow(hwndIndicate))
  236.     {
  237.         ATOM atomTip;
  239.         atomTip = GlobalAddAtom(ATOMTIP);
  240.         PostMessage(hwndIndicate, INDICM_SETIMEICON, 
  241.                     fOpen ? 1 : (-1), (LPARAM)hFreePYKL);
  242.         PostMessage(hwndIndicate, INDICM_SETIMETOOLTIPS, 
  243.                     fOpen ? atomTip : (-1), (LPARAM)hFreePYKL);
  244.         PostMessage(hwndIndicate, INDICM_REMOVEDEFAULTMENUITEMS, 
  245.                     // fOpen ? (RDMI_LEFT | RDMI_RIGHT) : 0, (LPARAM)hMyKL);
  246.                     fOpen ? (RDMI_LEFT) : 0, (LPARAM)hFreePYKL);
  247.     }
  248. }
  250. /**********************************************************************/
  251. /*                                                                    */
  252. /* MyIsIMEMessage(message)                                            */
  253. /*                                                                    */
  254. /* Any UI window should not pass the IME messages to DefWindowProc.   */
  255. /*                                                                    */
  256. /**********************************************************************/
  257. BOOL MyIsIMEMessage(UINT message)
  258. {
  259.     switch(message)
  260.     {
  261.             case WM_IME_STARTCOMPOSITION:
  262.             case WM_IME_ENDCOMPOSITION:
  263.             case WM_IME_COMPOSITION:
  264.             case WM_IME_NOTIFY:
  265.             case WM_IME_SETCONTEXT:
  266.             case WM_IME_CONTROL:
  267.             case WM_IME_COMPOSITIONFULL:
  268.             case WM_IME_SELECT:
  269.             case WM_IME_CHAR:
  270.                 return TRUE;
  271.     }
  273.     return FALSE;
  274. }
  276. BOOL MakeResultString( HIMC hIMC,BOOL fFlag)
  277. {
  278.     GENEMSG GnMsg;
  279.     LPCOMPOSITIONSTRING lpCompStr;
  280.     LPINPUTCONTEXT lpIMC;
  281. LPTSTR lpConvStr,lpPreResultStr;
  282. LPCANDIDATEINFO lpCandInfo;
  283. LPCANDIDATELIST lpCandList;
  284. /*
  285.     if (!IsCompStr(hIMC))
  286.         return FALSE;
  287. */
  288. wConversionMode = 0;
  290.     lpIMC = ImmLockIMC(hIMC);
  291.     lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  292. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  293. lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo  + lpCandInfo->dwOffset[0]);
  295. if(fFlag) {
  296. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  297. lpPreResultStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPreResultStr;
  298. _tcscpy(GETLPRESULTSTR(lpCompStr),lpConvStr);
  299. _tcscpy(lpPreResultStr,lpConvStr);
  300. lpCompStr->dwResultStrLen = _tcslen(lpConvStr);
  301. }
  302. else{
  303. *GETLPRESULTSTR(lpCompStr) = _T('');
  304. lpCompStr->dwResultStrLen = 0;
  305. }
  307. lpCandList->dwCount = 0;
  308.     lpCompStr->dwCompStrLen = 0;
  310. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  311. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  313. ImmUnlockIMCC(lpIMC->hCompStr);
  314. ImmUnlockIMCC(lpIMC->hCandInfo);
  316. GnMsg.msg = WM_IME_COMPOSITION;
  317. GnMsg.wParam = 0;
  318. GnMsg.lParam = GCS_RESULTSTR;
  319. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  321. GnMsg.msg = WM_IME_ENDCOMPOSITION;
  322. GnMsg.wParam = 0;
  323. GnMsg.lParam = 0;
  324. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  326.     ImmUnlockIMC(hIMC);
  327.     return TRUE;
  328. }
  330. /**********************************************************************/
  331. /*                                                                    */
  332. /*      GenerateMessage()                                             */
  333. /*                                                                    */
  334. /*      Update the transrate key buffer.                              */
  335. /*                                                                    */
  336. /**********************************************************************/
  337. BOOL GenerateMessage(HIMC hIMC, LPDWORD lpdwTransKey,LPGENEMSG lpGeneMsg)
  338. {
  339.     LPINPUTCONTEXT lpIMC;
  341. if( (lpIMC = ImmLockIMC(hIMC)) == NULL ) return FALSE;
  343.     if (lpdwTransKey){
  344. ImmUnlockIMC(hIMC);
  345.         return GenerateMessageToTransKey(lpdwTransKey,lpGeneMsg);
  346. }
  347.     
  348.     if (IsWindow(lpIMC->hWnd))
  349.     {
  350.         LPDWORD lpdw;
  351.         if (!(lpIMC->hMsgBuf = ImmReSizeIMCC(lpIMC->hMsgBuf,
  352. sizeof(DWORD) * (lpIMC->dwNumMsgBuf +1) * 3)))
  353.             return FALSE;
  355.         if (!(lpdw = (LPDWORD)ImmLockIMCC(lpIMC->hMsgBuf)))
  356.             return FALSE;
  358.         lpdw += (lpIMC->dwNumMsgBuf) * 3;
  359.         *((LPGENEMSG)lpdw) = *lpGeneMsg;
  360.         ImmUnlockIMCC(lpIMC->hMsgBuf);
  361.         lpIMC->dwNumMsgBuf++;
  363.         ImmGenerateMessage(hIMC);
  364.     }
  365. ImmUnlockIMC(hIMC);
  366.     return TRUE;
  367. }
  369. /**********************************************************************/
  370. /*      GenerateMessageToTransKey()                                   */
  371. /*                                                                    */
  372. /*      Update the transrate key buffer.                              */
  373. /**********************************************************************/
  374. BOOL GenerateMessageToTransKey(LPDWORD lpdwTransKey,LPGENEMSG lpGeneMsg)
  375. {
  376. LPDWORD lpdwTemp;
  378.     uNumTransKey++;
  379.     if (uNumTransKey >= (UINT)*lpdwTransKey)
  380.     {
  381.         fOverTransKey = TRUE;
  382.         return FALSE;
  383.     }
  385. lpdwTemp = (LPDWORD)lpdwTransKey + 1 + (uNumTransKey - 1)*3;
  386. *(lpdwTemp++) = lpGeneMsg->msg;
  387. *(lpdwTemp++) = lpGeneMsg->wParam;
  388. *(lpdwTemp++) = lpGeneMsg->lParam;
  389.     return TRUE;
  390. }
  392. /**********************************************************************/
  393. /*                                                                    */
  394. /* DrawUIBorder()                                                     */
  395. /*                                                                    */
  396. /* When draging the child window, this function draws the border.     */
  397. /*                                                                    */
  398. /**********************************************************************/
  399. void DrawUIBorder( LPRECT lprc )
  400. {
  401.     HDC hDC;
  402.     int sbx, sby;
  404.     hDC = CreateDC( "DISPLAY", NULL, NULL, NULL );
  405.     SelectObject( hDC, GetStockObject( GRAY_BRUSH ) );
  406.     sbx = GetSystemMetrics( SM_CXBORDER );
  407.     sby = GetSystemMetrics( SM_CYBORDER );
  408.     PatBlt( hDC, lprc->left, 
  409. lprc->top, 
  410. lprc->right - lprc->left-sbx, 
  411. sby, PATINVERT );
  412.     PatBlt( hDC, lprc->right - sbx, 
  413. lprc->top, 
  414. sbx, 
  415. lprc->bottom - lprc->top-sby, PATINVERT );
  416.     PatBlt( hDC, lprc->right, 
  417. lprc->bottom-sby, 
  418. -(lprc->right - lprc->left-sbx), 
  419. sby, PATINVERT );
  420.     PatBlt( hDC, lprc->left, 
  421. lprc->bottom, 
  422. sbx, 
  423. -(lprc->bottom - lprc->top-sby), PATINVERT );
  424.     DeleteDC( hDC );
  425. }
  427. void DragUI( HWND hWnd, HWND hWnd1,UINT message, WPARAM wParam, LPARAM lParam,BOOL fIsCompWnd)
  428. {
  429.     POINT     pt;
  430.     static    POINT ptdif,ptdif1;
  431.     static    RECT drc,drc1;
  432.     static    SIZE sz,sz1;
  433.     DWORD     dwT;
  435.     switch (message)
  436.     {
  437. case WM_SETCURSOR:
  438. if ( HIWORD(lParam) == WM_LBUTTONDOWN
  439. || HIWORD(lParam) == WM_RBUTTONDOWN ) 
  440. {
  441. GetCursorPos( &pt );
  442. SetCapture(hWnd);
  443. GetWindowRect(hWnd,&drc);
  444. ptdif.x = pt.x - drc.left;
  445. ptdif.y = pt.y - drc.top;
  446. sz.cx = drc.right - drc.left;
  447. sz.cy = drc.bottom - drc.top;
  449. if (IsWindow(hWnd1)) {
  450. GetWindowRect(hWnd1,&drc1);
  451. ptdif1.x = pt.x - drc1.left;
  452. ptdif1.y = pt.y - drc1.top;
  453. sz1.cx = drc1.right - drc1.left;
  454. sz1.cy = drc1.bottom - drc1.top;
  455. }
  457. SetWindowLong(hWnd,FIGWL_MOUSE,FIM_CAPUTURED);
  458. }
  459. break;
  461. case WM_MOUSEMOVE:
  462. dwT = GetWindowLong(hWnd,FIGWL_MOUSE);
  463. if (dwT & FIM_MOVED)
  464. {
  465. DrawUIBorder(&drc);
  466. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  467. GetCursorPos( &pt );
  468. drc.left   = pt.x - ptdif.x;
  469. drc.top    = pt.y - ptdif.y;
  470. drc.right  = drc.left + sz.cx;
  471. drc.bottom = drc.top + sz.cy;
  472. if (IsWindow(hWnd1)) {
  473. drc1.left   = pt.x - ptdif1.x;
  474. drc1.top    = pt.y - ptdif1.y;
  475. drc1.right  = drc1.left + sz1.cx;
  476. drc1.bottom = drc1.top + sz1.cy;
  477. }
  478. DrawUIBorder(&drc);
  479. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  480. }
  481. else if (dwT & FIM_CAPUTURED)
  482. {
  483. DrawUIBorder(&drc);
  484. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  485. SetWindowLong(hWnd,FIGWL_MOUSE,dwT | FIM_MOVED);
  486. }
  487. break;
  489. case WM_LBUTTONUP:
  490. case WM_RBUTTONUP:
  491. dwT = GetWindowLong(hWnd,FIGWL_MOUSE);
  493. if (dwT & FIM_CAPUTURED)
  494. {
  495. ReleaseCapture();
  496. if (dwT & FIM_MOVED)
  497. {
  498. DrawUIBorder(&drc);
  499. if (IsWindow(hWnd1)) DrawUIBorder(&drc1);
  500. GetCursorPos( &pt );
  501. MoveWindow(hWnd,pt.x - ptdif.x,
  502. pt.y - ptdif.y,
  503. sz.cx,
  504. sz.cy,TRUE);
  506. if(fIsCompWnd) {
  507. HWND hUIWnd;
  508. LPARAM mylParam;
  510. *((LPWORD)(&mylParam)) = (WORD)(pt.x - ptdif.x);
  511. *((LPWORD)(&mylParam)+1) = (WORD)(pt.y - ptdif.y);
  513. hUIWnd = (HWND)GetWindowLong(hWnd,FIGWL_SVRWND);
  514. if (IsWindow(hUIWnd))
  515. SendMessage(hUIWnd,WM_UI_COMPMOVE,0,mylParam);
  516. }
  518. if (IsWindow(hWnd1)) {
  519. MoveWindow(hWnd1,pt.x - ptdif1.x,
  520. pt.y - ptdif1.y,
  521. sz1.cx,
  522. sz1.cy,TRUE);
  523. }
  524. }
  525. }
  526. break;
  527.     }
  528. }
  531. void SelectCandFromCandlist( HIMC hIMC, WORD wParam)
  532. {
  533. if( wParam >= _T('0') && wParam <= _T('9') ){
  534. DWORD dwIdx;
  535. LPTSTR lpConvStr;
  536.     LPINPUTCONTEXT lpIMC;
  537. LPCANDIDATEINFO lpCandInfo;
  538. LPCANDIDATELIST lpCandList;
  539. LPCOMPOSITIONSTRING lpCompStr;
  541. lpIMC = ImmLockIMC(hIMC);
  542. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  543. lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo  + lpCandInfo->dwOffset[0]);
  544. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  546.     if( wParam == (WORD)_T('0') ) dwIdx=9;
  547. else dwIdx = wParam - _T('1');
  548. if(dwIdx < lpCandList->dwPageSize ) {
  549. dwIdx += lpCandList->dwPageStart;
  550. if( dwIdx < (lpCandList->dwCount + 2) && lpCandList->dwCount){
  551. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  552. _tcscpy(lpConvStr,GETLPCANDSTR(lpCandList,dwIdx));
  553. MakeResultString(hIMC,TRUE);
  554. }
  555. }
  556. ImmUnlockIMCC(lpIMC->hCompStr);
  557. ImmUnlockIMCC(lpIMC->hCandInfo);
  558. ImmUnlockIMC(hIMC);
  559. }
  560. return;
  561. }
  563. void DeleteCharBackward(HIMC hIMC,WORD wParam)
  564. {
  565. if(wConversionMode & CONVERSION_MODE_PHRASETOCHAR){
  566. MakeResultString(hIMC,FALSE);
  567. }
  568. else if( wConversionMode & CONVERSION_MODE_I   || 
  569.  wConversionMode & CONVERSION_MODE_U   ||
  570.  wConversionMode & CONVERSION_MODE_V ) {
  572.     LPINPUTCONTEXT lpIMC;
  573. LPCANDIDATEINFO lpCandInfo;
  574. LPCANDIDATELIST lpCandList;
  575. LPCOMPOSITIONSTRING lpCompStr;
  576. GENEMSG GnMsg;
  577. LPTSTR lpStr;
  579. lpIMC = ImmLockIMC(hIMC);
  580. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  581. lpCandList = (LPCANDIDATELIST)((LPSTR)lpCandInfo  + lpCandInfo->dwOffset[0]);
  582. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  584. if( !lpCandList->dwCount ) MakeResultString(hIMC,FALSE);
  585. else{
  586. lpCandList->dwCount = 0;
  588. lpStr = GETLPCOMPSTR(lpCompStr);
  589. lpStr = CharPrev(lpStr,lpStr + _tcslen(lpStr));
  590. *lpStr= _T('');
  592. lpStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPaintCompStr;
  593. lpStr = CharPrev(lpStr,lpStr + _tcslen(lpStr));
  594. *lpStr= _T('');
  596. GnMsg.msg = WM_IME_COMPOSITION;
  597. GnMsg.wParam = 0;
  598. GnMsg.lParam = GCS_COMPSTR;
  599. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  600. }
  601. ImmUnlockIMCC(lpIMC->hCompStr);
  602. ImmUnlockIMCC(lpIMC->hCandInfo);
  603. ImmUnlockIMC(hIMC);
  604. }
  605. else AddChar(hIMC,wParam,EDIT_BACK);
  606. return;
  607. }
  609. void DeleteCharForward(HIMC hIMC,WORD wParam)
  610. {
  611. AddChar(hIMC,wParam,EDIT_DELETE);
  612. return;
  613. }
  615. void SpaceSelect(HIMC hIMC,WORD wParam)
  616. {
  617. WORD wCode;
  618. wCode = (WORD)_T('1');
  620. if(wConversionMode & CONVERSION_MODE_PHRASETOCHAR)
  621. CharHandlePhToCh( hIMC,wCode,0);
  622. else if( wConversionMode & CONVERSION_MODE_I   || 
  623. wConversionMode & CONVERSION_MODE_U   ||
  624. wConversionMode & CONVERSION_MODE_V ) {
  626. SelectCandFromCandlist( hIMC, wCode);
  627. }
  628. else
  629. SelectCand(hIMC,wCode);
  630. return;
  631. }
  633. void SelectForwardFromCand(HIMC hIMC,LPCANDIDATELIST lpCandList)
  634. {
  635. HDC hDC;
  636. TCHAR szTotal[200],szTemp[100];
  637. SIZE sz;
  638. WORD wPos;
  639. GENEMSG GnMsg;
  641. if(wConversionSet & CONVERSION_SET_SHAPE) {
  642. wPos = (WORD) lpCandList->dwSelection;
  643. if(wPos < lpCandList->dwCount) {
  644. hDC = GetDC(NULL);
  645. lpCandList->dwPageStart = wPos + 2;
  646. _tcscpy(szTotal,"<>");
  647. lpCandList->dwPageSize = 0;
  648. while(wPos < lpCandList->dwCount && lpCandList->dwPageSize < CAND_PAGESIZE) {
  649. _stprintf(szTemp,"%d%s ",1,GETLPCANDSTR(lpCandList,wPos+2));
  650. _tcscat(szTotal,szTemp);
  651. GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
  652. if(sz.cx > sizeCand[1].cx) {
  653. break;
  654. }
  655. (lpCandList->dwPageSize)++;
  656. wPos++;
  657. }
  658. ReleaseDC(NULL,hDC);
  659. lpCandList->dwSelection = wPos;
  660. if(lpCandList->dwPageStart > 2)
  661. _tcscpy(GETLPCANDSTR(lpCandList,0),_T("<"));
  662. else
  663. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  664. if(wPos < lpCandList->dwCount)
  665. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(">"));
  666. else
  667. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  669. GnMsg.msg = WM_IME_COMPOSITION;
  670. GnMsg.wParam = 0;
  671. GnMsg.lParam = GCS_COMPSTR;
  672. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  673. }
  674. else MessageBeep(0xFFFFFFFF );
  675. }
  676. else{
  677. if( lpCandList->dwPageStart + lpCandList->dwPageSize -2 < 
  678. lpCandList->dwCount) {
  679. lpCandList->dwPageStart += lpCandList->dwPageSize;
  680. lpCandList->dwPageSize = CAND_PAGESIZE;
  682. GnMsg.msg = WM_IME_COMPOSITION;
  683. GnMsg.wParam = 0;
  684. GnMsg.lParam = GCS_COMPSTR;
  685. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  686. }
  687. else MessageBeep(0xFFFFFFFF );
  688. }
  689. }
  691. void SelectBackwardFromCand(HIMC hIMC,LPCANDIDATELIST lpCandList)
  692. {
  693. HDC hDC;
  694. TCHAR szTotal[200],szTemp[100];
  695. SIZE sz;
  696. WORD wCount;
  697. GENEMSG GnMsg;
  699. if(lpCandList->dwPageStart > 2) {
  700. if(wConversionSet & CONVERSION_SET_SHAPE) {
  701. hDC = GetDC(NULL);
  702. lpCandList->dwSelection = (WORD)lpCandList->dwPageStart - 2;
  703. wCount = (WORD)lpCandList->dwPageStart - 2;
  704. _tcscpy(szTotal,"<>");
  705. lpCandList->dwPageSize = 0;
  706. while(wCount > 0 && lpCandList->dwPageSize < CAND_PAGESIZE) {
  707. _stprintf(szTemp,"%d%s ",1,GETLPCANDSTR(lpCandList,wCount+2));
  708. _tcscat(szTotal,szTemp);
  709. GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
  710. if(sz.cx > sizeCand[1].cx) {
  711. break;
  712. }
  713. (lpCandList->dwPageSize)++;
  714. wCount--;
  715. }
  716. ReleaseDC(NULL,hDC);
  717. lpCandList->dwPageStart -= (lpCandList->dwSelection - wCount);
  719. if(lpCandList->dwPageStart > 2)
  720. _tcscpy(GETLPCANDSTR(lpCandList,0),_T("<"));
  721. else
  722. _tcscpy(GETLPCANDSTR(lpCandList,0),_T(""));
  724. if(lpCandList->dwSelection < lpCandList->dwCount)
  725. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(">"));
  726. else
  727. _tcscpy(GETLPCANDSTR(lpCandList,1),_T(""));
  729. }
  730. else {
  732. if( (int)(lpCandList->dwPageStart) - (int)(lpCandList->dwPageSize)  >= 1){ 
  733. lpCandList->dwPageStart -= lpCandList->dwPageSize;
  734. }
  735. }
  736. GnMsg.msg = WM_IME_COMPOSITION;
  737. GnMsg.wParam = 0;
  738. GnMsg.lParam = GCS_COMPSTR;
  739. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  740. }
  741. else MessageBeep(0xFFFFFFFF );
  742. }
  744. void SetPaintColor(HDC hDC, WORD wMode)
  745. {
  746. if(wMode & CONVERSION_MODE_PHRASETOCHAR) {
  747. SetTextColor(hDC,RGB(0,0,128));
  748. }
  749. else if(wMode & CONVERSION_MODE_U) {
  750. SetTextColor(hDC,RGB(128,0,0));
  751. }
  752. else if(wMode & CONVERSION_MODE_I) {
  753. SetTextColor(hDC,RGB(0,128,128));
  754. }
  755. else if(wMode & CONVERSION_MODE_V) {
  756. SetTextColor(hDC,RGB(128,0,128));
  757. }
  758. else{
  759. SetTextColor(hDC,RGB(0,0,0));
  760. }
  761. }
  763. BOOL WINAPI ConfigDialogProc(
  764. HWND hWnd,
  765. UINT message,
  766. WPARAM wParam,
  767. LPARAM lParam )
  768. {
  769. HKEY hKey,hChildKey;
  770. DWORD dwConvSet;
  771. DWORD dwData = sizeof(DWORD);
  772. DWORD dwDisposition;
  774. switch(message) {
  775. case WM_INITDIALOG:
  776. if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  777. _T("Software\freepy"),
  778. 0,
  779. KEY_READ,
  780. &hKey) == ERROR_SUCCESS ){
  781. if( RegQueryValueEx( hKey,
  782. _T("ConversionSet"),
  783. NULL,
  784. NULL,
  785. (LPBYTE)&dwConvSet,
  786. &dwData) == ERROR_SUCCESS ){
  788. CheckDlgButton(hWnd,CONFIGSORT,
  789. (dwConvSet & CONVERSION_SET_SORT)? BST_CHECKED :BST_UNCHECKED );
  790. CheckDlgButton(hWnd,CONFIGPUNCT,
  791. (dwConvSet & CONVERSION_SET_PUNCT)? BST_CHECKED :BST_UNCHECKED );
  792. CheckDlgButton(hWnd,CONFIGFULLSHAPE,
  793. (dwConvSet & CONVERSION_SET_FULLSHAPE)? BST_CHECKED :BST_UNCHECKED );
  794. CheckDlgButton(hWnd,CONFIGFOLLOW,
  795. (dwConvSet & CONVERSION_SET_FOLLOW)? BST_CHECKED :BST_UNCHECKED );
  796. CheckDlgButton(hWnd,CONFIGGBK,
  797. (dwConvSet & CONVERSION_SET_GBK)? BST_CHECKED :BST_UNCHECKED );
  798. CheckDlgButton(hWnd,CONFIGFUZZYC,
  799. (dwConvSet & CONVERSION_SET_FUZZYC)? BST_CHECKED :BST_UNCHECKED );
  800. CheckDlgButton(hWnd,CONFIGFUZZYN,
  801. (dwConvSet & CONVERSION_SET_FUZZYN)? BST_CHECKED :BST_UNCHECKED );
  802. CheckDlgButton(hWnd,CONFIGFUZZYH,
  803. (dwConvSet & CONVERSION_SET_FUZZYH)? BST_CHECKED :BST_UNCHECKED );
  804. CheckDlgButton(hWnd,CONFIGFUZZYB,
  805. (dwConvSet & CONVERSION_SET_FUZZYB)? BST_CHECKED :BST_UNCHECKED );
  806. CheckDlgButton(hWnd,CONFIGSHAPE,
  807. (dwConvSet & CONVERSION_SET_SHAPE)? BST_CHECKED :BST_UNCHECKED );
  809. }
  810. RegCloseKey(hKey);
  811. }
  812. break;
  814. case WM_COMMAND:
  815. switch(wParam) {
  816. case CONFIGFUZZYC:
  817. break;
  819. case CONFIGFUZZYN:
  820. break;
  822. case CONFIGFUZZYH:
  823. break;
  825. case CONFIGSORT:
  826. break;
  828. case CONFIGPUNCT:
  829. break;
  831. case CONFIGFULLSHAPE:
  832. break;
  834. case IDOK:
  835. if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  836. _T("Software"),
  837. 0,
  838. KEY_READ,
  839. &hKey) == ERROR_SUCCESS ){
  841. if( RegCreateKeyEx( hKey,
  842. _T("freepy"),
  843. 0,
  844. NULL,
  845. REG_OPTION_NON_VOLATILE ,
  846. KEY_ALL_ACCESS ,
  847. NULL,
  848. &hChildKey,
  849. &dwDisposition ) == ERROR_SUCCESS) {
  851. dwConvSet = 0;
  852. if(IsDlgButtonChecked(hWnd,CONFIGSORT) == BST_CHECKED)
  853. dwConvSet |= CONVERSION_SET_SORT;
  854. else
  855. dwConvSet &= ~CONVERSION_SET_SORT;
  857. if(IsDlgButtonChecked(hWnd,CONFIGPUNCT) == BST_CHECKED)
  858. dwConvSet |= CONVERSION_SET_PUNCT;
  859. else
  860. dwConvSet &= ~CONVERSION_SET_PUNCT;
  862. if(IsDlgButtonChecked(hWnd,CONFIGFULLSHAPE) == BST_CHECKED)
  863. dwConvSet |= CONVERSION_SET_FULLSHAPE;
  864. else
  865. dwConvSet &= ~CONVERSION_SET_FULLSHAPE;
  867. if(IsDlgButtonChecked(hWnd,CONFIGFOLLOW) == BST_CHECKED)
  868. dwConvSet |= CONVERSION_SET_FOLLOW;
  869. else
  870. dwConvSet &= ~CONVERSION_SET_FOLLOW;
  872. if(IsDlgButtonChecked(hWnd,CONFIGGBK) == BST_CHECKED)
  873. dwConvSet |= CONVERSION_SET_GBK;
  874. else
  875. dwConvSet &= ~CONVERSION_SET_GBK;
  877. if(IsDlgButtonChecked(hWnd,CONFIGFUZZYC) == BST_CHECKED)
  878. dwConvSet |= CONVERSION_SET_FUZZYC;
  879. else
  880. dwConvSet &= ~CONVERSION_SET_FUZZYC;
  882. if(IsDlgButtonChecked(hWnd,CONFIGFUZZYN) == BST_CHECKED)
  883. dwConvSet |= CONVERSION_SET_FUZZYN;
  884. else
  885. dwConvSet &= ~CONVERSION_SET_FUZZYN;
  887. if(IsDlgButtonChecked(hWnd,CONFIGFUZZYH) == BST_CHECKED)
  888. dwConvSet |= CONVERSION_SET_FUZZYH;
  889. else
  890. dwConvSet &= ~CONVERSION_SET_FUZZYH;
  892. if(IsDlgButtonChecked(hWnd,CONFIGFUZZYB) == BST_CHECKED)
  893. dwConvSet |= CONVERSION_SET_FUZZYB;
  894. else
  895. dwConvSet &= ~CONVERSION_SET_FUZZYB;
  897. if(IsDlgButtonChecked(hWnd,CONFIGSHAPE) == BST_CHECKED)
  898. dwConvSet |= CONVERSION_SET_SHAPE;
  899. else
  900. dwConvSet &= ~CONVERSION_SET_SHAPE;
  902. wConversionSet = (WORD)dwConvSet;
  904. RegSetValueEx(hChildKey,
  905. _T("ConversionSet"),
  906. 0,
  907. REG_DWORD,
  908. (LPBYTE)&dwConvSet,
  909. sizeof(DWORD));
  910. RegCloseKey(hChildKey);
  911. }
  913. RegCloseKey(hKey);
  914. }
  916. EndDialog(hWnd,TRUE);
  917. break;
  919. case IDCANCEL:
  920. EndDialog(hWnd,TRUE);
  921. break;
  923. default:
  924. return FALSE;
  925. break;
  926. }
  927. break;
  929. default:
  930. return FALSE;
  931. break;
  932. }
  933. return TRUE;
  934. }