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

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

输入法编程

开发平台：

Delphi

Compui.pas：源码内容
  2.  {******************************************************}
  3.  {                                                      }
  4.  {    Copyright (c) 1990-1999 Microsoft Corporation     }
  5.  {                                                      }
  6.  {    Module Name:  Compui.c ->>  Compui.pas            }
  7.  {                                                      }
  8.  {    Translator:  Liu_mazi@126.com, 2005-11-17         }
  9.  {                                                      }
  10.  {******************************************************}
  12. unit Compui;
  14. {$I Define.Inc}
  16. interface
  18. uses Windows;
  20. function GetCompWnd(hUIWnd: hWnd): hWnd;  // 返回Composition窗口句柄
  21. function CompWndProc(hCompWnd: hWnd; uMsg: uInt; wParam: WParam; lParam: LParam): LResult; stdcall; // Composition窗口回调
  22. procedure ShowComp(hUIWnd: hWnd; nShowCompCmd: Integer);  // 显示隐藏Composition窗口
  23. procedure StartComp(hUIWnd: hWnd);  // 打开Composition窗口
  24. procedure EndComp(hUIWnd: hWnd);    // 隐藏Composition窗口
  25. procedure MoveDefaultCompPosition(hUIWnd: hWnd); // the default comp position need to near the caret
  27. implementation
  29. uses Messages, ImmDev, ImeDefs, Data, Ui, Uisubs, Statusui, Candui, LogText;
  31.   // 返回Composition窗口句柄
  32. function GetCompWnd(hUIWnd: hWnd): hWnd;
  33. var
  34.   hUIPrivate: HGlobal;
  35.   lpUIPrivate: PUIPriv;
  36. begin
  37.   Result := 0;
  39.   hUIPrivate := GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
  40.   if (hUIPrivate = 0) then Exit;     // can not darw candidate window
  42.   lpUIPrivate := GlobalLock(hUIPrivate);
  43.   if (lpUIPrivate = nil) then Exit;  // can not draw candidate window
  45.   Result := lpUIPrivate.hCompWnd;
  46.   GlobalUnlock(hUIPrivate);
  47. end;
  49.   // fit in lazy operation or not
  50. function FitInLazyOperation(lpptOrg, lpptNearCaret: PPoint; lprcInputRect: PRect; uEsc: uInt): Bool;
  51. var
  52.   ptDelta, ptTol: TPoint;
  53.   rcUIRect, rcInterRect: TRect;
  54. begin
  55.   Result := False;
  57.   ptDelta.x := lpptOrg.x - lpptNearCaret.x;
  58.   if (ptDelta.x < 0) then ptDelta.x := - ptDelta.x;
  60.   ptTol.x := sImeG.iParaTol * ncUIEsc[uEsc].iParaFacX + sImeG.iPerpTol * ncUIEsc[uEsc].iPerpFacX;
  61.   if (ptTol.x < 0) then ptTol.x := - ptTol.x;
  63.   if (ptDelta.x > ptTol.x) then Exit;
  65.   ptDelta.y := lpptOrg.y - lpptNearCaret.y;
  66.   if (ptDelta.y < 0) then ptDelta.y := - ptDelta.y;
  68.   ptTol.y := sImeG.iParaTol * ncUIEsc[uEsc].iParaFacY + sImeG.iPerpTol * ncUIEsc[uEsc].iPerpFacY;
  69.   if (ptTol.y < 0) then ptTol.y := - ptTol.y;
  71.   if (ptDelta.y > ptTol.y) then Exit;
  73.   // build up the UI rectangle (composition window)
  74.   rcUIRect.Left := lpptOrg.x;
  75.   rcUIRect.Top := lpptOrg.y;
  76.   rcUIRect.Right := rcUIRect.Left + sImeL.xCompWi;
  77.   rcUIRect.Bottom := rcUIRect.Top + sImeL.yCompHi;
  79.   if IntersectRect(rcInterRect, rcUIRect, lprcInputRect^) then Exit;
  81.   Result := True;
  82. end;
  84.   // decide a near caret position according to the caret position
  85. procedure GetNearCaretPosition(lpptFont: PPoint; uEsc, uRot: uInt; lpptCaret, lpptNearCaret: PPoint; fFlags: DWord);
  86. var
  87.   lFontSize, xWidthUI, yHeightUI, xBorder, yBorder: Integer;
  88. begin
  89.   if ((uEsc + uRot) and $0001) <> 0 then lFontSize := lpptFont.x else lFontSize := lpptFont.y;
  91.   xWidthUI  := sImeL.xCompWi;
  92.   yHeightUI := sImeL.yCompHi;
  93.   xBorder   := sImeL.cxCompBorder;
  94.   yBorder   := sImeL.cyCompBorder;
  96.   if (fFlags and NEAR_CARET_FIRST_TIME) <> 0 then
  97.   begin
  98.     lpptNearCaret.x := lpptCaret.x +
  99.       lFontSize * ncUIEsc[uEsc].iLogFontFacX +
  100.       sImeG.iPara * ncUIEsc[uEsc].iParaFacX +
  101.       sImeG.iPerp * ncUIEsc[uEsc].iPerpFacX;
  103.     if (ptInputEsc[uEsc].x >= 0) then
  104.       Inc(lpptNearCaret.x, xBorder * 2)
  105.     else
  106.       Dec(lpptNearCaret.x, xWidthUI - xBorder * 2);
  108.     lpptNearCaret.y := lpptCaret.y +
  109.       lFontSize * ncUIEsc[uEsc].iLogFontFacY +
  110.       sImeG.iPara * ncUIEsc[uEsc].iParaFacY +
  111.       sImeG.iPerp * ncUIEsc[uEsc].iPerpFacY;
  113.     if (ptInputEsc[uEsc].y >= 0) then
  114.       Inc(lpptNearCaret.y, yBorder * 2)
  115.     else
  116.       Dec(lpptNearCaret.y, yHeightUI - yBorder * 2);
  117.   end else
  118.   begin
  119.     lpptNearCaret.x := lpptCaret.x +
  120.       lFontSize * ncAltUIEsc[uEsc].iLogFontFacX +
  121.       sImeG.iPara * ncAltUIEsc[uEsc].iParaFacX +
  122.       sImeG.iPerp * ncAltUIEsc[uEsc].iPerpFacX;
  124.     if (ptAltInputEsc[uEsc].x >= 0) then
  125.       Inc(lpptNearCaret.x, xBorder * 2)
  126.     else
  127.       Dec(lpptNearCaret.x, xWidthUI - xBorder * 2);
  129.     lpptNearCaret.y := lpptCaret.y +
  130.       lFontSize * ncAltUIEsc[uEsc].iLogFontFacY +
  131.       sImeG.iPara * ncAltUIEsc[uEsc].iParaFacY +
  132.       sImeG.iPerp * ncAltUIEsc[uEsc].iPerpFacY;
  134.     if (ptAltInputEsc[uEsc].y >= 0) then
  135.       Inc(lpptNearCaret.y, yBorder * 2)
  136.     else
  137.       Dec(lpptNearCaret.y, yHeightUI - yBorder * 2);
  138.   end;
  140.   if (lpptNearCaret.x < sImeG.rcWorkArea.Left) then
  141.   begin
  142.     lpptNearCaret.x := sImeG.rcWorkArea.Left;
  143.   end else
  144.     if (lpptNearCaret.x + xWidthUI > sImeG.rcWorkArea.Right) then
  145.     begin
  146.       lpptNearCaret.x := sImeG.rcWorkArea.Right - xWidthUI;
  147.     end;
  149.   if (lpptNearCaret.y < sImeG.rcWorkArea.Top) then
  150.   begin
  151.     lpptNearCaret.y := sImeG.rcWorkArea.Top
  152.   end else
  153.     if (lpptNearCaret.y + yHeightUI > sImeG.rcWorkArea.Bottom) then
  154.     begin
  155.       lpptNearCaret.y := sImeG.rcWorkArea.Bottom - yHeightUI;
  156.     end;
  157. end;
  159.  // IME adjust position according to composition form
  160. function AdjustCompPosition(lpIMC: PInputContext; lpptOrg: PPoint; lpptNew: PPoint): Bool;
  161. var
  162.   ptNearCaret, ptOldNearCaret, ptFont: TPoint;
  163.   uEsc, uRot, uTmp: uInt;
  164.   rcUIRect, rcInputRect, rcInterRect: TRect;
  165. begin
  166.   Result := False;
  167.   if (lpIMC = nil) then Exit;
  169.   // we need to adjust according to font attribute
  170.   if (lpIMC.lfFont.A.lfWidth > 0) then
  171.     ptFont.x := lpIMC.lfFont.A.lfWidth * 2
  172.   else
  173.     if (lpIMC.lfFont.A.lfWidth < 0) then
  174.       ptFont.x := - lpIMC.lfFont.A.lfWidth * 2
  175.     else
  176.       if (lpIMC.lfFont.A.lfHeight > 0) then
  177.         ptFont.x := lpIMC.lfFont.A.lfHeight
  178.       else
  179.         if (lpIMC.lfFont.A.lfHeight < 0) then
  180.           ptFont.x := - lpIMC.lfFont.A.lfHeight
  181.         else
  182.           ptFont.x := sImeL.yCompHi;
  184.   if (lpIMC.lfFont.A.lfHeight > 0) then
  185.     ptFont.y := lpIMC.lfFont.A.lfHeight
  186.   else
  187.     if (lpIMC.lfFont.A.lfHeight < 0) then
  188.       ptFont.y := -lpIMC.lfFont.A.lfHeight
  189.     else
  190.       ptFont.y := ptFont.x;
  192.   // if the input char is too big, we don't need to consider so much
  193.   if (ptFont.x > sImeL.yCompHi * 8) then ptFont.x := sImeL.yCompHi * 8;
  194.   if (ptFont.y > sImeL.yCompHi * 8) then ptFont.y := sImeL.yCompHi * 8;
  195.   if (ptFont.x < sImeG.xChiCharWi) then ptFont.x := sImeG.xChiCharWi;
  196.   if (ptFont.y < sImeG.yChiCharHi) then ptFont.y := sImeG.yChiCharHi;
  198.   // -450 to 450 index 0
  199.   // 450 to 1350 index 1
  200.   // 1350 to 2250 index 2
  201.   // 2250 to 3150 index 3
  202.   uEsc := (lpIMC.lfFont.A.lfEscapement + 450) div 900 mod 4;
  203.   uRot := (lpIMC.lfFont.A.lfOrientation + 450) div 900 mod 4;
  205.   // decide the input rectangle
  206.   rcInputRect.Left := lpptNew.x;
  207.   rcInputRect.Top := lpptNew.y;
  209.   // build up an input rectangle from escapemment
  210.   rcInputRect.Right := rcInputRect.Left + ptFont.x * ptInputEsc[uEsc].x;
  211.   rcInputRect.Bottom := rcInputRect.Top + ptFont.y * ptInputEsc[uEsc].y;
  213.   // be a normal rectangle, not a negative rectangle
  214.   if (rcInputRect.Left > rcInputRect.Right) then
  215.   begin
  216.     uTmp := rcInputRect.Left;
  217.     rcInputRect.Left := rcInputRect.Right;
  218.     rcInputRect.Right := uTmp;
  219.   end;
  221.   if (rcInputRect.Top > rcInputRect.Bottom) then
  222.   begin
  223.     uTmp := rcInputRect.Top;
  224.     rcInputRect.Top := rcInputRect.Bottom;
  225.     rcInputRect.Bottom := uTmp;
  226.   end;
  228.   GetNearCaretPosition(@ptFont, uEsc, uRot, lpptNew, @ptNearCaret, NEAR_CARET_FIRST_TIME);
  230.   // 1st, use the adjust point build up the new suggest UI rectangle (composition window)
  231.   rcUIRect.Left := ptNearCaret.x;
  232.   rcUIRect.Top := ptNearCaret.y;
  233.   rcUIRect.Right := rcUIRect.Left + sImeL.xCompWi;
  234.   rcUIRect.Bottom := rcUIRect.Top + sImeL.yCompHi;
  236.   ptOldNearCaret := ptNearCaret;
  238.   // OK, no intersect between the near caret position and input char
  239.   if IntersectRect(rcInterRect, rcUIRect, rcInputRect) then
  240.   begin
  241.   end else
  242.     if FitInLazyOperation(lpptOrg, @ptNearCaret, @rcInputRect, uEsc) then
  243.     begin
  244.       Result := False;  // happy ending!!!, don't change position
  245.       Exit;
  246.     end else
  247.     begin
  248.       lpptOrg^ := ptNearCaret;
  249.       Result := True;  // happy ending!!
  250.       Exit;
  251.     end;
  253.   // unhappy case
  254.   GetNearCaretPosition(@ptFont, uEsc, uRot, lpptNew, @ptNearCaret, 0);
  256.   // build up the new suggest UI rectangle (composition window)
  257.   rcUIRect.Left := ptNearCaret.x;
  258.   rcUIRect.Top := ptNearCaret.y;
  259.   rcUIRect.Right := rcUIRect.Left + sImeL.xCompWi;
  260.   rcUIRect.Bottom := rcUIRect.Top + sImeL.yCompHi;
  262.   // OK, no intersect between the adjust position and input char
  263.   if IntersectRect(rcInterRect, rcUIRect, rcInputRect) then
  264.   begin
  265.   end else
  266.     if FitInLazyOperation(lpptOrg, @ptNearCaret, @rcInputRect, uEsc) then
  267.     begin
  268.       Result := False;
  269.       Exit;
  270.     end else
  271.     begin
  272.       lpptOrg^ := ptNearCaret;
  273.       Result := True;
  274.       Exit;
  275.     end;
  277.   lpptOrg^ := ptOldNearCaret;
  278.   Result := True;
  279. end;
  281.   // 设置Composition窗口位置
  282. procedure SetCompPosition(hCompWnd: hWnd; _hIMC: hIMC; lpIMC: PInputContext);
  283. var
  284.   ptWnd, ptSTWPos, ptNew: TPoint;
  285.   hCandWnd: hWnd;
  286.   fChange: Bool; // = FALSE
  287.   Comp_CandWndLen: Integer;
  288. begin
  289.   fChange := False;
  291.   // Composition窗口当前位置
  292.   ptWnd.x := 0;
  293.   ptWnd.y := 0;
  294.   ClientToScreen(hCompWnd, ptWnd);
  295.   Dec(ptWnd.x, sImeL.cxCompBorder);
  296.   Dec(ptWnd.y, sImeL.cyCompBorder);
  298.   // 光标跟随 = False
  299.   if (sImeG.IC_Trace = 0) then
  300.   begin
  301.     ImmGetStatusWindowPos(_hIMC, @ptSTWPos);
  303.     // reset status window for LINE_UI(FIX_UI)
  304.     if (uStartComp <> 0) then
  305.     begin
  306.       Comp_CandWndLen := 0;
  307.       Inc(Comp_CandWndLen, sImeL.xCompWi + UI_MARGIN);
  308.       if (uOpenCand <> 0) then Inc(Comp_CandWndLen, sImeG.xCandWi + UI_MARGIN);
  310.       if (ptSTWPos.x + sImeG.xStatusWi + Comp_CandWndLen > sImeG.rcWorkArea.Right) then
  311.         ptSTWPos.x := sImeG.rcWorkArea.Right - sImeG.xStatusWi - Comp_CandWndLen;
  313.       SetWindowPos(GetStatusWnd(GetWindow(hCompWnd, GW_OWNER)), 0, ptSTWPos.x,
  314.         ptSTWPos.y, 0, 0, SWP_NOACTIVATE or SWP_NOCOPYBITS or SWP_NOSIZE or SWP_NOZORDER);
  315.       ImmSetStatusWindowPos(_hIMC, PPoint(@ptSTWPos));
  316.     end;
  318.     ptWnd.x := ptSTWPos.x + sImeG.xStatusWi + UI_MARGIN;
  319.     ptWnd.y := ptSTWPos.y;
  320.     lpIMC.cfCompForm.ptCurrentPos := ptWnd;
  321.     ScreenToClient(lpIMC.hWnd, lpIMC.cfCompForm.ptCurrentPos);
  323.     fChange := True;
  324.   end else
  325.     if ((lpIMC.cfCompForm.dwStyle and CFS_FORCE_POSITION) <> 0) then
  326.     begin
  327.       ptNew.x := lpIMC.cfCompForm.ptCurrentPos.x;
  328.       ptNew.y := lpIMC.cfCompForm.ptCurrentPos.y;
  329.       ClientToScreen(lpIMC.hWnd, ptNew);
  331.       if (ptWnd.x <> ptNew.x) then
  332.       begin
  333.         ptWnd.x := ptNew.x;
  334.         fChange := True;
  335.       end;
  337.       if (ptWnd.y <> ptNew.y) then
  338.       begin
  339.         ptWnd.y := ptNew.y;
  340.         fChange := True;
  341.       end;
  343.       if (fChange) then
  344.       begin
  345.         Dec(ptWnd.x, sImeL.cxCompBorder);
  346.         Dec(ptWnd.y, sImeL.cyCompBorder);
  347.       end;
  348.     end else
  349.       if (lpIMC.cfCompForm.dwStyle <> CFS_DEFAULT) then
  350.       begin
  351.         ptNew.x := lpIMC.cfCompForm.ptCurrentPos.x;
  352.         ptNew.y := lpIMC.cfCompForm.ptCurrentPos.y;
  353.         ClientToScreen(lpIMC.hWnd, ptNew);
  355.         fChange := AdjustCompPosition(lpIMC, @ptWnd, @ptNew);
  356.       end else
  357.       begin
  358.         ImmGetStatusWindowPos(_hIMC, @ptSTWPos);
  359.         
  360.         ptNew.x := ptSTWPos.x + sImeG.xStatusWi + UI_MARGIN;
  361.         if (ptNew.x + sImeL.xCompWi + UI_MARGIN + sImeG.xCandWi >= sImeG.rcWorkArea.Right) then
  362.         begin
  363.           ptNew.x := ptSTWPos.x - sImeL.xCompWi - UI_MARGIN;
  364.         end;
  366.         ptNew.y := ptSTWPos.y;
  368.         if (ptWnd.x <> ptNew.x) then
  369.         begin
  370.           ptWnd.x := ptNew.x;
  371.           fChange := True;
  372.         end;
  374.         if (ptWnd.y <> ptNew.y) then
  375.         begin
  376.           ptWnd.y := ptNew.y;
  377.           fChange := True;
  378.         end;
  380.         if (fChange) then
  381.         begin
  382.           lpIMC.cfCompForm.ptCurrentPos := ptNew;
  383.           ScreenToClient(lpIMC.hWnd, lpIMC.cfCompForm.ptCurrentPos);
  384.         end;
  385.       end;
  387.   if (fChange = False) then Exit; // 没有变化
  388.   SetWindowPos(hCompWnd, 0, ptWnd.x, ptWnd.y, 0, 0, SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER);
  390.   // 调整Candidate窗口位置 ..
  392.   hCandWnd := GetCandWnd(GetWindow(hCompWnd, GW_OWNER));
  393.   if IsWindow(hCandWnd) then Exit;
  395.   CalcCandPos(_hIMC, GetWindow(hCompWnd, GW_OWNER), @ptWnd);
  396.   ScreenToClient(lpIMC.hWnd, ptWnd);
  398.   lpIMC.cfCandForm[0].dwStyle := CFS_CANDIDATEPOS;
  399.   lpIMC.cfCandForm[0].ptCurrentPos := ptWnd;
  401.   if (IsWindowVisible(hCandWnd) = False) then Exit;
  402.   PostMessage(hCandWnd, WM_IME_NOTIFY, IMN_SETCANDIDATEPOS, 1);
  403. end;
  405.   // IMN_SETCOMPOSITIONWINDOW处理
  406. procedure SetCompWindow(hCompWnd: hWnd);
  407. var
  408.   _hIMC: hIMC;
  409.   lpIMC: PInputContext;
  410.   hUIWnd: hWnd;
  411. begin
  412.   hUIWnd := GetWindow(hCompWnd, GW_OWNER);
  413.   if (IsWindow(hUIWnd) = False) then Exit;
  415.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  416.   if (_hIMC = 0) then Exit;
  418.   lpIMC := ImmLockIMC(_hIMC);
  419.   if (lpIMC = nil) then Exit;
  421.   SetCompPosition(hCompWnd, _hIMC, lpIMC);
  422.   ImmUnlockIMC(_hIMC);
  423. end;
  425.   // the default comp position need to near the caret
  426. procedure MoveDefaultCompPosition(hUIWnd: hWnd);
  427. var
  428.   _hIMC: hIMC;
  429.   lpIMC: PInputContext;
  430.   hCompWnd: hWnd;
  431. begin
  432.   hCompWnd := GetCompWnd(hUIWnd);
  433.   if (IsWindow(hCompWnd) = False) then Exit;
  435.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  436.   if (_hIMC = 0) then Exit;
  438.   lpIMC := ImmLockIMC(_hIMC);
  439.   if (lpIMC = nil) then Exit;
  441.   if ((lpIMC.cfCompForm.dwStyle and CFS_FORCE_POSITION) = 0) then
  442.   begin
  443.     SetCompPosition(hCompWnd, _hIMC, lpIMC);
  444.   end;
  446.   ImmUnlockIMC(_hIMC);
  447. end;
  449.   // 显示隐藏Composition窗口
  450. procedure ShowComp(hUIWnd: hWnd; nShowCompCmd: Integer);
  451. var
  452.   hUIPrivate: HGlobal;
  453.   lpUIPrivate: PUIPriv;
  454. begin
  455.   hUIPrivate := GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
  456.   if (hUIPrivate = 0) then Exit;
  458.   lpUIPrivate := GlobalLock(hUIPrivate);
  459.   if (lpUIPrivate = nil) then Exit;
  461.   if (lpUIPrivate.nShowCompCmd = nShowCompCmd) then Exit; // **
  463.   if (nShowCompCmd = SW_HIDE) then
  464.     lpUIPrivate.fdwSetContext := lpUIPrivate.fdwSetContext and (not ISC_HIDE_COMP_WINDOW);
  466.   if IsWindow(lpUIPrivate.hCompWnd) then
  467.   begin
  468.     if (nShowCompCmd = SW_HIDE) then uStartComp := 0 else uStartComp := 1;
  469.     ShowWindow(lpUIPrivate.hCompWnd, nShowCompCmd);
  470.     lpUIPrivate.nShowCompCmd := nShowCompCmd;
  471.   end;
  473.   GlobalUnlock(hUIPrivate);
  474. end;
  476.   // "打开"Composition窗口
  477. procedure StartComp(hUIWnd: hWnd);
  478. var
  479.   _hIMC: hIMC;
  480.   hUIPrivate: HGlobal;
  481.   lpIMC: PInputContext;
  482.   lpUIPrivate: PUIPriv;
  483. begin
  484.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  485.   if (_hIMC = 0) then Exit;
  487.   hUIPrivate := GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
  488.   if (hUIPrivate = 0) then Exit;
  490.   lpIMC := ImmLockIMC(_hIMC);
  491.   if (lpIMC = nil) then Exit;
  493.   lpUIPrivate := GlobalLock(hUIPrivate);
  494.   if (lpUIPrivate = nil) then // can not draw composition window
  495.   begin
  496.     ImmUnlockIMC(_hIMC);
  497.     Exit;
  498.   end;
  500.   lpUIPrivate.fdwSetContext := lpUIPrivate.fdwSetContext or ISC_SHOWUICOMPOSITIONWINDOW;
  502.   if (IsWindow(lpUIPrivate.hCompWnd) = False) then // 窗口不存在则建立
  503.   begin
  504.     lpUIPrivate.hCompWnd := CreateWindowEx(WS_EX_WINDOWEDGE or WS_EX_DLGMODALFRAME, szCompClassName,
  505.       nil, WS_POPUP or WS_DISABLED, 0, 0, sImeL.xCompWi, sImeL.yCompHi, hUIWnd, 0, HInstance, nil);
  507.     SetWindowLong(lpUIPrivate.hCompWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
  508.     SetWindowLong(lpUIPrivate.hCompWnd, UI_MOVE_XY, sImeL.nMaxKey);
  509.   end;
  511.   uStartComp := 1;
  513.   // try to set the position of composition UI window near the caret
  514.   SetCompPosition(lpUIPrivate.hCompWnd, _hIMC, lpIMC);
  515.   ImmUnlockIMC(_hIMC);
  517.   ShowComp(hUIWnd, SW_SHOWNOACTIVATE);
  518.   GlobalUnlock(hUIPrivate);
  519. end;
  521.   // "关闭"Composition窗口
  522. procedure EndComp(hUIWnd: hWnd);
  523. begin
  524.   ShowComp(hUIWnd, SW_HIDE);
  525. end;
  527.   // WM_DESTROY消息处理
  528. procedure DestroyCompWindow(hCompWnd: hWnd);
  529. var
  530.   hUIPrivate: HGlobal;
  531.   lpUIPrivate: PUIPriv;
  532. begin
  533.   if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) <> WINDOW_NOT_DRAG) then // undo the drag border
  534.     DrawDragBorder(hCompWnd, GetWindowLong(hCompWnd, UI_MOVE_XY), GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
  536.   hUIPrivate := GetWindowLong(GetWindow(hCompWnd, GW_OWNER), IMMGWLP_PRIVATE);
  537.   if (hUIPrivate = 0) then Exit;
  539.   lpUIPrivate := GlobalLock(hUIPrivate);
  540.   if (lpUIPrivate = nil) then Exit;
  542.   lpUIPrivate.nShowCompCmd := SW_HIDE;
  543.   lpUIPrivate.hCompWnd := 0;
  545.   GlobalUnlock(hUIPrivate);
  546. end;
  548.   // WM_SETCURSOR消息处理
  549. procedure CompSetCursor(hCompWnd: hWnd; lParam: LParam);
  550. var
  551.   ptCursor: TPoint;
  552.   rcWnd: TRect;
  553. begin
  554.   SetCursor(LoadCursor(0, IDC_SIZEALL));
  556.   if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) <> WINDOW_NOT_DRAG) then Exit;
  557.   if (HiWord(lParam) <> WM_LBUTTONDOWN) then Exit;
  559.   // start dragging ..
  561.   SystemParametersInfo(SPI_GETWORKAREA, 0, @sImeG.rcWorkArea, 0);
  563.   SetCapture(hCompWnd);
  565.   GetCursorPos(ptCursor);
  566.   SetWindowLong(hCompWnd, UI_MOVE_XY, MakeLong(ptCursor.x, ptCursor.y));
  568.   GetWindowRect(hCompWnd, rcWnd);
  569.   SetWindowLong(hCompWnd, UI_MOVE_OFFSET, MakeLong(ptCursor.x - rcWnd.Left, ptCursor.y - rcWnd.Top));
  571.   DrawDragBorder(hCompWnd, MakeLong(ptCursor.x, ptCursor.y), GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
  572. end;
  574.   // WM_LBUTTONUP消息处理
  575. function CompButtonUp(hCompWnd: hWnd): Bool;
  576. var
  577.   lTmpCursor, lTmpOffset: DWord;
  578.   pt: TPoint;
  579.   hUIWnd: hWnd;
  580.   _hIMC: hIMC;
  581.   lpIMC: PInputContext;
  582. begin
  583.   Result := False;
  585.   if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) = WINDOW_NOT_DRAG) then Exit; // 非拖拽状态
  587.   lTmpCursor := GetWindowLong(hCompWnd, UI_MOVE_XY);
  588.   lTmpOffset := GetWindowLong(hCompWnd, UI_MOVE_OFFSET);
  590.   // calculate the org by the offset
  591.   pt.x := PSmallPoint(@lTmpCursor).x - PSmallPoint(@lTmpOffset).x;
  592.   pt.y := PSmallPoint(@lTmpCursor).y - PSmallPoint(@lTmpOffset).y;
  594.   DrawDragBorder(hCompWnd, lTmpCursor, lTmpOffset);
  595.   SetWindowLong(hCompWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
  596.   SetWindowLong(hCompWnd, UI_MOVE_XY, sImeL.nMaxKey);
  597.   ReleaseCapture();
  599.   hUIWnd := GetWindow(hCompWnd, GW_OWNER);
  600.   if (IsWindow(hUIWnd) = False) then Exit;
  602.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  603.   if (_hIMC = 0) then Exit;
  605.   lpIMC := ImmLockIMC(_hIMC);
  606.   if (lpIMC = nil) then Exit;
  608.   if (pt.x < sImeG.rcWorkArea.Left) then
  609.   begin
  610.     pt.x := sImeG.rcWorkArea.Left;
  611.   end else
  612.     if (pt.x + sImeL.xCompWi > sImeG.rcWorkArea.Right) then
  613.     begin
  614.       pt.x := sImeG.rcWorkArea.Right - sImeL.xCompWi;
  615.     end;
  617.   if (pt.y < sImeG.rcWorkArea.Top) then
  618.   begin
  619.     pt.y := sImeG.rcWorkArea.Top;
  620.   end else
  621.     if (pt.y + sImeL.yCompHi > sImeG.rcWorkArea.Bottom) then
  622.     begin
  623.       pt.y := sImeG.rcWorkArea.Bottom - sImeL.yCompHi;
  624.     end;
  626.   lpIMC.cfCompForm.dwStyle := CFS_FORCE_POSITION;
  627.   lpIMC.cfCompForm.ptCurrentPos.x := pt.x + sImeL.cxCompBorder;
  628.   lpIMC.cfCompForm.ptCurrentPos.y := pt.y + sImeL.cyCompBorder;
  630.   ScreenToClient(lpIMC.hWnd, lpIMC.cfCompForm.ptCurrentPos);
  631.   ImmUnlockIMC(_hIMC);
  633.   // set composition window to the new poosition
  634.   PostMessage(hCompWnd, WM_IME_NOTIFY, IMN_SETCOMPOSITIONWINDOW, 0);
  635.   
  636.   Result := True;
  637. end;
  639.   // 绘制Composition窗口
  640. procedure PaintCompWindow(hUIWnd: hWnd; hCompWnd: hWnd; _hDC: hDC);
  641. var
  642.   _hIMC: hIMC;
  643.   lpIMC: PInputContext;
  644.   hOldFont: HGdiObj;
  645.   lpCompStr: PCompositionString;
  646.   lpGuideLine: PGuideLine;
  647.   fShowString: DWord;
  648.   lfFont: TLogFont;
  649.   rcWnd: TRect;
  650. begin
  651.   _hIMC := GetWindowLong(hUIWnd, IMMGWLP_IMC);
  652.   if (_hIMC = 0) then Exit;
  654.   lpIMC := ImmLockIMC(_hIMC);
  655.   if (lpIMC = nil) then Exit;
  657.   if (sImeG.fDiffSysCharSet) then
  658.   begin
  659.     hOldFont := GetCurrentObject(_hDC, OBJ_FONT);
  661.     ZeroMemory(@lfFont, SizeOf(lfFont));
  662.     lfFont.lfHeight := - MulDiv(12, GetDeviceCaps(_hDC, LOGPIXELSY), 72);
  663.     lfFont.lfCharSet := NATIVE_CHARSET;
  664.     lStrCpy(lfFont.lfFaceName, '宋体');
  666.     SelectObject(_hDC, CreateFontIndirect(lfFont));
  667.   end else
  668.     hOldFont := 0;
  670.   lpCompStr := ImmLockIMCC(lpIMC.hCompStr);
  671.   if (lpCompStr = nil) then Exit;
  673.   lpGuideLine := ImmLockIMCC(lpIMC.hGuideLine);
  674.   if (lpGuideLine = nil) then Exit;
  676.   // 凹陷边框
  677.   GetClientRect(hCompWnd, rcWnd);
  678.   DrawConcaveRect(_hDC, rcWnd.Left, rcWnd.Top, rcWnd.Right - 1, rcWnd.Bottom - 1);
  680.   SetBkColor(_hDC, RGB($C0, $C0, $C0));
  682.   fShowString := 0;
  684.   if (lpGuideLine = nil) then
  685.   begin
  686.   end else
  687.     if (lpGuideLine.dwLevel = GL_LEVEL_NOGUIDELINE) then
  688.     begin
  689.     end else
  690.       if (lpGuideLine.dwStrLen = 0) then
  691.       begin
  692.         if (lpGuideLine.dwLevel = GL_LEVEL_ERROR) then
  693.         begin
  694.           fShowString := fShowString or IME_STR_ERROR;
  695.         end;
  696.       end else
  697.       begin
  698.         // if there is information string, we will show the information string
  699.         if (lpGuideLine.dwLevel = GL_LEVEL_ERROR) then
  700.         begin
  701.           SetTextColor(_hDC, RGB($FF, 0, 0));    // red text for error
  702.           SetBkColor(_hDC, RGB($80, $80, $80));  // light gray background for error
  703.         end;
  705.         ExtTextOut(_hDC, sImeL.rcCompText.Left, sImeL.rcCompText.Top, ETO_OPAQUE, @sImeL.rcCompText,
  706.           PChar(DWord(lpGuideLine) + lpGuideLine.dwStrOffset), lpGuideLine.dwStrLen, nil);
  707.           
  708.         fShowString := fShowString or IME_STR_SHOWED; // 已显示
  709.       end;
  711.   if (fShowString and IME_STR_SHOWED) <> 0 then
  712.   begin
  713.     // already show it, don't need to show
  714.   end else
  715.     if (lpCompStr.dwCompStrLen > 0) then
  716.     begin
  717.       ExtTextOut(_hDC, sImeL.rcCompText.Left, sImeL.rcCompText.Top, ETO_OPAQUE, @sImeL.rcCompText, nil, 0, nil);
  719.       DrawText(_hDC, PChar(DWord(lpCompStr) + lpCompStr.dwCompStrOffset),
  720.         lpCompStr.dwCompStrLen, sImeL.rcCompText, DT_LEFT or DT_VCENTER or DT_SINGLELINE);
  722.       if (fShowString and IME_STR_ERROR) <> 0 then
  723.       begin
  724.         // red text for error
  725.         SetTextColor(_hDC, RGB($FF, 0, 0));
  727.         // light gray background for error
  728.         SetBkColor(_hDC, RGB($80, $80, $80));
  730.         ExtTextOut(_hDC, sImeL.rcCompText.Left + Integer(lpCompStr.dwCursorPos) * sImeG.xChiCharWi div 2,
  731.           sImeL.rcCompText.Top, ETO_CLIPPED, @sImeL.rcCompText,
  732.           PChar(DWord(lpCompStr) + lpCompStr.dwCompStrOffset + lpCompStr.dwCursorPos),
  733.           lpCompStr.dwCompStrLen - lpCompStr.dwCursorPos, nil);
  734.       end else
  735.         if (lpCompStr.dwCursorPos < lpCompStr.dwCompStrLen) then
  736.         begin
  737.           // light gray background for cursor start
  738.           SetBkColor(_hDC, RGB($80, $80, $80));
  740.           ExtTextOut(_hDC, sImeL.rcCompText.Left + Integer(lpCompStr.dwCursorPos) * sImeG.xChiCharWi div 2,
  741.             sImeL.rcCompText.Top, ETO_CLIPPED, @sImeL.rcCompText,
  742.             PChar(DWord(lpCompStr) + lpCompStr.dwCompStrOffset + lpCompStr.dwCursorPos),
  743.             lpCompStr.dwCompStrLen - lpCompStr.dwCursorPos, nil);
  744.         end else
  745.         begin
  746.         end;
  747.     end else
  748.     begin
  749.       ExtTextOut(_hDC, sImeL.rcCompText.Left, sImeL.rcCompText.Top, ETO_OPAQUE, @sImeL.rcCompText, nil, 0, nil);
  750.     end;
  752.   if (sImeG.fDiffSysCharSet) then DeleteObject(SelectObject(_hDC, hOldFont));
  754.   ImmUnlockIMCC(lpIMC.hGuideLine);
  755.   ImmUnlockIMCC(lpIMC.hCompStr);
  756.   ImmUnlockIMC(_hIMC);
  757. end;
  759.   // Composition窗口回调
  760. function CompWndProc(hCompWnd: hWnd; uMsg: uInt; wParam: WParam; lParam: LParam): LResult; stdcall;
  761. var
  762.   ptCursor: TPoint;
  763.   _hDC: hDC;
  764.   ps: TPaintStruct;
  765. begin
  766.   Result := 0;
  768.   case (uMsg) of
  769.     WM_DESTROY:
  770.       DestroyCompWindow(hCompWnd);
  772.     WM_SETCURSOR:
  773.       CompSetCursor(hCompWnd, lParam);
  775.     WM_MOUSEMOVE:
  776.       if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) <> WINDOW_NOT_DRAG) then // 拖拽中
  777.       begin
  778.         DrawDragBorder(hCompWnd, GetWindowLong(hCompWnd, UI_MOVE_XY), GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
  779.         GetCursorPos(ptCursor);
  780.         SetWindowLong(hCompWnd, UI_MOVE_XY, MakeLong(ptCursor.x, ptCursor.y));
  781.         DrawDragBorder(hCompWnd, MakeLong(ptCursor.x, ptCursor.y), GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
  782.       end else
  783.         Result := DefWindowProc(hCompWnd, uMsg, wParam, lParam);
  785.     WM_LBUTTONUP:
  786.       if (CompButtonUp(hCompWnd) = False) then Result := DefWindowProc(hCompWnd, uMsg, wParam, lParam);
  788.     WM_IME_NOTIFY:
  789.       if (wParam = IMN_SETCOMPOSITIONWINDOW) then SetCompWindow(hCompWnd);
  791.     WM_PAINT:
  792.     begin
  793.       _hDC := BeginPaint(hCompWnd, ps);
  794.       PaintCompWindow(GetWindow(hCompWnd, GW_OWNER), hCompWnd, _hDC);
  795.       EndPaint(hCompWnd, ps);
  796.     end;
  798.     WM_MOUSEACTIVATE:
  799.       Result := MA_NOACTIVATE;
  801.     else
  802.       Result := DefWindowProc(hCompWnd, uMsg, wParam, lParam);
  803.   end;
  804. end;
  806. end.