compui.cpp

输入法源代码自由拼音输入法源代码（T9）

/*++

Copyright (c) 1990-1999 Microsoft Corporation, All Rights Reserved

Module Name:

    compui.c

++*/


#include <windows.h>
#include <imm.h>
#include "imedefs.h"

extern char	CurrentPy[PY_EDITER_PY_ITEMS][8];

void ComNextPingyinPage(  HWND   ,BOOL);
/**********************************************************************/
/* GetCompWnd                                                         */
/* Return Value :                                                     */
/*      window handle of composition                                  */
/**********************************************************************/
HWND PASCAL GetCompWnd(
    HWND hUIWnd)                // UI window
{
    HGLOBAL  hUIPrivate;
    LPUIPRIV lpUIPrivate;
    HWND     hCompWnd;

    hUIPrivate = (HGLOBAL)GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
    if (!hUIPrivate) {          // can not darw candidate window
        return (HWND)NULL;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {         // can not draw candidate window
        return (HWND)NULL;
    }
    hCompWnd = lpUIPrivate->hCompWnd;
    GlobalUnlock(hUIPrivate);
    return (hCompWnd);
}
/**********************************************************************/
/* SetCompPosition()                                                  */
/**********************************************************************/
void PASCAL SetCompPosition(    // set the composition window position
    HWND           hCompWnd,
    HIMC           hIMC,
    LPINPUTCONTEXT lpIMC)
{
    POINT ptWnd;
    POINT ptSTWPos;
    HWND  hCandWnd;
    RECT  rcWorkArea;

    rcWorkArea = sImeG.rcWorkArea;
    // the client coordinate position (0, 0) of composition window
    ptWnd.x = 0;
    ptWnd.y = 0;
    // convert to screen coordinates
    ClientToScreen(hCompWnd, &ptWnd);
    ptWnd.x -= lpImeL->cxCompBorder;
    ptWnd.y -= lpImeL->cyCompBorder;
    ImmGetStatusWindowPos(hIMC, (LPPOINT)&ptSTWPos);
   
    SetWindowPos(GetStatusWnd(GetWindow(hCompWnd, GW_OWNER)), 
             NULL,
             (int)ptSTWPos.x, 
             (int)ptSTWPos.y,
             0,
             0,
             SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOSIZE|SWP_NOZORDER);
    ImmSetStatusWindowPos(hIMC, (LPPOINT)&ptSTWPos);
    
    ptWnd.y = ptSTWPos.y;
    lpIMC->cfCompForm.ptCurrentPos = ptWnd;
    ScreenToClient(lpIMC->hWnd, &lpIMC->cfCompForm.ptCurrentPos);
    
    ptWnd.x = lpImeL->cxCompBorder;
    
    if(ptWnd.y - (lpImeL->yCompHi + sImeG.yCandHi) < 0){
    	 ptWnd.y = sImeG.rcWorkArea.bottom - (sImeG.yCandHi+lpImeL->yCompHi);
    }
    
    SetWindowPos(hCompWnd, 
    	 NULL,
    	 ptWnd.x,
    	 ptWnd.y,
    	 0, 0,
    	 SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
	
    lpImeL->ptNewComp = ptWnd;

    hCandWnd = GetCandWnd(GetWindow(hCompWnd, GW_OWNER));

    if (!hCandWnd) {
        return;
    }

    // decide the position of candidate window by UI's position
    CalcCandPos(hIMC, GetWindow(hCompWnd, GW_OWNER), &ptWnd);

    ScreenToClient(lpIMC->hWnd, &ptWnd);

    lpIMC->cfCandForm[0].dwStyle = CFS_CANDIDATEPOS;
    lpIMC->cfCandForm[0].ptCurrentPos = ptWnd;

    if (!IsWindowVisible(hCandWnd)) {
        return;
    }

    PostMessage(hCandWnd, WM_IME_NOTIFY, IMN_SETCANDIDATEPOS, 0x0001);
    return;
}


/**********************************************************************/
/* SetCompWindow()                                                    */
/**********************************************************************/
void PASCAL SetCompWindow(              // set the position of composition window
    HWND hCompWnd)
{
    HIMC           hIMC;
    LPINPUTCONTEXT lpIMC;
    HWND           hUIWnd;

    hUIWnd = GetWindow(hCompWnd, GW_OWNER);
    if (!hUIWnd) {
        return;
    }
    hIMC = (HIMC)GetWindowLong(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {
        return;
    }

    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC) {
        return;
    }

    SetCompPosition(hCompWnd, hIMC, lpIMC);
    ImmUnlockIMC(hIMC);

    return;
}

/**********************************************************************/
/* MoveDefaultCompPosition()                                          */
/**********************************************************************/
void PASCAL MoveDefaultCompPosition(    // the default comp position
                                        // need to near the caret
    HWND hUIWnd)
{
    HIMC           hIMC;
    LPINPUTCONTEXT lpIMC;
    HWND           hCompWnd;

    hIMC = (HIMC)GetWindowLong(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {
        return;
    }

    hCompWnd = GetCompWnd(hUIWnd);
    if (!hCompWnd) {
        return;
    }

    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC) {
        return;
    }

    if (!(lpIMC->cfCompForm.dwStyle & CFS_FORCE_POSITION)) {
        SetCompPosition(hCompWnd, hIMC, lpIMC);
    }

    ImmUnlockIMC(hIMC);

    return;
}

/**********************************************************************/
/* ShowComp()                                                         */
/**********************************************************************/
void PASCAL ShowComp(           // Show the composition window
    HWND hUIWnd,
    int  nShowCompCmd)
{
    HGLOBAL  hUIPrivate;
    LPUIPRIV lpUIPrivate;

    // show or hid the UI window
    hUIPrivate = (HGLOBAL)GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
    if (!hUIPrivate) {
        return;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {
        return;
    }

    if (lpUIPrivate->nShowCompCmd == nShowCompCmd) {
        goto SwCompNoChange;
    }

    if (nShowCompCmd == SW_HIDE) {
        lpUIPrivate->fdwSetContext &= ~(ISC_HIDE_COMP_WINDOW);
    }

    if (lpUIPrivate->hCompWnd) {
        if(nShowCompCmd == SW_HIDE) {
            uStartComp = 0;
        } else {
            uStartComp = 1;
        }
        
        ShowWindow(lpUIPrivate->hCompWnd, nShowCompCmd);
        lpUIPrivate->nShowCompCmd = nShowCompCmd;
    }

SwCompNoChange:
    GlobalUnlock(hUIPrivate);
    return;
}

/**********************************************************************/
/* StartComp()                                                        */
/**********************************************************************/
void PASCAL StartComp(
    HWND hUIWnd)
{
    HIMC           hIMC;
    HGLOBAL        hUIPrivate;
    LPINPUTCONTEXT lpIMC;
    LPUIPRIV       lpUIPrivate;

    hIMC = (HIMC)GetWindowLong(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {           
        return;
    }

    hUIPrivate = (HGLOBAL)GetWindowLong(hUIWnd, IMMGWLP_PRIVATE);
    if (!hUIPrivate) {     
        return;
    }

    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC) {          
        return;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {    // can not draw composition window
        ImmUnlockIMC(hIMC);
        return;
    }

    lpUIPrivate->fdwSetContext |= ISC_SHOWUICOMPOSITIONWINDOW;

    if(!lpUIPrivate->hCompWnd) {
        lpUIPrivate->hCompWnd = CreateWindowEx(
             WS_EX_NOACTIVATE|WS_EX_TOPMOST|WS_EX_TOOLWINDOW,
             szCompClassName, 
             NULL, 
             WS_POPUP|WS_BORDER,//WS_DISABLED|
             0, 
             0, 
             lpImeL->xCompWi, 
             lpImeL->yCompHi,
             hUIWnd, 
             (HMENU)NULL, 
             hInst, 
             NULL);
        SetWindowLong(lpUIPrivate->hCompWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
        SetWindowLong(lpUIPrivate->hCompWnd, UI_MOVE_XY, lpImeL->nMaxKey);
    }

    uStartComp = 1;
    // try to set the position of composition UI window near the caret
    SetCompPosition(lpUIPrivate->hCompWnd, hIMC, lpIMC);

    ImmUnlockIMC(hIMC);

    ShowComp(hUIWnd, SW_SHOWNOACTIVATE);

    GlobalUnlock(hUIPrivate);

    return;
}

/**********************************************************************/
/* EndComp()                                                          */
/**********************************************************************/
void PASCAL EndComp(
    HWND hUIWnd)
{
    ShowComp(hUIWnd, SW_HIDE);

    return;
}

/**********************************************************************/
/* DestroyCompWindow()                                                */
/**********************************************************************/
void PASCAL DestroyCompWindow(          // destroy composition window
    HWND hCompWnd)
{
    HGLOBAL  hUIPrivate;
    LPUIPRIV lpUIPrivate;

    if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
        // undo the drag border
        DrawDragBorder(hCompWnd,
            GetWindowLong(hCompWnd, UI_MOVE_XY),
            GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
    }

    hUIPrivate = (HGLOBAL)GetWindowLong(GetWindow(hCompWnd, GW_OWNER),
        IMMGWLP_PRIVATE);
    if (!hUIPrivate) {     
        return;
    }

    lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
    if (!lpUIPrivate) {    
        return;
    }

    lpUIPrivate->nShowCompCmd = SW_HIDE;
   SendMessage(lpUIPrivate->hCompWnd ,SIZE_MINIMIZED,NULL,NULL);
    //__asm int 3;
    lpUIPrivate->hCompWnd = (HWND)NULL;
 
    GlobalUnlock(hUIPrivate);
    return;
}

BOOL GetSelPingyin(LPCOMPOSITIONSTRING lpCompStr,int position, TCHAR*  CHDes)
{
    int rePosition,iStrat,iEnd;
    TCHAR*pSelStr ,*pSelItem;
	
    if(!lpCompStr||!CHDes )   return FALSE;

    rePosition = position- lpImeL->rcCompText.left;
	
    rePosition = rePosition/(sImeG.xChiCharWi/2);

    if((DWORD)rePosition>lpCompStr->dwCompStrLen ||rePosition<0)      return FALSE;
    
    pSelStr = (LPTSTR)((LPBYTE)lpCompStr + lpCompStr->dwCompStrOffset);

    if(*(pSelStr+rePosition) ==32)	    return FALSE;
   
    //search for space back
    iStrat = iEnd = rePosition;
     while ((DWORD)iEnd <lpCompStr->dwCompStrLen &&
		   (*((TCHAR*)pSelStr+iEnd) !=32)) {
          iEnd++;
     }
      	
     while (iStrat >=0 && (*((TCHAR*)pSelStr+iStrat) !=32)){
          iStrat--;
     }
     	 	
     if((iEnd - iStrat) <1 )    return FALSE;
	 
     rePosition = iStrat+1;
     pSelItem  = lpImeL->tComSelItem;
     {
         TCHAR TempBuf[COMP_MAX_PYLEN+1];
         TCHAR *pTempBuf       = TempBuf;
         TCHAR *pComCurItem = lpImeL->tComCurItem;
         while( rePosition<iEnd ) {
	        *pTempBuf = *pSelItem ;
	        *pSelItem = *(pSelStr+rePosition);
	        *pComCurItem = *pSelItem;
	        rePosition++;
	        pSelItem++;
	        pTempBuf++;
	        pComCurItem++;
		 }
		 *pSelItem   = 0 ;		
		 *pTempBuf  = 0 ;
		 *pComCurItem=0;
     if(wcscmp(lpImeL->tComSelItem,pTempBuf)==0)
 	   return FALSE;
     }
     return (TRUE);
}
	
void  MouseSelCompingyin(
	HWND    hComWnd,
	LPPOINT lpCursor)
{
    //    lpImeL->
           
    HIMC                            hIMC;
    LPINPUTCONTEXT                  lpIMC;
    LPCOMPOSITIONSTRING lpCompStr;
    TCHAR   chSelPingyin[COMP_MAX_PYLEN+1];         
    // change candlist
    hIMC = (HIMC)GetWindowLong(GetWindow(hComWnd, GW_OWNER), IMMGWLP_IMC);
    if (!hIMC)         return;
    
    // get lpIMC
    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC)         return;

    lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC ->hCompStr);
   
    if(!lpCompStr )
    {
       ImmUnlockIMC(hIMC); 
	   return;	 
    }

    if(GetSelPingyin(lpCompStr,lpCursor->x,chSelPingyin)) {
         
        LPPRIVCONTEXT   lpImcP;
	    HWND                  hCandWnd;
        {
			RECT TempRC;   	
			TempRC = lpImeL->rcCompText;
			TempRC.left = 0;   
			RedrawWindow(hComWnd, &TempRC, NULL, RDW_INVALIDATE);
        }
	
        //get lpImcP
        lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
	    if(lpImcP){
 	      Finalize(lpIMC, lpCompStr, lpImcP);   
 	      hCandWnd = GetCandWnd(GetWindow(hComWnd, GW_OWNER));	 
 	      if(hCandWnd)
             RedrawWindow(hCandWnd, &sImeG.rcCandText, NULL, RDW_INVALIDATE);
 	      ImmLockIMCC(lpIMC->hPrivate);	  
        }
    }

    ImmUnlockIMCC(lpIMC ->hCompStr);
    ImmUnlockIMC(hIMC);
}

void ComLoadBmp(HWND hCompWnd ,LPCTSTR StrBmp,RECT * pRc)
{
     HDC      hDC, hMemDC;
     HBITMAP  hNewBmp, hOldBmp;

     hDC = GetDC(hCompWnd);
     hMemDC = CreateCompatibleDC(hDC);	
     hNewBmp = LoadBitmap(hInst,StrBmp);
     hOldBmp = (HBITMAP)SelectObject(hMemDC, hNewBmp);

     BitBlt(hDC, pRc->left, pRc->top,
            pRc->right - pRc->left,
            STATUS_DIM_Y,
            hMemDC, 0, 0, SRCCOPY);
     SelectObject(hMemDC, hOldBmp);
     DeleteObject(hNewBmp);
     DeleteDC(hMemDC);
     ReleaseDC(hCompWnd, hDC);	 
}

/**********************************************************************/
/* CompButtonUp()                                                     */
/**********************************************************************/
BOOL PASCAL CompButtonUp(       // finish drag, set comp  window to this
                                // position
    HWND   hCompWnd)
{
    LONG            lTmpCursor, lTmpOffset;
    POINT           pt;
    HWND            hUIWnd;
    HIMC            hIMC;
    LPINPUTCONTEXT  lpIMC;
    RECT            rcWorkArea;

    if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) == WINDOW_NOT_DRAG) {
        return (FALSE);
    }

    lTmpCursor = GetWindowLong(hCompWnd, UI_MOVE_XY);

    // calculate the org by the offset
    lTmpOffset = GetWindowLong(hCompWnd, UI_MOVE_OFFSET);

    pt.x = (*(LPPOINTS)&lTmpCursor).x - (*(LPPOINTS)&lTmpOffset).x;
    pt.y = (*(LPPOINTS)&lTmpCursor).y - (*(LPPOINTS)&lTmpOffset).y;

    DrawDragBorder(hCompWnd, lTmpCursor, lTmpOffset);
    SetWindowLong(hCompWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);

    SetWindowLong(hCompWnd, UI_MOVE_XY, lpImeL->nMaxKey);

    ReleaseCapture();

    hUIWnd = GetWindow(hCompWnd, GW_OWNER);

    hIMC = (HIMC)GetWindowLong(hUIWnd, IMMGWLP_IMC);
    if (!hIMC) {
        return (FALSE);
    }

    lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
    if (!lpIMC) {
        return (FALSE);