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

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

输入法编程

开发平台：

Delphi

Candui.pas：源码内容
  2.  {******************************************************}
  3.  {                                                      }
  4.  {    Copyright (c) 1990-1999 Microsoft Corporation     }
  5.  {                                                      }
  6.  {    Module Name:  Candui.c ->>  Candui.pas            }
  7.  {                                                      }
  8.  {    Translator:  Liu_mazi@126.com, 2005-11-17         }
  9.  {                                                      }
  10.  {******************************************************}
  12. unit Candui;
  14. {$I Define.Inc}
  16. interface
  18. uses Windows, ImmDev;
  20. function GetCandWnd(hUIWnd: hWnd): hWnd;  // 返回Candidate窗口句柄
  21. function CandWndProc(hCandWnd: hWnd; uMsg: uInt; wParam: WParam; lParam: LParam): LResult; stdcall;  // Candidate窗口回调
  22. procedure ShowCand(hUIWnd: hWnd; nShowCandCmd: Integer);  // 显示隐藏Candidate窗口
  23. procedure OpenCand(hUIWnd: hWnd);  // "打开"Candidate窗口
  24. procedure PaintCandWindow(hCandWnd: hWnd; _hDC: hDC);  // 绘制Candidate窗口
  25. procedure CloseCand(hUIWnd: hWnd);  // 隐藏Candidate窗口
  26. procedure CalcCandPos(_hIMC: hIMC; hUIWnd: hWnd; lpptWnd: PPoint); // 计算Candidate窗口位置
  28. implementation
  30. uses Messages, ImeDefs, Data, Notify, Ui, Uisubs, Compui, Chcand, LogText;
  32.   // 返回Candidate窗口句柄
  33. function GetCandWnd(hUIWnd: hWnd): hWnd;
  34. var
  35.   hUIPrivate: hGlobal;
  36.   lpUIPrivate: PUIPriv;
  37. begin
  38.   Result := 0;
  40.   hUIPrivate := GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
  41.   if (hUIPrivate = 0) then Exit;    // can not darw candidate window
  43.   lpUIPrivate := GlobalLock(hUIPrivate);
  44.   if (lpUIPrivate = nil) then Exit; // can not draw candidate window
  46.   Result := lpUIPrivate.hCandWnd;
  47.   GlobalUnlock(hUIPrivate);
  48. end;
  50.   // 计算Candidate窗口位置
  51. procedure CalcCandPos(_hIMC: hIMC; hUIWnd: hWnd; lpptWnd: PPoint);
  52. var
  53.   ptNew, ptSTWPos: TPoint;
  54.   hCompWnd: hWnd;
  55. begin
  56.   if (sImeG.IC_Trace = 0) then // 光标跟随 = False
  57.   begin
  58.     ImmGetStatusWindowPos(_hIMC, @ptSTWPos);
  60.     hCompWnd := GetCompWnd(hUIWnd);
  61.     if IsWindow(hCompWnd) then
  62.     begin
  63.       ptNew.x := ptSTWPos.x + sImeG.xStatusWi + sImeL.xCompWi + 2 * UI_MARGIN;
  64.       if (ptNew.x + sImeG.xCandWi > sImeG.rcWorkArea.Right) then
  65.       begin
  66.         if (ptSTWPos.x >= (sImeG.xCandWi + sImeL.xCompWi + 2 * UI_MARGIN)) then
  67.           ptNew.x := ptSTWPos.x - sImeL.xCompWi - sImeG.xCandWi - 2 * UI_MARGIN
  68.         else
  69.           ptNew.x := ptSTWPos.x + sImeG.xStatusWi + UI_MARGIN;
  70.       end;
  72.       ptNew.y := ptSTWPos.y + sImeL.cyCompBorder - sImeG.cyCandBorder;
  73.       if (ptNew.y + sImeG.yCandHi > sImeG.rcWorkArea.Bottom) then ptNew.y := sImeG.rcWorkArea.Bottom - sImeG.yCandHi;
  74.     end else
  75.     begin
  76.       ptNew.x := ptSTWPos.x + sImeG.xStatusWi + UI_MARGIN;
  77.       if (ptNew.x + sImeG.xCandWi >= sImeG.rcWorkArea.Right) and
  78.          (ptSTWPos.x >= sImeG.xCandWi + UI_MARGIN) then
  79.       begin
  80.         ptNew.x := ptSTWPos.x - sImeG.xCandWi - UI_MARGIN;
  81.       end;
  83.       ptNew.y := ptSTWPos.y + sImeL.cyCompBorder - sImeG.cyCandBorder;
  84.       if (ptNew.y + sImeG.yCandHi > sImeG.rcWorkArea.Bottom) then ptNew.y := sImeG.rcWorkArea.Bottom - sImeG.yCandHi;
  85.     end;
  86.   end else                     // 光标跟随 = True
  87.   begin
  88.     ptNew.x := lpptWnd.x + sImeL.xCompWi + UI_MARGIN;
  89.     if (ptNew.x + sImeG.xCandWi > sImeG.rcWorkArea.Right) then ptNew.x := lpptWnd.x - sImeG.xCandWi - UI_MARGIN;
  91.     ptNew.y := lpptWnd.y + sImeL.cyCompBorder - sImeG.cyCandBorder;
  92.     if (ptNew.y + sImeG.yCandHi > sImeG.rcWorkArea.Bottom) then ptNew.y := sImeG.rcWorkArea.Bottom - sImeG.yCandHi;
  93.   end;
  95.   lpptWnd^ := ptNew;
  96. end;
  98.   // 微调Candidate窗口位置
  99. procedure AdjustCandPos(_hIMC: hIMC; lpptWnd: PPoint);
  100. var
  101.   lpIMC: PInputContext;
  102.   ptFontHi: Integer;
  103.   uEsc: uInt;
  104. begin
  105.   lpIMC := ImmLockIMC(_hIMC);
  106.   if (lpIMC = nil) then Exit;
  108.   if (lpIMC.lfFont.A.lfHeight > 0) then
  109.   begin
  110.     ptFontHi := lpIMC.lfFont.A.lfHeight;
  111.   end else
  112.     if (lpIMC.lfFont.A.lfWidth = 0) then
  113.       ptFontHi := sImeL.yCompHi
  114.     else
  115.       ptFontHi := -lpIMC.lfFont.A.lfHeight;
  117.   if (ptFontHi > sImeL.yCompHi * 8) then ptFontHi := sImeL.yCompHi * 8;
  118.   if (ptFontHi < sImeG.yChiCharHi) then ptFontHi := sImeG.yChiCharHi;
  120.   // -450 to 450 index 0
  121.   // 450 to 1350 index 1
  122.   // 1350 to 2250 index 2
  123.   // 2250 to 3150 index 3
  124.   uEsc := (lpIMC.lfFont.A.lfEscapement + 450) div 900 mod 4;
  126.   // find the location after IME do an adjustment
  127.   ptFontHi := ptFontHi * ptInputEsc[uEsc].y;
  129.   if (lpptWnd.y + ptFontHi + sImeG.yCandHi <= sImeG.rcWorkArea.Bottom) then
  130.     Inc(lpptWnd.y, ptFontHi)
  131.   else
  132.     Dec(lpptWnd.y, ptFontHi + sImeG.yCandHi);
  134.   ImmUnlockIMC(_hIMC);
  135. end;
  137.   // 修正Candidate窗口位置
  138. procedure AdjustCandBoundry(lpptCandWnd: PPoint);
  139. begin
  140.   if (lpptCandWnd.x < sImeG.rcWorkArea.Left) then
  141.   begin
  142.     lpptCandWnd.x := sImeG.rcWorkArea.Left;
  143.   end else
  144.     if (lpptCandWnd.x + sImeG.xCandWi > sImeG.rcWorkArea.Right) then
  145.     begin
  146.       lpptCandWnd.x := sImeG.rcWorkArea.Right - sImeG.xCandWi;
  147.     end;
  149.   if (lpptCandWnd.y < sImeG.rcWorkArea.Top) then
  150.   begin
  151.     lpptCandWnd.y := sImeG.rcWorkArea.Top;
  152.   end else
  153.     if (lpptCandWnd.y + sImeG.yCandHi > sImeG.rcWorkArea.Bottom) then
  154.     begin
  155.       lpptCandWnd.y := sImeG.rcWorkArea.Bottom - sImeG.yCandHi;
  156.     end;
  157. end;
  159.   // 设置Candidate窗口位置
  160. function SetCandPosition(hCandWnd: hWnd): LResult;
  161. var
  162.   hUIWnd: hWnd;
  163.   _hIMC: hIMC;
  164.   lpIMC: PInputContext;
  165.   ptNew: TPoint;
  166. begin
  167.   Result := 1;
  169.   hUIWnd := GetWindow(hCandWnd, GW_OWNER);
  170.   if (IsWindow(hUIWnd) = False) then Exit;
  172.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  173.   if (_hIMC = 0) then Exit;
  175.   lpIMC := ImmLockIMC(_hIMC);
  176.   if (lpIMC = nil) then Exit;
  178.   ptNew := lpIMC.cfCandForm[0].ptCurrentPos;
  179.   ClientToScreen(lpIMC.hWnd, ptNew);
  181.   if ((lpIMC.cfCandForm[0].dwStyle and CFS_FORCE_POSITION) <> 0) then
  182.   begin
  183.   end else
  184.     if (lpIMC.cfCandForm[0].dwStyle = CFS_CANDIDATEPOS) then
  185.     begin
  186.       AdjustCandBoundry(@ptNew);
  187.     end else
  188.       if (lpIMC.cfCandForm[0].dwStyle = CFS_EXCLUDE) then
  189.       begin
  190.         if (sImeG.IC_Trace = 0) then CalcCandPos(_hIMC, hUIWnd, @ptNew);
  191.         AdjustCandBoundry(@ptNew);
  192.       end;
  194.   SetWindowPos(hCandWnd, 0, ptNew.x, ptNew.y, 0, 0, SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER);
  196.   ImmUnlockIMC(_hIMC);
  197.   Result := 0;
  198. end;
  200.   // 显示隐藏Candidate窗口
  201. procedure ShowCand(hUIWnd: hWnd; nShowCandCmd: Integer);
  202. label
  203.   ShowCand;
  204. var
  205.   hUIPrivate: hGlobal;
  206.   lpUIPrivate: PUIPriv;
  207.   _hIMC: hIMC;
  208.   ptSTWPos: TPoint;  
  209.   Comp_CandWndLen: Integer;
  210. begin
  211.   hUIPrivate := GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
  212.   if (hUIPrivate = 0) then Exit;          // can not darw candidate window
  214.   lpUIPrivate := GlobalLock(hUIPrivate);
  215.   if (lpUIPrivate = nil) then Exit;       // can not draw candidate window
  217.   if (lpUIPrivate.nShowCandCmd = nShowCandCmd) then Exit; // **
  219.   if (nShowCandCmd = SW_HIDE) then
  220.     lpUIPrivate.fdwSetContext := lpUIPrivate.fdwSetContext and (not ISC_HIDE_CAND_WINDOW);
  222.   if IsWindow(lpUIPrivate.hCandWnd) then
  223.     if (lpUIPrivate.nShowCandCmd = nShowCandCmd) then // 无变化
  224.     begin
  225.     end else
  226.     begin
  227.       if (nShowCandCmd = SW_HIDE) then
  228.       begin
  229.         uOpenCand := 0;
  230.       end else
  231.       begin
  232.         uOpenCand := 1;
  234.         // reset status window for LINE_UI(FIX_UI)
  235.         _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  236.         if (_hIMC = 0) then goto ShowCand;
  238.         ImmGetStatusWindowPos(_hIMC, @ptSTWPos);
  239.         Comp_CandWndLen := 0;
  240.         if (uOpenCand <> 0) then
  241.         begin
  242.           Inc(Comp_CandWndLen, sImeG.xCandWi + UI_MARGIN);
  243.           if (uStartComp <> 0) then Inc(Comp_CandWndLen, sImeL.xCompWi + UI_MARGIN);
  244.           if (ptSTWPos.x + sImeG.xStatusWi + Comp_CandWndLen > sImeG.rcWorkArea.Right) then
  245.             PostMessage(GetCompWnd(hUIWnd), WM_IME_NOTIFY, IMN_SETCOMPOSITIONWINDOW, 0);
  246.         end;
  247.       end;
  249. ShowCand:
  250.       ShowWindow(lpUIPrivate.hCandWnd, nShowCandCmd);
  251.       lpUIPrivate.nShowCandCmd := nShowCandCmd;
  252.     end;
  254.   GlobalUnlock(hUIPrivate);
  255. end;
  257.   // "打开"Candidate窗口
  258. procedure OpenCand(hUIWnd: hWnd);
  259. label
  260.   OpenCandUnlockUIPriv;
  261. var
  262.   hUIPrivate: hGlobal;
  263.   lpUIPrivate: PUIPriv;
  264.   _hIMC: hIMC;
  265.   lpIMC: PInputContext;
  266.   ptWnd, ptCaret: TPoint;
  267. begin
  268.   hUIPrivate := GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
  269.   if (hUIPrivate = 0) then Exit;          // can not darw candidate window
  271.   lpUIPrivate := GlobalLock(hUIPrivate);
  272.   if (lpUIPrivate = nil) then Exit;       // can not draw candidate window
  274.   lpUIPrivate.fdwSetContext := lpUIPrivate.fdwSetContext or ISC_SHOWUICANDIDATEWINDOW;
  276.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  277.   if (_hIMC = 0) then goto OpenCandUnlockUIPriv;
  279.   lpIMC := ImmLockIMC(_hIMC);
  280.   if (lpIMC = nil) then goto OpenCandUnlockUIPriv;
  282.   if (lpIMC.cfCandForm[0].dwIndex = 0) then
  283.   begin
  284.     ptWnd := lpIMC.cfCandForm[0].ptCurrentPos;
  285.     ClientToScreen(lpIMC.hWnd, ptWnd);
  287.     if (lpIMC.cfCandForm[0].dwStyle and CFS_FORCE_POSITION) <> 0 then
  288.     begin
  289.     end else
  290.     begin
  291.       if (lpIMC.cfCandForm[0].dwStyle = CFS_EXCLUDE) then
  292.       begin
  293.         AdjustCandBoundry(@ptWnd);
  295.         if (sImeG.IC_Trace = 0) or (GetCaretPos(ptCaret) = False) then // **
  296.         begin
  297.           if IsWindow(GetCompWnd(hUIWnd)) then
  298.           begin
  299.             ptWnd.x := 0;
  300.             ptWnd.y := 0;
  301.             ClientToScreen(lpIMC.hWnd, ptWnd);
  302.             Dec(ptWnd.x, sImeL.cxCompBorder + 1);
  303.             Dec(ptWnd.y, sImeL.cyCompBorder + 1);
  304.           end else
  305.           begin
  306.             ptWnd.x := sImeL.cxCompBorder + 1;
  307.             ptWnd.y := sImeL.cyCompBorder + 1;
  308.           end;
  310.           CalcCandPos(_hIMC, hUIWnd, @ptWnd);
  312.           lpIMC.cfCandForm[0].dwStyle := lpIMC.cfCandForm[0].dwStyle or CFS_CANDIDATEPOS;
  313.           lpIMC.cfCandForm[0].ptCurrentPos := ptWnd;
  315.           ScreenToClient(lpIMC.hWnd, lpIMC.cfCandForm[0].ptCurrentPos);
  316.         end else
  317.         begin
  318.           AdjustCandPos(_hIMC, @ptWnd);
  319.         end;
  320.       end else
  321.         if (lpIMC.cfCandForm[0].dwStyle = CFS_CANDIDATEPOS) then
  322.         begin
  323.           AdjustCandBoundry(@ptWnd);
  324.         end else
  325.         begin
  326.           if (lpUIPrivate.nShowCompCmd <> SW_HIDE) then
  327.           begin
  328.             ptWnd.x := 0;
  329.             ptWnd.y := 0;
  330.             ClientToScreen(lpUIPrivate.hCompWnd, ptWnd);
  331.           end else
  332.           begin
  333.             ptWnd := lpIMC.cfCompForm.ptCurrentPos;
  334.             ClientToScreen(lpIMC.hWnd, ptWnd);
  335.           end;
  337.           Dec(ptWnd.x, sImeL.cxCompBorder + 1);
  338.           Dec(ptWnd.y, sImeL.cyCompBorder + 1);
  340.           CalcCandPos(_hIMC, hUIWnd, @ptWnd);
  342.           lpIMC.cfCandForm[0].dwStyle := lpIMC.cfCandForm[0].dwStyle or CFS_CANDIDATEPOS;
  343.           lpIMC.cfCandForm[0].ptCurrentPos := ptWnd;
  344.           ScreenToClient(lpIMC.hWnd, lpIMC.cfCandForm[0].ptCurrentPos);
  345.         end;
  346.     end;
  347.   end else
  348.   begin
  349.     // make cand windows trace comp window !
  351.     if (lpUIPrivate.nShowCompCmd <> SW_HIDE) then
  352.     begin
  353.       ptWnd.x := 0;
  354.       ptWnd.y := 0;
  355.       ClientToScreen(lpUIPrivate.hCompWnd, ptWnd);
  356.     end else
  357.     begin
  358.       ptWnd := lpIMC.cfCompForm.ptCurrentPos;
  359.       ClientToScreen(lpIMC.hWnd, ptWnd);
  360.     end;
  362.     Dec(ptWnd.x, sImeL.cxCompBorder + 1);
  363.     Dec(ptWnd.y, sImeL.cyCompBorder + 1);
  365.     CalcCandPos(_hIMC, hUIWnd, @ptWnd);
  367.     lpIMC.cfCandForm[0].dwStyle := lpIMC.cfCandForm[0].dwStyle or CFS_CANDIDATEPOS;
  368.     lpIMC.cfCandForm[0].ptCurrentPos := ptWnd;
  369.     ScreenToClient(lpIMC.hWnd, lpIMC.cfCandForm[0].ptCurrentPos);
  370.   end;
  372.   ImmUnlockIMC(_hIMC);
  374.   if IsWindow(lpUIPrivate.hCandWnd) then
  375.   begin
  376.     SetWindowPos(lpUIPrivate.hCandWnd, 0, ptWnd.x, ptWnd.y, 0, 0, SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER);
  377.   end else
  378.   begin
  379.     lpUIPrivate.hCandWnd := CreateWindowEx(WS_EX_WINDOWEDGE or WS_EX_DLGMODALFRAME,
  380.       szCandClassName, nil, WS_POPUP or WS_DISABLED, ptWnd.x, ptWnd.y,
  381.       sImeG.xCandWi, sImeG.yCandHi, hUIWnd, 0, HInstance, nil);
  383.     SetWindowLong(lpUIPrivate.hCandWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
  384.     SetWindowLong(lpUIPrivate.hCandWnd, UI_MOVE_XY, 0);
  385.   end;
  386.   ShowCand(hUIWnd, SW_SHOWNOACTIVATE);
  388. OpenCandUnlockUIPriv:
  389.   GlobalUnlock(hUIPrivate);
  390. end;
  392.   // 隐藏Candidate窗口
  393. procedure CloseCand(hUIWnd: hWnd);
  394. begin
  395.   uOpenCand := 0;
  396.   ShowCand(hUIWnd, SW_HIDE);
  397. end;
  399.   // WM_DESTROY消息处理
  400. procedure DestroyCandWindow(hCandWnd: hWnd);
  401. var
  402.   hUIPrivate: hGlobal;
  403.   lpUIPrivate: PUIPriv;
  404. begin
  405.   if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) <> WINDOW_NOT_DRAG) then  // undo the drag border
  406.     DrawDragBorder(hCandWnd, GetWindowLong(hCandWnd, UI_MOVE_XY), GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
  408.   hUIPrivate := GetWindowLong(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_PRIVATE);
  409.   if (hUIPrivate = 0) then Exit;    // can not darw candidate window
  411.   lpUIPrivate := GlobalLock(hUIPrivate);
  412.   if (lpUIPrivate = nil) then Exit; // can not draw candidate window
  414.   lpUIPrivate.nShowCandCmd := SW_HIDE;
  415.   lpUIPrivate.hCandWnd := 0;
  417.   GlobalUnlock(hUIPrivate);
  418. end;
  420.   // 鼠标点击选择汉字
  421. procedure MouseSelectCandStr(hCandWnd: hWnd; lpCursor: PPoint);
  422. var
  423.   _hIMC: hIMC;
  424.   lpIMC: PInputContext;
  425.   lpCandInfo: PCandiDateInfo;
  426.   lpCandList: PCandiDateList;
  427.   dwValue: DWord;
  428. begin
  429.   _hIMC := GetWindowLong(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_IMC);
  430.   if (_hIMC = 0) then Exit;
  432.   lpIMC := ImmLockIMC(_hIMC);
  433.   if (lpIMC = nil) then Exit;
  435.   if (lpIMC.hCandInfo = 0) then
  436.   begin
  437.     ImmUnlockIMC(_hIMC);
  438.     Exit;
  439.   end;
  441.   lpCandInfo := ImmLockIMCC(lpIMC.hCandInfo);
  442.   if (lpCandInfo = nil) then
  443.   begin
  444.     ImmUnlockIMC(_hIMC);
  445.     Exit;
  446.   end;
  448.   dwValue := (lpCursor.y - sImeG.rcCandText.Top) div sImeG.yChiCharHi; // **
  449.   lpCandList := PCandidateList(DWord(lpCandInfo) + lpCandInfo.dwOffset[0]);
  450.   dwValue := dwValue + lpCandList.dwSelection div lpCandList.dwPageSize * lpCandList.dwPageSize;
  452.   if (dwValue >= lpCandList.dwCount) then MessageBeep($FFFFFFFF)  // invalid choice
  453.   else NotifyIME(_hIMC, NI_SELECTCANDIDATESTR, 0, dwValue);
  455.   ImmUnlockIMCC(lpIMC.hCandInfo);
  456.   ImmUnlockIMC(_hIMC);
  457. end;
  459.   // Candidate窗口翻页
  460. procedure CandPageDownUP(hCandWnd: hWnd; uCandDownUp: uInt);
  461. var
  462.   _hIMC: hIMC;
  463.   lpIMC: PInputContext;
  464.   lpImcP: PPrivContext;
  465.   lpCandInfo: PCandiDateInfo;
  466.  // lpCandList: PCandiDateList;
  467.   _hDC: hDC;
  468.   hCandHpBmp, hCandUpBmp, hCandDpBmp, hCandEpBmp, hOldBmp: hBitmap;
  469.   hMemDC: hDC;
  470. begin
  471.   // change candlist
  472.   _hIMC := GetWindowLong(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_IMC);
  473.   if (_hIMC = 0) then Exit;
  475.   // get lpIMC
  476.   lpIMC := ImmLockIMC(_hIMC);
  477.   if (lpIMC = nil) then Exit;
  479.   // get lpImcP
  480.   lpImcP := ImmLockIMCC(lpIMC.hPrivate);
  481.   if (lpImcP = nil) then Exit;
  483.   // get lpCandInfo
  484.   lpCandInfo := ImmLockIMCC(lpIMC.hCandInfo);
  485.   if (lpCandInfo = nil) then Exit;
  487.   // get lpCandList and init dwCount & dwSelection, 未用到, --
  488.   // lpCandList := PCandiDateList(DWord(lpCandInfo) + lpCandInfo.dwOffset[0]);
  490.   case (uCandDownUp) of
  491.     uCandHome:
  492.     begin
  493.       ChooseCand($24, lpIMC, lpCandInfo, lpImcP);
  494.       NotifyIME(_hIMC, NI_CHANGECANDIDATELIST, 0, 0);
  495.     end;
  497.     uCandUp:
  498.     begin
  499.       ChooseCand(Ord('-'), lpIMC, lpCandInfo, lpImcP);
  500.       NotifyIME(_hIMC, NI_CHANGECANDIDATELIST, 0, 0);
  501.     end;
  503.     uCandDown:
  504.     begin
  505.       ChooseCand(Ord('='), lpIMC, lpCandInfo, lpImcP);
  506.       NotifyIME(_hIMC, NI_CHANGECANDIDATELIST, 0, 0);
  507.     end;
  509.     uCandEnd:
  510.     begin
  511.       ChooseCand($0023, lpIMC, lpCandInfo, lpImcP);
  512.       NotifyIME(_hIMC, NI_CHANGECANDIDATELIST, 0, 0);
  513.     end;
  514.   end;
  516.   ImmUnlockIMCC(lpIMC.hPrivate);
  517.   ImmUnlockIMCC(lpIMC.hCandInfo);
  518.   ImmUnlockIMC(_hIMC);
  520.   // draw button down
  521.   _hDC := GetDC(hCandWnd);
  522.   hCandHpBmp := LoadBitmap(HInstance, 'CandHp');
  523.   hCandUpBmp := LoadBitmap(HInstance, 'CandUp');
  524.   hCandDpBmp := LoadBitmap(HInstance, 'CandDp');
  525.   hCandEpBmp := LoadBitmap(HInstance, 'CandEp');
  527.   hMemDC := CreateCompatibleDC(_hDC);
  529.   case (uCandDownUp) of
  530.     uCandHome:
  531.     begin
  532.       hOldBmp := SelectObject(hMemDC, hCandHpBmp);
  533.       BitBlt(_hDC, sImeG.rcCandBTH.Left, sImeG.rcCandBTH.Top,
  534.         sImeG.rcCandBTH.Right - sImeG.rcCandBTH.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  535.     end;
  537.     uCandUp:
  538.     begin
  539.       hOldBmp := SelectObject(hMemDC, hCandUpBmp);
  540.       BitBlt(_hDC, sImeG.rcCandBTU.Left, sImeG.rcCandBTU.Top,
  541.         sImeG.rcCandBTU.Right - sImeG.rcCandBTU.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  542.     end;
  544.     uCandDown:
  545.     begin
  546.       hOldBmp := SelectObject(hMemDC, hCandDpBmp);
  547.       BitBlt(_hDC, sImeG.rcCandBTD.Left, sImeG.rcCandBTD.Top,
  548.         sImeG.rcCandBTD.Right - sImeG.rcCandBTD.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  549.     end;
  551.     uCandEnd:
  552.     begin
  553.       hOldBmp := SelectObject(hMemDC, hCandEpBmp);
  554.       BitBlt(_hDC, sImeG.rcCandBTE.Left, sImeG.rcCandBTE.Top,
  555.         sImeG.rcCandBTE.Right - sImeG.rcCandBTE.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  556.     end;
  558.     else hOldBmp := 0;
  559.   end;
  561.   SelectObject(hMemDC, hOldBmp);
  562.   DeleteDC(hMemDC);
  563.   DeleteObject(hCandEpBmp);
  564.   DeleteObject(hCandDpBmp);
  565.   DeleteObject(hCandUpBmp);
  566.   DeleteObject(hCandHpBmp);
  567.   ReleaseDC(hCandWnd, _hDC);
  568. end;
  570.   // WM_SETCURSOR消息处理
  571. procedure CandSetCursor(hCandWnd: hWnd; lParam: LParam);
  572. var
  573.   ptCursor: TPoint;
  574.   rcWnd: TRect;
  575.   _hDC, hMemDC: hDC;
  576.   hCandHBmp, hCandUBmp, hCandDBmp, hCandEBmp, hOldBmp: hBitmap;
  577. begin
  578.   if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) <> WINDOW_NOT_DRAG) then
  579.   begin
  580.     SetCursor(LoadCursor(0, IDC_SIZEALL));
  581.     Exit;
  582.   end;
  584.   if (HiWord(lParam) = WM_LBUTTONDOWN) then
  585.   begin
  586.     SystemParametersInfo(SPI_GETWORKAREA, 0, @sImeG.rcWorkArea, 0);
  587.     GetCursorPos(ptCursor);
  588.     ScreenToClient(hCandWnd, ptCursor);
  590.     if PtInRect(sImeG.rcCandText, ptCursor) // 文字
  591.        and (sImeG.IC_Trace <> 0) then
  592.     begin
  593.       SetCursor(LoadCursor(HInstance, szHandCursor));
  594.       MouseSelectCandStr(hCandWnd, @ptCursor);
  595.     end else
  596.       if PtInRect(sImeG.rcCandBTH, ptCursor) then // 首页
  597.       begin
  598.         CandPageDownUP(hCandWnd, uCandHome);
  599.       end else
  600.         if PtInRect(sImeG.rcCandBTU, ptCursor) then // 上翻
  601.         begin
  602.           CandPageDownUP(hCandWnd, uCandUp);
  603.         end else
  604.           if PtInRect(sImeG.rcCandBTD, ptCursor) then // 下翻
  605.           begin
  606.             CandPageDownUP(hCandWnd, uCandDown);
  607.           end else
  608.             if (PtInRect(sImeG.rcCandBTE, ptCursor)) then // 末页
  609.             begin
  610.               CandPageDownUP(hCandWnd, uCandEnd);
  611.             end else
  612.             begin
  613.               SetCursor(LoadCursor(0, IDC_SIZEALL));
  615.               SetCapture(hCandWnd);
  617.               GetCursorPos(ptCursor);
  618.               SetWindowLong(hCandWnd, UI_MOVE_XY, MakeLong(ptCursor.x, ptCursor.y));
  620.               GetWindowRect(hCandWnd, rcWnd);
  621.               SetWindowLong(hCandWnd, UI_MOVE_OFFSET, MakeLong(ptCursor.x - rcWnd.Left, ptCursor.y - rcWnd.Top));
  622.               
  623.               DrawDragBorder(hCandWnd, MakeLong(ptCursor.x, ptCursor.y), GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
  624.             end;
  625.   end else
  626.     if (HiWord(lParam) = WM_LBUTTONUP) then
  627.     begin
  628.       _hDC := GetDC(hCandWnd);
  630.       hCandHBmp := LoadBitmap(HInstance, 'CandH');
  631.       hCandUBmp := LoadBitmap(HInstance, 'CandU');
  632.       hCandDBmp := LoadBitmap(HInstance, 'CandD');
  633.       hCandEBmp := LoadBitmap(HInstance, 'CandE');
  634.       hMemDC := CreateCompatibleDC(_hDC);
  636.       hOldBmp := SelectObject(hMemDC, hCandHBmp);
  637.       BitBlt(_hDC, sImeG.rcCandBTH.Left, sImeG.rcCandBTH.Top,
  638.         sImeG.rcCandBTH.Right - sImeG.rcCandBTH.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  640.       SelectObject(hMemDC, hCandUBmp);
  641.       BitBlt(_hDC, sImeG.rcCandBTU.Left, sImeG.rcCandBTU.Top,
  642.         sImeG.rcCandBTU.Right - sImeG.rcCandBTU.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  644.       SelectObject(hMemDC, hCandDBmp);
  645.       BitBlt(_hDC, sImeG.rcCandBTD.Left, sImeG.rcCandBTD.Top,
  646.         sImeG.rcCandBTD.Right - sImeG.rcCandBTD.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  648.       SelectObject(hMemDC, hCandEBmp);
  649.       BitBlt(_hDC, sImeG.rcCandBTE.Left, sImeG.rcCandBTE.Top,
  650.         sImeG.rcCandBTE.Right - sImeG.rcCandBTE.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  652.       SelectObject(hMemDC, hOldBmp);
  653.       DeleteObject(hCandEBmp);
  654.       DeleteObject(hCandDBmp);
  655.       DeleteObject(hCandUBmp);
  656.       DeleteObject(hCandEBmp);
  657.       DeleteDC(hMemDC);
  658.       ReleaseDC(hCandWnd, _hDC);
  659.     end else
  660.     begin
  661.       SystemParametersInfo(SPI_GETWORKAREA, 0, @sImeG.rcWorkArea, 0);
  662.       GetCursorPos(ptCursor);
  663.       ScreenToClient(hCandWnd, ptCursor);
  665.       if PtInRect(sImeG.rcCandText, ptCursor) then
  666.       begin
  667.         SetCursor(LoadCursor(HInstance, szHandCursor));
  668.       end else
  669.         if PtInRect(sImeG.rcCandBTH, ptCursor) or
  670.            PtInRect(sImeG.rcCandBTU, ptCursor) or
  671.            PtInRect(sImeG.rcCandBTD, ptCursor) or
  672.            PtInRect(sImeG.rcCandBTE, ptCursor) then
  673.         begin
  674.           SetCursor(LoadCursor(HInstance, szHandCursor));
  675.         end else
  676.           SetCursor(LoadCursor(0, IDC_SIZEALL));
  677.     end;
  678. end;
  680.   // WM_LBUTTONUP消息处理
  681. function CandButtonUp(hCandWnd: hWnd): Bool;
  682. var
  683.   lTmpCursor, lTmpOffset: DWord;
  684.   pt: TPoint;
  685.   hUIWnd: hWnd;
  686.   _hIMC: hIMC;
  687.   lpIMC: PInputContext;
  688. begin
  689.   Result := False;
  691.   // Candidate 窗口未处于"拖拽"状态
  692.   if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) = WINDOW_NOT_DRAG) then Exit;
  694.   lTmpCursor := GetWindowLong(hCandWnd, UI_MOVE_XY);
  695.   lTmpOffset := GetWindowLong(hCandWnd, UI_MOVE_OFFSET);
  697.   // calculate the org by the offset
  698.   pt.x := PSmallPoint(@lTmpCursor).x - PSmallPoint(@lTmpOffset).x;
  699.   pt.y := PSmallPoint(@lTmpCursor).y - PSmallPoint(@lTmpOffset).y;
  701.   DrawDragBorder(hCandWnd, lTmpCursor, lTmpOffset);
  702.   SetWindowLong(hCandWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
  703.   ReleaseCapture();
  705.   hUIWnd := GetWindow(hCandWnd, GW_OWNER);
  706.   if IsWindow(hUIWnd) = False then Exit;
  708.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  709.   if (_hIMC = 0) then Exit;
  711.   lpIMC := ImmLockIMC(_hIMC);
  712.   if (lpIMC = nil) then Exit;
  714.   AdjustCandBoundry(@pt);
  715.   ScreenToClient(lpIMC.hWnd, pt);
  717.   lpIMC.cfCandForm[0].dwStyle := lpIMC.cfCandForm[0].dwStyle or CFS_CANDIDATEPOS;
  718.   lpIMC.cfCandForm[0].ptCurrentPos := pt;
  720.   ImmUnlockIMC(_hIMC);
  721.   
  722.   PostMessage(hCandWnd, WM_IME_NOTIFY, IMN_SETCANDIDATEPOS, $0001);
  723.   Result := True;
  724. end;
  726.   // 绘制Candidate窗口
  727. procedure PaintCandWindow(hCandWnd: hWnd; _hDC: hDC);
  728. label
  729.   UpCandW2UnlockIMC, UpCandW2UnlockCandInfo;
  730. var
  731.   _hIMC: hIMC;
  732.   lpIMC: PInputContext;
  733.   lpCandInfo: PCandiDateInfo;
  734.   lpCandList: PCandiDateList;
  735.   lpImcP: PPrivContext;
  736.   hOldFont: hGdiObj;
  737.   dwStart, dwEnd: DWord;
  738.   szStrBuf: array[0..2 * MAXSTRLEN + 1] of Char;
  739.   szMyStrBuf: array[0..12] of Char;
  740.   iLen, I, J, K, X, StrLen: Integer;
  741.   hCandIconBmp, hCandInfBmp: hBitmap;
  742.   hOldBmp, hCandHBmp, hCandUBmp, hCandDBmp, hCandEBmp: hBitmap;
  743.   hMemDC: hDC;
  744.   lfFont: TLogFont;
  745.   rcWnd: TRect;
  746.   wCode, wGB: Word;
  747.   AbSeq: array[0..4] of Char;
  748.   GbSeq: array[0..4] of Char;
  749.   GBARInfo: TRect;
  750.   AnsiStr: array[0..MAXCODE] of Char;
  751.   StrSize: TSize;
  752.   ArgList: array[0..1] of DWord;
  753. begin
  754.   _hIMC := GetWindowLong(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_IMC);
  755.   if (_hIMC = 0) then Exit;
  757.   lpIMC := ImmLockIMC(_hIMC);
  758.   if (lpIMC = nil) then Exit;
  760.   if (lpIMC.hCandInfo = 0) then goto UpCandW2UnlockIMC;
  761.   lpCandInfo := ImmLockIMCC(lpIMC.hCandInfo);
  762.   if (lpCandInfo = nil) then goto UpCandW2UnlockIMC;
  764.   if (lpIMC.hPrivate = 0) then goto UpCandW2UnlockCandInfo;
  765.   lpImcP := ImmLockIMCC(lpIMC.hPrivate);
  766.   if (lpImcP = nil) then goto UpCandW2UnlockCandInfo;
  768.   // set font
  769.   if (sImeG.fDiffSysCharSet) then
  770.   begin
  771.     hOldFont := GetCurrentObject(_hDC, OBJ_FONT);
  773.     ZeroMemory(@lfFont, SizeOf(TLogFont));
  774.     lfFont.lfHeight := -MulDiv(12, GetDeviceCaps(_hDC, LOGPIXELSY), 72);
  775.     lfFont.lfCharSet := NATIVE_CHARSET;
  776.     lStrCpy(lfFont.lfFaceName, '宋体');
  778.     SelectObject(_hDC, CreateFontIndirect(lfFont));
  779.   end else
  780.     hOldFont := 0;
  782.   lpCandList := PCandiDateList(DWord(lpCandInfo) + lpCandInfo.dwOffset[0]);
  783.   dwStart := lpCandList.dwSelection;
  784.   dwEnd := dwStart + lpCandList.dwPageSize;
  785.   if (dwEnd > lpCandList.dwCount) then dwEnd := lpCandList.dwCount;
  787.   // 凹陷边框
  788.   if (sImeG.IC_Trace <> 0) then
  789.   begin
  790.     GetClientRect(hCandWnd, rcWnd);
  791.     DrawConcaveRect(_hDC, rcWnd.Left, rcWnd.Top + UI_CANDINF, rcWnd.Right - 1, rcWnd.Bottom - 1);
  792.   end else
  793.   begin
  794.     GetClientRect(hCandWnd, rcWnd);
  795.     DrawConcaveRect(_hDC, sImeG.rcCandText.Left - 1, rcWnd.Top, sImeG.rcCandText.Right + 1, rcWnd.Bottom - 1);
  796.   end;
  798.   // 黑字灰底
  799.   SetTextColor(_hDC, RGB($00, $00, $00));
  800.   SetBkColor(_hDC, RGB($C0, $C0, $C0));
  802.   if (sImeG.IC_Trace <> 0) then
  803.   begin
  804.     ExtTextOut(_hDC, sImeG.rcCandText.Left, sImeG.rcCandText.Top, ETO_OPAQUE, @sImeG.rcCandText, nil, 0, nil);
  806.     szStrBuf[0] := '1'; // **
  807.     szStrBuf[1] := ':';
  809.     I := 0;
  810.     while (dwStart < dwEnd) do
  811.     begin
  812.       // I 行文字
  813.       szStrBuf[0] := szDigit[I + CAND_START];
  815.       iLen := lStrLen(PChar(DWord(lpCandList) + lpCandList.dwOffset[dwStart]));
  816.       if (iLen > 10 * 2) then
  817.       begin
  818.         iLen := 10 * 2;
  819.         CopyMemory(@szStrBuf[2], Pointer(DWord(lpCandList) + lpCandList.dwOffset[dwStart]), iLen - 2);
  820.         szStrBuf[iLen] := '.';
  821.         szStrBuf[iLen + 1] := '.';
  822.         szStrBuf[iLen + 2] := #0;
  823.       end else
  824.       begin
  825.         CopyMemory(@szStrBuf[2], Pointer(DWord(lpCandList) + lpCandList.dwOffset[dwStart]), iLen);
  826.       end;
  828.       ExtTextOut(_hDC, sImeG.rcCandText.Left,
  829.         sImeG.rcCandText.Top + I * sImeG.yChiCharHi, 0, nil, szStrBuf, iLen + 2, nil);
  831.       // QW/GB info
  832.       wCode := PUnaWord(DWord(lpCandList) + lpCandList.dwOffset[dwStart])^;
  834.       wCode := HiByte(wCode) or (LoByte(wCode) shl 8);
  835.       ArgList[0] := wCode;
  836.       wvsprintf(GbSeq, '%04lx', @ArgList);    // get GB string
  838.       Dec(wCode, $A0A0);
  839.       ArgList[0] := HiByte(wCode);
  840.       ArgList[1] := LoByte(wCode);
  841.       wvsprintf(AbSeq, '%02d%02d', @ArgList); // get QW string
  843.       ArgList[0] := DWord(@GbSeq);
  844.       ArgList[1] := DWord(@AbSeq);
  845.       wvsprintf(szMyStrBuf, '(%s,%s)', @ArgList);
  847.       GBARInfo.Top := sImeG.rcCandText.Top + I * sImeG.yChiCharHi;
  848.       GBARInfo.Left := sImeG.rcCandText.Left;
  849.       GBARInfo.Right := sImeG.rcCandText.Right;
  850.       GBARInfo.Bottom := sImeG.rcCandText.Bottom;
  851.       DrawText(_hDC, szMyStrBuf, lStrLen(szMyStrBuf), GBARInfo, DT_RIGHT or DT_SINGLELINE);
  853.       // Next ..
  854.       Inc(dwStart);
  855.       Inc(I);
  856.     end; // while (dwStart < dwEnd) do ..
  857.   end else
  858.   begin
  859.     ExtTextOut(_hDC, sImeG.rcCandText.Left, sImeG.rcCandText.Top + 1, ETO_OPAQUE, @sImeG.rcCandText, nil, 0, nil);
  861.     X := 0;
  862.     I := 0;
  863.     while (dwStart < dwEnd) do
  864.     begin
  865.       // display numbers
  866.       AnsiStr[0] := szDigit[I + CAND_START];
  867.       AnsiStr[1] := ':';
  868.       AnsiStr[2] := #0;
  869.       ExtTextOut(_hDC, sImeG.rcCandText.Left + X, sImeG.rcCandText.Top + 1,
  870.         ETO_CLIPPED, @sImeG.rcCandText, AnsiStr, lStrLen(AnsiStr), nil);
  871.       if (GetTextExtentPoint(_hDC, AnsiStr, lStrLen(AnsiStr), StrSize) = False) then
  872.         ZeroMemory(@StrSize, SizeOf(TSize)); // **
  873.       Inc(X, StrSize.cx);
  875.       // display chinese word and code
  876.       iLen := lStrLen(PChar(DWord(lpCandList) + lpCandList.dwOffset[dwStart]));
  877.       CopyMemory(@szStrBuf, PChar(DWord(lpCandList) + lpCandList.dwOffset[dwStart]), iLen);
  879.       J := 0;
  880.       while (J < iLen) do  // 定位到第一个英文字母, ??
  881.       begin
  882.         if (Ord(szStrBuf[J]) and $80) <> 0 then
  883.         begin
  884.           Inc(J, 2);
  885.           Continue;
  886.         end else
  887.           Break;
  888.       end;
  890.       K := J - 1; // **
  891.       J := 0;
  892.       while (J < iLen - K) do
  893.       begin
  894.         AnsiStr[J] := szStrBuf[J + K];
  895.         Inc(J);
  896.       end;
  897.       
  898.       AnsiStr[J] := #0;
  899.       szStrBuf[K] := #0;
  901.       ExtTextOut(_hDC, sImeG.rcCandText.Left + X, sImeG.rcCandText.Top + 1,
  902.         ETO_CLIPPED, @sImeG.rcCandText, szStrBuf, lStrLen(szStrBuf), nil);
  903.       if (GetTextExtentPoint(_hDC, szStrBuf, lStrLen(szStrBuf), StrSize) = False) then
  904.         ZeroMemory(@StrSize, SizeOf(TSize));
  905.       Inc(X, StrSize.cx);
  907.       ExtTextOut(_hDC, sImeG.rcCandText.Left + X, sImeG.rcCandText.Top + 1,
  908.         ETO_CLIPPED, @sImeG.rcCandText, AnsiStr, lStrLen(AnsiStr), nil);
  909.       if (GetTextExtentPoint(_hDC, AnsiStr, lStrLen(AnsiStr), StrSize) = False) then
  910.         ZeroMemory(@StrSize, SizeOf(TSize));
  911.       Inc(X, StrSize.cx);
  913.       // Next ..
  914.       Inc(dwStart);
  915.       Inc(I);
  916.     end; // while (dwStart < dwEnd) do ..
  917.   end; // else ..
  919.   // load all bitmap & draw
  920.   if (sImeG.IC_Trace <> 0) then
  921.     hCandInfBmp := LoadBitmap(HInstance, 'Candinf')
  922.   else
  923.     hCandInfBmp := 0;
  924.   hCandHBmp := LoadBitmap(HInstance, 'CandH');
  925.   hCandUBmp := LoadBitmap(HInstance, 'CandU');
  926.   hCandDBmp := LoadBitmap(HInstance, 'CandD');
  927.   hCandEBmp := LoadBitmap(HInstance, 'CandE');
  928.   hCandIconBmp := LoadBitmap(HInstance, 'CandSel');
  930.   hMemDC := CreateCompatibleDC(_hDC);
  932.   hOldBmp := SelectObject(hMemDC, hCandIconBmp);
  933.   BitBlt(_hDC, sImeG.rcCandIcon.Left, sImeG.rcCandIcon.Top,
  934.     sImeG.rcCandIcon.Right - sImeG.rcCandIcon.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  936.   if (hCandInfBmp <> 0) then
  937.   begin
  938.     SelectObject(hMemDC, hCandInfBmp);
  939.     BitBlt(_hDC, sImeG.rcCandInf.Left, sImeG.rcCandInf.Top,
  940.       sImeG.rcCandInf.Right - sImeG.rcCandInf.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  941.   end;
  943.   SelectObject(hMemDC, hCandHBmp);
  944.   BitBlt(_hDC, sImeG.rcCandBTH.Left, sImeG.rcCandBTH.Top,
  945.     sImeG.rcCandBTH.Right - sImeG.rcCandBTH.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  947.   SelectObject(hMemDC, hCandUBmp);
  948.   BitBlt(_hDC, sImeG.rcCandBTU.Left, sImeG.rcCandBTU.Top,
  949.     sImeG.rcCandBTU.Right - sImeG.rcCandBTU.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  951.   SelectObject(hMemDC, hCandDBmp);
  952.   BitBlt(_hDC, sImeG.rcCandBTD.Left, sImeG.rcCandBTD.Top,
  953.     sImeG.rcCandBTD.Right - sImeG.rcCandBTD.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  955.   SelectObject(hMemDC, hCandEBmp);
  956.   BitBlt(_hDC, sImeG.rcCandBTE.Left, sImeG.rcCandBTE.Top,
  957.     sImeG.rcCandBTE.Right - sImeG.rcCandBTE.Left, STATUS_DIM_Y, hMemDC, 0, 0, SRCCOPY);
  959.   SelectObject(hMemDC, hOldBmp);
  960.   DeleteDC(hMemDC);
  961.   DeleteObject(hCandIconBmp);
  962.   DeleteObject(hCandEBmp);
  963.   DeleteObject(hCandDBmp);
  964.   DeleteObject(hCandUBmp);
  965.   DeleteObject(hCandHBmp);
  966.   DeleteObject(hCandInfBmp);
  968.   if (sImeG.fDiffSysCharSet) then DeleteObject(SelectObject(_hDC, hOldFont));
  970.   ImmUnlockIMCC(lpIMC.hPrivate);
  972. UpCandW2UnlockCandInfo:
  973.   ImmUnlockIMCC(lpIMC.hCandInfo);
  975. UpCandW2UnlockIMC:
  976.   ImmUnlockIMC(_hIMC);
  977. end;
  979.   // Candidate窗口回调
  980. function CandWndProc(hCandWnd: hWnd; uMsg: uInt; wParam: WParam; lParam: LParam): LResult; stdcall;
  981. var
  982.   ptCursor: TPoint;
  983.   _hDC: hDC;
  984.   ps: TPaintStruct;
  985. begin
  986.   Result := 0;
  988.   case (uMsg) of
  989.     WM_DESTROY:
  990.       DestroyCandWindow(hCandWnd);
  992.     WM_SETCURSOR:
  993.       CandSetCursor(hCandWnd, lParam);
  995.     WM_MOUSEMOVE:
  996.       if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) <> WINDOW_NOT_DRAG) then
  997.       begin
  998.         DrawDragBorder(hCandWnd, GetWindowLong(hCandWnd, UI_MOVE_XY), GetWindowLong(hCandWnd, UI_MOVE_OFFSET)); // 擦除
  999.         GetCursorPos(ptCursor);
  1000.         SetWindowLong(hCandWnd, UI_MOVE_XY, MakeLong(ptCursor.x, ptCursor.y));
  1001.         DrawDragBorder(hCandWnd, MakeLong(ptCursor.x, ptCursor.y), GetWindowLong(hCandWnd, UI_MOVE_OFFSET));    // 重绘
  1002.       end else
  1003.         Result := DefWindowProc(hCandWnd, uMsg, wParam, lParam);
  1005.     WM_LBUTTONUP:
  1006.       if (CandButtonUp(hCandWnd) = False) then Result := DefWindowProc(hCandWnd, uMsg, wParam, lParam);
  1008.     WM_IME_NOTIFY:
  1009.       if (wParam = IMN_SETCANDIDATEPOS) then Result := SetCandPosition(hCandWnd);
  1011.     WM_PAINT:
  1012.     begin
  1013.       _hDC := BeginPaint(hCandWnd, ps);
  1014.       PaintCandWindow(hCandWnd, _hDC);
  1015.       EndPaint(hCandWnd, ps);
  1016.     end;
  1018.     WM_MOUSEACTIVATE:
  1019.       Result := MA_NOACTIVATE;
  1021.     else
  1022.       Result := DefWindowProc(hCandWnd, uMsg, wParam, lParam);
  1023.   end;
  1024. end;
  1026. end.