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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 输入法编程 > 查看源码
Compose.pas
资源名称：Wingb_Mz.rar　[点击查看]
上传用户：wen198501
上传日期：2013-04-01
资源大小：335k
文件大小：15k
源码类别：

输入法编程

开发平台：

Delphi

Compose.pas：源码内容
  2.  {******************************************************}
  3.  {                                                      }
  4.  {    Copyright (c) 1990-1999 Microsoft Corporation     }
  5.  {                                                      }
  6.  {    Module Name:  Compose.c ->>  Compose.pas          }
  7.  {                                                      }
  8.  {    Translator:  Liu_mazi@126.com, 2005-11-19         }
  9.  {                                                      }
  10.  {******************************************************}
  12. unit Compose;
  14. {$I Define.Inc}
  16. interface
  18. uses Windows, ImmDev, ImeDefs;
  20. function GBEngine(lpImcP: PPrivContext): Word;  // Conv GBcode
  22. procedure AddCodeIntoCand(lpCandList: PCandiDateList; wCode: Word); // 添加Candidate
  24. procedure CompEscapeKey(lpIMC: PInputContext; lpCompStr: PCompositionString;
  25.   lpGuideLine: PGuideLine; lpImcP: PPrivContext); // Composition取消处理
  26.   
  27. procedure CompWord(wCharCode: Word; lpIMC: PInputContext;
  28.   lpCompStr: PCompositionString; lpImcP: PPrivContext; lpGuideLine: PGuideLine);
  30. implementation
  32. uses Data, DDIS;
  34.   // 单个字符转数值
  35. function CharToHex(cChar: Char): Word;
  36. begin
  37.   if (cChar >= '0') and (cChar <= '9') then
  38.     Result := Ord(cChar) - Ord('0')
  39.   else
  40.     if (cChar >= 'a') and (cChar <= 'f') then
  41.       Result := Ord(cChar) - Ord('a') + $0A
  42.     else
  43.       Result := 0;
  44. end;
  46.   // GB内码串转内码
  47. function AsciiToGB(lpImcP: PPrivContext): Word;
  48. begin
  49.   Result := (CharToHex(lpImcP.bSeq[2]) shl 4) or CharToHex(lpImcP.bSeq[3]);
  50.   Result := (Result shl 8);
  51.   Result := (CharToHex(lpImcP.bSeq[0]) shl 4) or CharToHex(lpImcP.bSeq[1]) or Result;
  52. end;
  54.   // 区位码串转内码
  55. function AsciiToArea(lpImcP: PPrivContext): Word;
  56. begin
  57.   Result := (CharToHex(lpImcP.bSeq[2]) * 10) + CharToHex(lpImcP.bSeq[3]) + $A0;
  58.   Result := (Result shl 8);
  59.   Result := (CharToHex(lpImcP.bSeq[0]) * 10) + CharToHex(lpImcP.bSeq[1]) + $A0 or Result;
  60. end;
  62.   // Conv GBcode
  63. function GBEngine(lpImcP: PPrivContext): Word;
  64. begin
  65.   if (lpImcP.bSeq[3] <> #0) or (lpImcP.bSeq[2] = '?') then
  66.   begin
  67.     if (lpImcP.bSeq[0] >= '0') and (lpImcP.bSeq[0] <= '9') then //Area mode
  68.     begin
  69.       if (lpImcP.bSeq[2] = '?') then
  70.       begin
  71.         lpImcP.bSeq[2] := '0';
  72.         lpImcP.bSeq[3] := '1';
  73.       end;
  74.       Result := AsciiToArea(lpImcP);
  75.     end else
  76.       if (lpImcP.bSeq[0] >= 'a') and (lpImcP.bSeq[0] <= 'f') then //GB mode
  77.       begin
  78.         if (lpImcP.bSeq[2] = '?') then
  79.         begin
  80.           lpImcP.bSeq[2] := 'a';
  81.           lpImcP.bSeq[3] := '1';
  82.         end;
  83.         Result := AsciiToGB(lpImcP);
  84.       end else
  85.         Result := 0;
  86.   end else
  87.     Result := 0;
  88. end;
  90.   // Conv GBcode for Space
  91. function GBSpcEng(lpImcP: PPrivContext): Word;
  92. begin
  93.   if (lpImcP.bSeq[0] >= '0') and (lpImcP.bSeq[0] <= '9') then //Area mode
  94.   begin
  95.     lpImcP.bSeq[2] := '0';
  96.     lpImcP.bSeq[3] := '1';
  97.     Result := AsciiToArea(lpImcP);
  98.   end else
  99.     if (lpImcP.bSeq[0] >= 'a') and (lpImcP.bSeq[0] <= 'f') then //GB mode
  100.     begin
  101.       lpImcP.bSeq[2] := 'a';
  102.       lpImcP.bSeq[3] := '1';
  103.       Result := AsciiToGB(lpImcP);
  104.     end else
  105.       Result := 0;
  106. end;
  108.   // search MB, and fill lpCompStr & lpCandList
  109. function Engine(lpCompStr: PCompositionString; lpCandList: PCandiDateList;
  110.   lpImcP: PPrivContext; lpIMC: PInputContext; wCharCode: Word): Integer;
  111. var
  112.   J: DWord;
  113.   wCode: Word;
  114.   ResaultStr: array[0..2] of Char;
  115. begin
  116.   if (lpCompStr.dwCursorPos < 4) and (lpImcP.bSeq[2] <> '?') and (wCharCode <> Ord(' ')) then
  117.   begin
  118.     Result := ENGINE_COMP;
  119.     Exit;
  120.   end else
  121.     if (lpCompStr.dwCursorPos = 4) or (lpImcP.bSeq[2] = '?') or
  122.        ((wCharCode = Ord(' ')) and (lpCompStr.dwCursorPos = 2)) then
  123.     begin
  124.       if (lpCompStr = nil) then
  125.       begin
  126.         MessageBeep($FFFFFFFF);
  127.         Result := -1;
  128.         Exit;
  129.       end;
  131.       if (lpImcP = nil) then
  132.       begin
  133.         MessageBeep($FFFFFFFF);
  134.         Result := -1;
  135.         Exit;
  136.       end;
  138.       if (lpImcP.bSeq[2] = '?') then // 查询
  139.       begin
  140.         wCode := GBEngine(lpImcP);
  141.         wCode := HiByte(wCode) or (LoByte(wCode) shl 8);
  143.         for J := 0 to IME_MAXCAND - 1 do
  144.         begin
  145.           AddCodeIntoCand(lpCandList, wCode);
  146.           Inc(wCode);
  147.         end;
  149.         Result := ENGINE_COMP;
  150.         Exit;
  151.       end else
  152.         if (wCharCode = Ord(' ')) then    // 查询
  153.         begin
  154.           wCode := GBSpcEng(lpImcP);
  155.           lpImcP.bSeq[2] := #0;
  156.           lpImcP.bSeq[3] := #0;
  157.           wCode := HiByte(wCode) or (LoByte(wCode) shl 8);
  159.           for J := 0 to IME_MAXCAND - 1 do
  160.           begin
  161.             AddCodeIntoCand(lpCandList, wCode);
  162.             Inc(wCode);
  163.           end;
  165.           Result := ENGINE_COMP;
  166.           Exit
  167.         end else                     // 转换
  168.         begin
  169.           InitCompStr(lpCompStr);
  171.           wCode := GBEngine(lpImcP); // the result string = the selected candidate;
  172.           ResaultStr[0] := Chr(LoByte(wCode));
  173.           ResaultStr[1] := Chr(HiByte(wCode));
  174.           ResaultStr[2] := #0;
  176.           lStrCpy(PChar(DWord(lpCompStr) + lpCompStr.dwResultStrOffset), ResaultStr);
  177.           lpCompStr.dwResultStrLen := lStrLen(ResaultStr); // calculate result string length
  179.           Result := ENGINE_RESAULT;
  180.           Exit;
  181.         end;
  182.     end;
  184.   MessageBeep($FFFFFFFF);
  185.   Result := ENGINE_COMP;
  186. end;
  188.   // Call Engine finalize Chinese word(s) by searching table
  189. function Finalize(lpIMC: PInputContext; lpCompStr: PCompositionString; lpImcP: PPrivContext; wCharCode: Word): uInt;
  190. var
  191.   lpCandInfo: PCandiDateInfo;
  192.   lpCandList: PCandiDateList;
  193. begin
  194.   Result := 0;
  195.   if (lpIMC.hCandInfo = 0) then Exit;
  197.   // get lpCandInfo
  198.   lpCandInfo := ImmLockIMCC(lpIMC.hCandInfo);
  199.   if (lpCandInfo = nil) then Exit;
  201.   // get lpCandList and init dwCount & dwSelection
  202.   lpCandList := PCandiDateList(DWord(lpCandInfo) + lpCandInfo.dwOffset[0]);
  203.   lpCandList.dwCount := 0;
  204.   lpCandList.dwSelection := 0;
  206.   // search the IME tables
  207.   Result := Engine(lpCompStr, lpCandList, lpImcP, lpIMC, wCharCode);
  209.   if (Result = ENGINE_COMP) then
  210.   begin
  211.     lpCandInfo.dwCount := 1;
  213.     if ( (lpCompStr.dwCursorPos < 3) and (wCharCode <> Ord(' ')) ) or
  214.        ( (lpCompStr.dwCursorPos = 3) and (wCharCode <> Ord(' ')) and (wCharCode <> Ord('?')) ) then
  215.     begin
  216.       lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_CLOSE_CANDIDATE) and (not MSG_OPEN_CANDIDATE);
  217.       ImmUnlockIMCC(lpIMC.hCandInfo);
  218.       Exit;
  219.     end;
  221.     if (lpCandList.dwCount <> 0) then
  222.     begin // open composition candidate UI window for the string(s)
  223.       if (lpImcP.fdwImeMsg and MSG_ALREADY_OPEN <> 0) and (MSG_ALREADY_OPEN and MSG_CLOSE_CANDIDATE <> 0) then
  224.       begin
  225.         lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_CHANGE_CANDIDATE) and (not MSG_CLOSE_CANDIDATE);
  226.       end else
  227.         if ((lpImcP.fdwImeMsg and MSG_ALREADY_OPEN) <> 0) then
  228.           lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_CHANGE_CANDIDATE)
  229.         else
  230.           lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_OPEN_CANDIDATE) and (not MSG_CLOSE_CANDIDATE);
  231.     end;
  233.     if ((lpImcP.fdwImeMsg and MSG_ALREADY_START) <> 0) then lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_COMPOSITION;
  234.   end else
  235.     if (Result = ENGINE_ASCII) then
  236.     begin
  237.       // **
  238.     end else
  239.       if (Result = ENGINE_RESAULT) then
  240.       begin
  241.         // Set lpImep!   and tell application, there is a reslut string
  242.         lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_COMPOSITION;
  243.         lpImcP.dwCompChar := 0;
  244.         lpImcP.fdwGcsFlag := lpImcP.fdwGcsFlag or GCS_COMPREAD or
  245.           GCS_COMP or GCS_CURSORPOS or GCS_DELTASTART or GCS_RESULTREAD or GCS_RESULT;
  247.         if ((lpImcP.fdwImeMsg and MSG_ALREADY_OPEN) <> 0) then
  248.           lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_CLOSE_CANDIDATE) and (not MSG_OPEN_CANDIDATE);
  250.         // clear candidate now
  251.         lpCandList.dwCount := 0;
  253.         // set iImeState with CST_INIT
  254.         lpImcP.iImeState := CST_INIT;
  255.         PDWord(@lpImcP.bSeq)^ := 0;
  256.       end;
  258.   ImmUnlockIMCC(lpIMC.hCandInfo);
  259. end;
  261.   // 添加Candidate
  262. procedure AddCodeIntoCand(lpCandList: PCandiDateList; wCode: Word);
  263. var
  264.   wInCode: Word;
  265. begin
  266.   if (lpCandList.dwCount >= IME_MAXCAND) then Exit;
  268.   wInCode := HiByte(wCode) or (LoByte(wCode) shl 8);
  270.   // add GB string into candidate list
  271.   PUnaWord(DWord(lpCandList) + lpCandList.dwOffset[lpCandList.dwCount])^ := wInCode;
  273.   // null terminator
  274.   PChar(DWord(lpCandList) + lpCandList.dwOffset[lpCandList.dwCount] + SizeOf(Word))^ := #0;
  276.   lpCandList.dwOffset[lpCandList.dwCount + 1] := lpCandList.dwOffset[lpCandList.dwCount] + SizeOf(Word) + SizeOf(Char);
  277.   Inc(lpCandList.dwCount);
  278. end;
  280.   // Composition取消处理
  281. procedure CompEscapeKey(lpIMC: PInputContext; lpCompStr: PCompositionString; lpGuideLine: PGuideLine; lpImcP: PPrivContext);
  282. begin
  283.   if (lpGuideLine = nil) then
  284.   begin
  285.     MessageBeep($FFFFFFFF);
  286.   end else
  287.     if (lpGuideLine.dwLevel <> GL_LEVEL_NOGUIDELINE) then
  288.     begin
  289.       lpGuideLine.dwLevel := GL_LEVEL_NOGUIDELINE;
  290.       lpGuideLine.dwIndex := GL_ID_UNKNOWN;
  291.       lpGuideLine.dwStrLen := 0;
  293.       lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_GUIDELINE;
  294.     end;
  296.   if (lpImcP.iImeState <> CST_CHOOSE) then
  297.     if ((lpImcP.fdwImeMsg and MSG_ALREADY_START) <> 0) then
  298.       lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_END_COMPOSITION) and (not MSG_START_COMPOSITION);
  300.   lpImcP.iImeState := CST_INIT;
  301.   PDWord(@lpImcP.bSeq)^ := 0;
  303.   if (lpCompStr <> nil) then
  304.   begin
  305.     InitCompStr(lpCompStr);
  306.     lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_COMPOSITION;
  307.     lpImcP.dwCompChar := VK_ESCAPE;
  308.     lpImcP.fdwGcsFlag := lpImcP.fdwGcsFlag or GCS_COMPREAD or GCS_COMP or GCS_CURSORPOS or GCS_DELTASTART;
  309.   end;
  310. end;
  312.   // Composition回退处理
  313. procedure CompBackSpaceKey(lpIMC: PInputContext; lpCompStr: PCompositionString; lpImcP: PPrivContext);
  314. begin
  315.   if (lpCompStr.dwCursorPos < SizeOf(Byte)) then lpCompStr.dwCursorPos := SizeOf(Byte);
  317.   lpImcP.bSeq[3] := #0;
  319.   // go back a compsoition char
  320.   Dec(lpCompStr.dwCursorPos, SizeOf(Byte));
  322.   // clean the sequence code
  323.   lpImcP.bSeq[lpCompStr.dwCursorPos] := #0;
  325.   lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_COMPOSITION;
  326.   lpImcP.dwCompChar := $08;
  327.   lpImcP.fdwGcsFlag := lpImcP.fdwGcsFlag or GCS_COMPREAD or GCS_COMP or GCS_CURSORPOS or GCS_DELTASTART;
  329.   if (lpCompStr.dwCursorPos = 0) then
  330.   begin
  331.     if ((lpImcP.fdwImeMsg and MSG_ALREADY_OPEN) <> 0) then
  332.     begin
  333.       ClearCand(lpIMC);
  334.       lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_CLOSE_CANDIDATE) and (not MSG_OPEN_CANDIDATE);
  335.     end;
  337.     if (lpImcP.iImeState <> CST_INIT) then
  338.     begin
  339.       lpImcP.iImeState := CST_INIT;
  340.       lpCompStr.dwCompReadStrLen := lpCompStr.dwCursorPos;
  341.       lpCompStr.dwCompStrLen := lpCompStr.dwCursorPos;
  342.       lpCompStr.dwDeltaStart := lpCompStr.dwCursorPos;
  343.       Finalize(lpIMC, lpCompStr, lpImcP, $08);
  344.       Exit;
  345.     end;
  347.     if ((lpImcP.fdwImeMsg and MSG_ALREADY_START) <> 0) then
  348.     begin
  349.       InitCompStr(lpCompStr);
  350.       lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_END_COMPOSITION) and (not MSG_START_COMPOSITION);
  351.       Exit;
  352.     end;
  353.   end;
  355.   // reading string is composition string for some simple IMEs
  356.   // delta start is the same as cursor position for backspace
  357.   lpCompStr.dwCompReadStrLen := lpCompStr.dwCursorPos;
  358.   lpCompStr.dwCompStrLen := lpCompStr.dwCursorPos;
  359.   lpCompStr.dwDeltaStart := lpCompStr.dwCursorPos;
  360.   Finalize(lpIMC, lpCompStr, lpImcP, $08);
  361. end;
  363.   // 添加Composition, **
  364. procedure CompStrInfo(lpCompStr: PCompositionString; lpImcP: PPrivContext; lpGuideLine: PGuideLine; wCharCode: Word);
  365. var
  366.   dwCursorPos: DWord;
  367. begin
  368.   dwCursorPos := lpCompStr.dwCursorPos;
  370.   // dwCrusorPos limit
  371.   if (dwCursorPos >= sImeL.nMaxKey) then
  372.   begin
  373.     // exceed the max input key limitation
  374.     lpGuideLine.dwLevel := GL_LEVEL_ERROR;
  375.     lpGuideLine.dwIndex := GL_ID_TOOMANYSTROKE;
  376.     lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_GUIDELINE;
  377.     Exit;
  378.   end;
  380.   // set MSG_START_COMPOSITION
  381.   if ((lpImcP.fdwImeMsg and MSG_ALREADY_START) = 0) then
  382.     lpImcP.fdwImeMsg := (lpImcP.fdwImeMsg or MSG_START_COMPOSITION) and (not MSG_END_COMPOSITION);
  384.   // clean the 4 bytes in one time
  385.   if (lpImcP.iImeState = CST_INIT) then PDWord(@lpImcP.bSeq)^ := 0;
  387.   // **
  388.   lpImcP.bSeq[dwCursorPos] := Chr(Byte(wCharCode));
  390.   // composition/reading string - UsedCode(Full Shape)
  391.   lpImcP.dwCompChar := wCharCode;
  393.   // set reading string for lpCompStr
  394.   PUnaWord(DWord(lpCompStr) + lpCompStr.dwCompReadStrOffset + dwCursorPos)^ := Byte(lpImcP.dwCompChar);
  395.   PUnaWord(DWord(lpCompStr) + lpCompStr.dwCompReadAttrOffset + dwCursorPos)^ := (ATTR_TARGET_CONVERTED shl 8) or ATTR_TARGET_CONVERTED;
  397.   // set reading string lenght for lpCompStr
  398.   if (lpCompStr.dwCompReadStrLen <= dwCursorPos) then Inc(lpCompStr.dwCompReadStrLen, SizeOf(Byte));
  400.   // composition string is reading string for some simple IMEs
  401.   lpCompStr.dwCompStrLen := lpCompStr.dwCompReadStrLen;
  403.   // composition/reading attribute length is equal to reading string length
  404.   lpCompStr.dwCompReadAttrLen := lpCompStr.dwCompReadStrLen;
  405.   lpCompStr.dwCompAttrLen := lpCompStr.dwCompStrLen;
  407.   // delta start from previous cursor position
  408.   lpCompStr.dwDeltaStart := lpCompStr.dwCursorPos;
  410.   // set new cursor with next to the composition string
  411.   lpCompStr.dwCursorPos := lpCompStr.dwCompStrLen;
  413.   // set lpImcp->iImeState
  414.   lpImcP.iImeState := CST_INPUT;
  416.   // tell app, there is a composition char generated
  417.   lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_COMPOSITION;
  419.   // set lpImeP->fdwGcsFlag
  420.   lpImcP.fdwGcsFlag := lpImcP.fdwGcsFlag or GCS_COMPREAD or GCS_COMP or GCS_CURSORPOS or GCS_DELTASTART;
  421. end;
  423.   // compose the Chinese word(s) according to input key
  424. procedure CompWord(wCharCode: Word; lpIMC: PInputContext;
  425.   lpCompStr: PCompositionString; lpImcP: PPrivContext; lpGuideLine: PGuideLine);
  426. begin
  427.   if (lpCompStr = nil) then begin MessageBeep($FFFFFFFF); Exit; end;
  429.   // not good to use VK as char, but..., ??
  430.   if (wCharCode = VK_ESCAPE) then  // 取消
  431.   begin
  432.     CompEscapeKey(lpIMC, lpCompStr, lpGuideLine, lpImcP);
  433.     Exit;
  434.   end;
  436.   if (lpGuideLine = nil) then
  437.   begin
  438.   end else
  439.     if (lpGuideLine.dwLevel = GL_LEVEL_NOGUIDELINE) then
  440.     begin
  441.       lpGuideLine.dwStrLen := 0;
  442.     end else
  443.     begin
  444.       // previous input error cause us trancate some chars
  445.       if (lpGuideLine.dwLevel = GL_LEVEL_ERROR) then
  446.       begin
  447.         lpImcP.bSeq[lpCompStr.dwCursorPos div 2] := #0;
  448.         lpCompStr.dwCompReadStrLen := lpCompStr.dwCursorPos; // **
  449.         lpCompStr.dwCompStrLen := lpCompStr.dwCursorPos;
  450.         lpCompStr.dwCompReadAttrLen := lpCompStr.dwCompReadStrLen;
  451.         lpCompStr.dwCompAttrLen := lpCompStr.dwCompStrLen;
  452.       end;
  454.       lpGuideLine.dwLevel := GL_LEVEL_NOGUIDELINE;
  455.       lpGuideLine.dwIndex := GL_ID_UNKNOWN;
  456.       lpGuideLine.dwStrLen := 0;
  457.       lpImcP.fdwImeMsg := lpImcP.fdwImeMsg or MSG_GUIDELINE;
  458.     end;
  460.   if (wCharCode = $08) then // 回格
  461.   begin
  462.     CompBackSpaceKey(lpIMC, lpCompStr, lpImcP);
  463.     Exit;
  464.   end;
  466.   if (wCharCode <> Ord(' ')) then
  467.     CompStrInfo(lpCompStr, lpImcP, lpGuideLine, wCharCode); // build up composition string info
  469.   Finalize(lpIMC, lpCompStr, lpImcP, wCharCode); // compsition
  470. end;
  472. end.