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

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

输入法编程

开发平台：

Visual C++

HZmodenormal.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 CharHandleNormal( HIMC hIMC,WORD wParam,LONG lParam)
  25. {
  26. if( (wParam >= _T('a') && wParam <= _T('z')) || wParam == _T(''') ) {
  27. return AddChar(hIMC,wParam,EDIT_ADD);
  28. }
  29. else if( wParam == _T('=') || wParam == _T('.') || wParam == _T('>')) {
  30. return ForwardPage(hIMC);
  31. }
  33. else if( wParam == _T('-') || wParam == _T(',') || wParam == _T('<')) {
  34. return BackwardPage(hIMC);
  35. }
  36. else if( wParam >= _T('0') && wParam <= _T('9') ){
  37. return SelectCand(hIMC,wParam);
  38. }
  39. switch ( wParam ){
  40. case _T('!'):
  41. case _T('@'):
  42. case _T('#'):
  43. case _T('$'):
  44. case _T('%'):
  45. case _T('^'):
  46. case _T('&'):
  47. case _T('*'):
  48. case _T('('):
  49. case _T(')'):
  50. return DeletePhrase(hIMC,wParam);
  51. default:
  52. break;
  53. }
  54. return FALSE;
  55. }
  57. BOOL AddChar( HIMC hIMC, WORD wCode, WORD wEditMode)
  58. {
  59.     LPINPUTCONTEXT lpIMC;
  60.     LPCOMPOSITIONSTRING lpCompStr;
  61. LPCANDIDATEINFO lpCandInfo;
  62. LPCANDIDATELIST lpCandList;
  63. LPFREEPYCAND lpPYCand;
  65. LPTSTR lpStr;
  66. LPTSTR lpConvStr;
  67. LPTSTR lpPaintStr;
  68. TCHAR  szTemp[150];
  69.     GENEMSG GnMsg;
  70. LPTSTR lpPYArray;
  71. WORD *lpwPYArrayLen;
  72. WORD *lpwPYArrayCurPos;
  73. SHORT *lpwUnConvPos;
  74. SHORT *lpwEditCaret;
  75. TCHAR cTempChar;
  76. WORD wPYCount;
  77. int i;
  78. BOOL fRet = FALSE;
  79. TCHAR szPreStr[150];
  80. WORD  wPreUnConvPos;
  81. WORD  wPreEditCaret;
  83.     lpIMC = ImmLockIMC(hIMC);
  85. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  86. lpStr = GETLPCOMPSTR(lpCompStr);
  87. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  88. lpPaintStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPaintCompStr;
  89. lpPYArray = (LPTSTR)(((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPYArray);
  90. lpwPYArrayLen = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wPYArrayLen);
  91. lpwPYArrayCurPos = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wPYArrayCurPos);
  92. lpwUnConvPos = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wUnConvPos);
  93. lpwEditCaret = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wEditCaret);
  95. _tcscpy(szPreStr,lpStr);
  96. wPreUnConvPos = *lpwUnConvPos;
  97. wPreEditCaret = *lpwEditCaret;
  99.     if( wEditMode == EDIT_BACK ){
  100. if(!_tcslen(lpStr) || (*lpwEditCaret) < 1 ){
  101. MessageBeep(0xFFFFFFFF );
  102. fRet = TRUE;
  103. goto my_exit;
  104. }
  105. else if(*lpwEditCaret <= *lpwUnConvPos){
  106. *lpConvStr = _T('');
  107. *lpwUnConvPos = 0;
  108. }
  109. else{
  110. _tcscpy(szTemp,lpStr + *lpwEditCaret);
  111. _tcscpy(lpStr + *lpwEditCaret -1,szTemp);
  112. *lpwEditCaret -= 1;
  113. if( !_tcslen(lpStr)){
  114. MakeResultString(hIMC,FALSE);
  115. fRet = TRUE;
  116. goto my_exit;
  117. }
  118. }
  119.     }
  120.     else if( wEditMode == EDIT_DELETE ){
  121. if(!_tcslen(lpStr) || (*lpwEditCaret) == (SHORT)_tcslen(lpStr) ){
  122. MessageBeep(0xFFFFFFFF );
  123. fRet = TRUE;
  124. goto my_exit;
  125. }
  126. else{
  127. _tcscpy(szTemp,lpStr + *lpwEditCaret + 1);
  128. _tcscpy(lpStr + *lpwEditCaret,szTemp);
  129. if( !_tcslen(lpStr)){
  130. MakeResultString(hIMC,FALSE);
  131. fRet = TRUE;
  132. goto my_exit;
  133. }
  134. }
  135.     }
  136.     else if( wEditMode == EDIT_ADD ){
  137. _tcscpy(szTemp,lpStr + *lpwEditCaret);
  138. *(lpStr + *lpwEditCaret) = (TCHAR)wCode;
  139. _tcscpy(lpStr + *lpwEditCaret +1,szTemp);
  140. *lpwEditCaret += 1;
  141.     }
  142. else{
  143. MessageBeep(0xFFFFFFFF );
  144. fRet = TRUE;
  145. goto my_exit;
  146. }
  148.     lpCompStr->dwCompStrLen = _tcslen(lpStr);
  151.     if(!_tcslen(lpConvStr)){
  152. *lpwPYArrayCurPos = 0;
  153.     }
  155.     wPYCount=ParsePY(lpStr + *lpwUnConvPos,lpPYArray + (*lpwPYArrayCurPos)*MAX_PY_LEN,MAX_PY_LEN);
  157. *lpwPYArrayLen = *lpwPYArrayCurPos + wPYCount;
  158. i = *lpwPYArrayLen;
  159. while(i--){
  160. if((cTempChar = *(lpPYArray + i*MAX_PY_LEN)) == _T('i') || 
  161. cTempChar == _T('u') || cTempChar == _T('v') ){
  162. _tcscpy(lpStr,szPreStr);
  163. *lpwEditCaret = wPreEditCaret;
  164. *lpwUnConvPos = wPreUnConvPos;
  165. *lpwPYArrayLen = *lpwPYArrayLen - 1;
  166. MessageBeep(0xFFFFFFFF );
  167. fRet = TRUE;
  168. goto my_exit;
  169. }
  170. }
  172.     if(EffectPYArrayLen(lpPYArray,MAX_PY_LEN,*lpwPYArrayLen) > MAX_PHRASE_LEN) {
  173. _tcscpy(lpStr,szPreStr);
  174. *lpwEditCaret = wPreEditCaret;
  175. *lpwUnConvPos = wPreUnConvPos;
  176. *lpwPYArrayLen = *lpwPYArrayLen - 1;
  177. MessageBeep(0xFFFFFFFF );
  178. fRet = TRUE;
  179. goto my_exit;
  180.     }
  181. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  182. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  183. lpPYCand = (LPFREEPYCAND)(&((LPMYCAND)lpCandInfo)->FreePYCand);
  185. ConvertPY( lpPYArray + (*lpwPYArrayCurPos)*MAX_PY_LEN,
  186. MAX_PY_LEN,wPYCount,lpPYCand);
  188.     lpPYCand->awBeforePos[1] = 0;
  189. lpPYCand->awBeforePos[0] = 0;
  190. lpPYCand->awCurrentPos[1] = 0;
  191. lpPYCand->awCurrentPos[0] = 0;
  192. lpPYCand->wSelectDirect = SELECT_FORWARD;
  193.     lpPYCand->wSelectStatus = 1;
  195. lpCandList->dwCount = CreateCandStr(lpPYCand, SELECT_FORWARD, (LPTSTR)(((LPMYCAND)lpCandInfo)->szCandStr),MAXCANDSTRSIZE);
  196. lpCandList->dwPageStart = 2;
  197. lpCandList->dwPageSize = 10;
  199. CreatePaintStr( lpPYArray + (*lpwPYArrayCurPos)*MAX_PY_LEN,
  200. MAX_PY_LEN,(WORD)((*lpwPYArrayLen)-(*lpwPYArrayCurPos)),lpConvStr,lpPaintStr);
  202.     GnMsg.msg = WM_IME_COMPOSITION;
  203.     GnMsg.wParam = 0;
  204.     GnMsg.lParam = GCS_COMPSTR;
  205.     GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  207. ImmUnlockIMCC(lpIMC->hCandInfo);
  208. fRet = TRUE;
  209. my_exit:
  210.     ImmUnlockIMCC(lpIMC->hCompStr);
  211.     ImmUnlockIMC(hIMC);
  212. return fRet;
  213. }
  215. BOOL ForwardPage(HIMC hIMC)
  216. {
  217.     LPINPUTCONTEXT lpIMC;
  218. LPCANDIDATEINFO lpCandInfo;
  219. LPCANDIDATELIST lpCandList;
  220. LPFREEPYCAND lpPYCand;
  221. GENEMSG GnMsg;
  223. if( !IsCompStr(hIMC) ) return FALSE;
  225. lpIMC = ImmLockIMC(hIMC);
  226. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  227. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  228. lpPYCand = (LPFREEPYCAND)(&((LPMYCAND)lpCandInfo)->FreePYCand);
  230. lpCandList->dwCount = 
  231. CreateCandStr(lpPYCand, SELECT_FORWARD, (LPTSTR)(((LPMYCAND)lpCandInfo)->szCandStr),MAXCANDSTRSIZE);
  232. lpCandList->dwPageStart = 2;
  233. lpCandList->dwPageSize = 10;
  235. if(lpCandList->dwCount) {
  236. GnMsg.msg = WM_IME_COMPOSITION;
  237. GnMsg.wParam = 0;
  238. GnMsg.lParam = GCS_COMPSTR;
  239. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  240. }
  241. ImmUnlockIMCC(lpIMC->hCandInfo);
  242.     ImmUnlockIMC(hIMC);
  243. return TRUE;
  244. }
  246. BOOL BackwardPage(HIMC hIMC)
  247. {
  248.     LPINPUTCONTEXT lpIMC;
  249. LPCANDIDATEINFO lpCandInfo;
  250. LPCANDIDATELIST lpCandList;
  251. LPFREEPYCAND lpPYCand;
  252. GENEMSG GnMsg;
  254. if( !IsCompStr(hIMC) ) return FALSE;
  256. lpIMC = ImmLockIMC(hIMC);
  257. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  258. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  259. lpPYCand = (LPFREEPYCAND)(&((LPMYCAND)lpCandInfo)->FreePYCand);
  261. lpCandList->dwCount = 
  262. CreateCandStr(lpPYCand, SELECT_BACKWARD, (LPTSTR)(((LPMYCAND)lpCandInfo)->szCandStr),MAXCANDSTRSIZE);
  263. lpCandList->dwPageStart = 2;
  264. lpCandList->dwPageSize = 10;
  266. if(lpCandList->dwCount) {
  267. GnMsg.msg = WM_IME_COMPOSITION;
  268. GnMsg.wParam = 0;
  269. GnMsg.lParam = GCS_COMPSTR;
  270. GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  271. }
  273. ImmUnlockIMCC(lpIMC->hCandInfo);
  274.     ImmUnlockIMC(hIMC);
  275. return TRUE;
  276. }
  278. BOOL SelectCand(HIMC hIMC,WORD wParam)
  279. {
  280.     LPINPUTCONTEXT lpIMC;
  281. LPCOMPOSITIONSTRING lpCompStr;
  282. LPCANDIDATEINFO lpCandInfo;
  283. LPCANDIDATELIST lpCandList;
  285. LPFREEPYCAND lpPYCand;
  287. LPTSTR lpStr;
  288. LPTSTR lpConvStr;
  289. LPTSTR lpPaintStr;
  290. LPTSTR lpPYArray;
  291. SHORT *lpwUnConvPos;
  292. SHORT *lpwEditCaret;
  293. WORD *lpwPYArrayLen;
  294. WORD *lpwPYArrayCurPos;
  295. GENEMSG GnMsg;
  296.     WORD wIdx,awLen[2],wPosSpan,wTotal,wCount;
  297. TCHAR szTempStr[(MAX_PHRASE_LEN+1)*2];
  298. int i;
  300.     if( !IsCompStr(hIMC) ) return FALSE;
  302. lpIMC = ImmLockIMC(hIMC);
  304. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  305. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  306. lpPYCand = (LPFREEPYCAND)(&((LPMYCAND)lpCandInfo)->FreePYCand);
  308. lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
  309. lpStr = GETLPCOMPSTR(lpCompStr);
  310. lpConvStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szConvCompStr;
  311. lpPaintStr = ((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPaintCompStr;
  312. lpPYArray = (LPTSTR)(((LPMYCOMPSTR)lpCompStr)->FreePYComp.szPYArray);
  313. lpwPYArrayLen = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wPYArrayLen);
  314. lpwPYArrayCurPos = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wPYArrayCurPos);
  315. lpwUnConvPos = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wUnConvPos);
  316. lpwEditCaret = &(((LPMYCOMPSTR)lpCompStr)->FreePYComp.wEditCaret);
  319.     if( wParam == (WORD)_T('0') ) wIdx=9;
  320.     else wIdx = wParam - (WORD)_T('1');
  322. if(wIdx >= lpCandList->dwCount) return FALSE;
  324. wTotal = wIdx + 1;
  325.     switch(lpPYCand->wSelectDirect){
  326.     case SELECT_FORWARD:
  327. if(wConversionSet & CONVERSION_SET_GBK) {
  328. wIdx += lpPYCand->awBeforePos[lpPYCand->wSelectStatus];
  329. }
  330. else {
  331. if(lpPYCand->wSelectStatus) {
  332. wIdx += lpPYCand->awBeforePos[lpPYCand->wSelectStatus];
  333. }
  334. else{
  335. wIdx = lpPYCand->awBeforePos[lpPYCand->wSelectStatus];
  336. wCount = 0;
  337. while( wCount != wTotal) {
  338. for(i=0;i < lpPYCand->wHZNum;i++){
  339. if((lpPYCand->aHanZi+i)->wLen > wIdx) break;
  340. }
  341. #ifdef _UNICODE
  342. if(i)
  343. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + (wIdx - (lpPYCand->aHanZi+i-1)->wLen),1);
  344. else
  345. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + wIdx,1);
  346. szTempStr[1] = _T('');
  347. #else
  348. if(i)
  349. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + 2*(wIdx - (lpPYCand->aHanZi+i-1)->wLen),2);
  350. else
  351. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ+2*wIdx,2);
  352. szTempStr[2] = _T('');
  353. #endif
  354. if( (*((LPBYTE)szTempStr) >= GB_QUFIRST && *((LPBYTE)szTempStr) <= GB_QULAST) && 
  355. (*((LPBYTE)szTempStr+1) >= GB_WEIFIRST && *((LPBYTE)szTempStr+1) <= GB_WEILAST) ) {
  356. wCount++;
  357. }
  358. wIdx++;
  359. }
  360. wIdx--;
  361. }
  362. }
  363. break;
  364.     case SELECT_BACKWARD:
  365. if(wConversionSet & CONVERSION_SET_GBK) {
  366. wIdx += lpPYCand->awCurrentPos[lpPYCand->wSelectStatus]+1;
  367. }
  368. else {
  369. if(lpPYCand->wSelectStatus) {
  370. wIdx += lpPYCand->awCurrentPos[lpPYCand->wSelectStatus]+1;
  371. }
  372. else{
  373. wIdx = lpPYCand->awBeforePos[lpPYCand->wSelectStatus];
  374. wTotal--;
  375. wCount = 10;
  376. while( wCount != wTotal) {
  377. for(i=0;i < lpPYCand->wHZNum;i++){
  378. if((lpPYCand->aHanZi+i)->wLen > wIdx) break;
  379. }
  380. #ifdef _UNICODE
  381. if(i)
  382. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + (wIdx - (lpPYCand->aHanZi+i-1)->wLen),1);
  383. else
  384. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + wIdx,1);
  385. szTempStr[1] = _T('');
  386. #else
  387. if(i)
  388. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + 2*(wIdx - (lpPYCand->aHanZi+i-1)->wLen),2);
  389. else
  390. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ+2*wIdx,2);
  391. szTempStr[2] = _T('');
  392. #endif
  393. if( (*((LPBYTE)szTempStr) >= GB_QUFIRST && *((LPBYTE)szTempStr) <= GB_QULAST) && 
  394. (*((LPBYTE)szTempStr+1) >= GB_WEIFIRST && *((LPBYTE)szTempStr+1) <= GB_WEILAST) ) {
  395. wCount--;
  396. }
  397. wIdx--;
  398. }
  399. wIdx++;
  400. }
  401. }
  402. break;
  403.     default:
  404. break;
  405.     }
  406. awLen[1] = lpPYCand->wPhraseNum;
  407. awLen[0] = (lpPYCand->aHanZi + lpPYCand->wHZNum - 1)->wLen;
  409.     if(0 < wIdx < awLen[lpPYCand->wSelectStatus]){
  410. if(lpPYCand->wSelectStatus){
  411. _tcscpy(szTempStr,(lpPYCand->aPhrase+wIdx)->lpHZPH->szHZ);
  412. _tcscat(lpConvStr,szTempStr);
  413. lpPYCand ->abKey[0] |= 
  414. (lpPYCand->aPhrase+wIdx)->lpKeyPH->abKey[0] << lpPYCand->wKeyLen;
  416. for(i=1;i<=(lpPYCand->aPhrase+wIdx)->lpKeyPH->wLen;i++){
  417. lpPYCand ->abKey[(lpPYCand->wKeyLen++) + 1] =
  418. (lpPYCand->aPhrase+wIdx)->lpKeyPH->abKey[i];
  419. }
  421. }
  422. else{
  423. for(i=0;i < lpPYCand->wHZNum;i++){
  424. if((lpPYCand->aHanZi+i)->wLen > wIdx ) break;
  425. }
  426. #ifdef _UNICODE
  427. if(i)
  428. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + (wIdx - (lpPYCand->aHanZi+i-1)->wLen),1);
  429. else
  430. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + wIdx,1);
  431. szTempStr[1] = _T('');
  432. #else
  433. if(i)
  434. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ + 2*(wIdx - (lpPYCand->aHanZi+i-1)->wLen),2);
  435. else
  436. _tcsncpy(szTempStr,(lpPYCand->aHanZi+i)->lpHZ+2*wIdx,2);
  437. szTempStr[2] = _T('');
  438. #endif
  439. _tcscat(lpConvStr,szTempStr);
  441. lpPYCand ->abKey[0] |= ((lpPYCand->aHanZi+i)->wKey & 0x0100) >>(8 - lpPYCand->wKeyLen);
  442. lpPYCand ->abKey[(lpPYCand->wKeyLen++) + 1] = (BYTE)(lpPYCand->aHanZi+i)->wKey & 0xff;
  444. }
  445. #ifdef _UNICODE
  446. if( EffectPYArrayLen(lpPYArray,MAX_PY_LEN,*lpwPYArrayLen) == _tcslen(lpConvStr) ) {
  447. if(_tcslen(szTempStr) == _tcslen(lpConvStr) && lpPYCand->wSelectStatus)
  448. (lpPYCand->aPhrase + wIdx)->lpHZPH->wAttrib++;
  449. else if(_tcslen(lpConvStr) > 1)
  450. SavePhToMapFile(lpConvStr,lpPYCand->abKey,(WORD)(_tcslen(lpConvStr)),1);
  451. #else
  452. if( EffectPYArrayLen(lpPYArray,MAX_PY_LEN,*lpwPYArrayLen) == _tcslen(lpConvStr)/2 ) {
  453. if(_tcslen(szTempStr) == _tcslen(lpConvStr) && lpPYCand->wSelectStatus)
  454. (lpPYCand->aPhrase + wIdx)->lpHZPH->dwAttrib++;
  455. else if(_tcslen(lpConvStr) > 2)
  456. SavePhToMapFile(lpConvStr,lpPYCand->abKey,(WORD)(_tcslen(lpConvStr)/2),1);
  457. #endif
  458. MakeResultString(hIMC,TRUE);
  459. goto my_exit;
  460. }
  461. else{
  462. #ifdef _UNICODE
  463. wPosSpan = CalculatePosSpan(lpPYArray+(*lpwPYArrayCurPos)*MAX_PY_LEN,
  464. MAX_PY_LEN,(WORD)((*lpwPYArrayLen)-(*lpwPYArrayCurPos)),(WORD)_tcslen(szTempStr));
  465. #else
  466. wPosSpan = CalculatePosSpan(lpPYArray+(*lpwPYArrayCurPos)*MAX_PY_LEN,
  467. MAX_PY_LEN,(WORD)((*lpwPYArrayLen)-(*lpwPYArrayCurPos)),(WORD)(_tcslen(szTempStr)/2));
  468. #endif
  469. *lpwPYArrayCurPos += wPosSpan;
  471. *lpwUnConvPos = CalculateUnConvPos(lpPYArray + (*lpwPYArrayCurPos)*MAX_PY_LEN,
  472. MAX_PY_LEN,(WORD)((*lpwPYArrayLen)-(*lpwPYArrayCurPos)),lpStr);
  474. *lpwEditCaret = (SHORT)_tcslen(lpStr);
  476. ConvertPY( lpPYArray + (*lpwPYArrayCurPos)*MAX_PY_LEN,
  477. MAX_PY_LEN,(WORD)((*lpwPYArrayLen)-(*lpwPYArrayCurPos)),lpPYCand);
  479.     lpPYCand->awBeforePos[1] = 0;
  480. lpPYCand->awBeforePos[0] = 0;
  481. lpPYCand->awCurrentPos[1] = 0;
  482. lpPYCand->awCurrentPos[0] = 0;
  483. lpPYCand->wSelectDirect = SELECT_FORWARD;
  484. lpPYCand->wSelectStatus = 1;
  486. lpCandList->dwCount = CreateCandStr(lpPYCand, SELECT_FORWARD, (LPTSTR)(((LPMYCAND)lpCandInfo)->szCandStr),MAXCANDSTRSIZE);
  487. lpCandList->dwPageStart = 2;
  488. lpCandList->dwPageSize = 10;
  490. CreatePaintStr( lpPYArray + (*lpwPYArrayCurPos)*MAX_PY_LEN,
  491. MAX_PY_LEN,(WORD)((*lpwPYArrayLen)-(*lpwPYArrayCurPos)),lpConvStr,lpPaintStr);
  492. }
  493.     }
  494.     GnMsg.msg = WM_IME_COMPOSITION;
  495.     GnMsg.wParam = 0;
  496. GnMsg.lParam = GCS_COMPSTR;
  497.     GenerateMessage(hIMC, lpdwCurTransKey,(LPGENEMSG)&GnMsg);
  498. my_exit:
  499. ImmUnlockIMCC(lpIMC->hCandInfo);
  500.     ImmUnlockIMCC(lpIMC->hCompStr);
  501.     ImmUnlockIMC(hIMC);
  502. return TRUE;
  503. }
  505. BOOL DeletePhrase(HIMC hIMC,WORD wParam)
  506. {
  507.     LPINPUTCONTEXT lpIMC;
  508. LPCANDIDATEINFO lpCandInfo;
  509. LPCANDIDATELIST lpCandList;
  511. LPFREEPYCAND lpPYCand;
  512. LPKEYPH lpKPh;
  513. LPHZPH lpHZPh,lpCurHZPh,lpPreHZPh;
  515. WORD wLen,wIdx;
  516. WORD wRet = 0;
  518.     if( !IsCompStr(hIMC) ) return FALSE;
  520. lpIMC = ImmLockIMC(hIMC);
  522. lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
  523. lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo  + lpCandInfo->dwOffset[0]);
  524. lpPYCand = (LPFREEPYCAND)(&((LPMYCAND)lpCandInfo)->FreePYCand);
  526. if( ! lpPYCand->wSelectStatus ) {
  527. ImmUnlockIMCC(lpIMC->hCandInfo);
  528.     ImmUnlockIMC(hIMC);
  529. return FALSE;
  530. }
  532. switch( wParam ) {
  533. case _T('!'):
  534. wIdx = 0;
  535. break;
  536. case _T('@'):
  537. wIdx = 1;
  538. break;
  539. case _T('#'):
  540. wIdx = 2;
  541. break;
  542. case _T('$'):
  543. wIdx = 3;
  544. break;
  545. case _T('%'):
  546. wIdx = 4;
  547. break;
  548. case _T('^'):
  549. wIdx = 5;
  550. break;
  551. case _T('&'):
  552. wIdx = 6;
  553. break;
  554. case _T('*'):
  555. wIdx = 7;
  556. break;
  557. case _T('('):
  558. wIdx = 8;
  559. break;
  560. case _T(')'):
  561. wIdx = 9;
  562. break;
  563. default:
  564. wIdx = 0;
  565. break;
  566. }
  568.     switch(lpPYCand->wSelectDirect){
  569.     case SELECT_FORWARD:
  570. wIdx += lpPYCand->awBeforePos[lpPYCand->wSelectStatus];
  571. break;
  572.     case SELECT_BACKWARD:
  573. wIdx += lpPYCand->awCurrentPos[lpPYCand->wSelectStatus]+1;
  574. break;
  575.     default:
  576. break;
  577.     }
  578. wLen = lpPYCand->wPhraseNum;
  580.     if(0 < wIdx < wLen ){
  581. lpKPh = (lpPYCand->aPhrase+wIdx)->lpKeyPH;
  582. lpHZPh = (lpPYCand->aPhrase+wIdx)->lpHZPH;
  583. if( ((LPBYTE)lpKPh >= (LPBYTE)lpMapFileBase 
  584. && (LPBYTE)lpKPh < (LPBYTE)lpMapFileBase + MAX_PY_NUM*sizeof(KEYPH) ) ||
  585. ((LPBYTE)lpKPh >= (LPBYTE)lpMapFileBase + 2*MAX_PY_NUM*sizeof(KEYPH)
  586. &&(LPBYTE)lpKPh < (LPBYTE)lpMapFileBase + dwMapFileUsrOffset ) ) {
  587. lpHZPh->dwAttrib = 0;
  588. wRet = 1;
  589. }
  590. else{
  591. lpCurHZPh = lpKPh->lpHZPH;
  592. if( lpCurHZPh == lpHZPh) {
  593. if(lpHZPh->lpNext == NULL) lpKPh->wLen = -1;
  594. lpKPh->lpHZPH = lpHZPh->lpNext;
  595. wRet = 1;
  596. }
  597. else {
  598. lpPreHZPh = lpCurHZPh;
  599. do {
  600. lpCurHZPh = lpCurHZPh->lpNext;
  601. if(lpCurHZPh == lpHZPh) {
  602. lpPreHZPh->lpNext = lpCurHZPh->lpNext;
  603. wRet = 1;
  604. break;
  605. }
  606. lpPreHZPh = lpCurHZPh;
  607. }while(lpCurHZPh->lpNext != NULL);
  608. }
  609. }
  610. }
  611. if( wRet ) MakeResultString(hIMC,FALSE);
  612. ImmUnlockIMCC(lpIMC->hCandInfo);
  613.     ImmUnlockIMC(hIMC);
  614. return TRUE;
  615. }