dic.c

手机上的韩文输入法 saenaru20031212.zip

                    goto DBCS_BETA;
            }
            else
            {
DBCS_BETA:
                if( code == MYTEXT('^') )
                {
                    code2 = *lpprev;
                    if( IsTenten( code2 ) == FALSE )
                        goto DBCS_BETA2;
                    code2 = ConvTenten( code2 );
                    *lpprev++ = code2;
                }
                else if( code == MYTEXT('_') )
                {
                    code2 = *lpprev;
                    if( IsMaru( code2 ) == FALSE )
                        goto DBCS_BETA2;
                    code2 = ConvMaru( code2 );
                    *lpprev = code2;
                }
                else
                {
                    code = HanToZen(code,0,fdwConversion);
DBCS_BETA2:
                    *lpstr++ = code;
                    lpCompStr->dwCursorPos += 1;
                }
            }
        }
        else
        {
            if (fdwConversion & IME_CMODE_ROMAN  &&
                 fdwConversion & IME_CMODE_NATIVE )
            {

                if (IsSecond( code ))
                {
                    if (IsFirst( *lpprev ) &&
                       (code2 = ConvChar(hIMC,*lpprev,code)))
                    {
                        if (OneCharZenToHan(code2,&Katakana, &Sound))
                        {
                            *lpprev = Katakana;
                            if (Sound) {
                                *lpstr++ = Sound;
                                lpCompStr->dwCursorPos++;
                            }
                        } 
                        else 
                        {
                            code = ConvChar(hIMC, 0, code );
                            goto SBCS_BETA;
                        }
                    }
                    else
                    {
                        code = ConvChar(hIMC, 0, code );
                        //MakeGuideLine(hIMC,MYGL_TYPINGERROR);
                        goto SBCS_BETA;
                    }
                }
                else
                {
                    if( (WORD)(LONG_PTR)CharUpperW( (LPMYSTR)(LONG_PTR)code ) == 'N'
                      && (WORD)(LONG_PTR)CharUpperW( (LPMYSTR)(LONG_PTR)(code2 = *lpprev ) ) == 'N' )
                    {
                        *lpprev = (MYCHAR) 0xFF9D;
                    }
                    else
                    {
                         //MakeGuideLine(hIMC,MYGL_TYPINGERROR);
                         goto SBCS_BETA;
                    }
                }
            }
            else
            {
SBCS_BETA:
                if (OneCharZenToHan(code,&Katakana,&Sound)) 
                {
                    *lpstr++ = Katakana;
                    if (Sound) 
                    {
                        *lpstr++ = Sound;
                        lpCompStr->dwCursorPos++;
                    }
                }
                else
                {
                    *lpstr++ = code;
                }
                lpCompStr->dwCursorPos++;
            }
        }
        *lpstr = MYTEXT('\0');
    }

    // make reading string.
    lpstr = GETLPCOMPSTR(lpCompStr);
    lpread = GETLPCOMPREADSTR(lpCompStr);
    if (fdwConversion & IME_CMODE_HANGUL) 
    {
            Mylstrcpy(lpread,lpstr);
/*        if (fdwConversion & IME_CMODE_FULLSHAPE)
        {
            Mylstrcpy(lpread,lpstr);
        }
        else 
        {
            lHanToZen(lpread,lpstr,fdwConversion);
        }
	*/
    }
    else
    {
        LPMYSTR pSrc = lpstr;
        LPMYSTR pDst = lpread;

        for (; *pSrc;) {
            //*pDst++ = HiraToKata(*pSrc);
            *pDst++ = *pSrc;
            pSrc++;
        }
        *pDst = (MYCHAR) 0;
    }


    // make attribute
    lpCompStr->dwCursorPos = Mylstrlen(lpstr);
    lpCompStr->dwDeltaStart = (DWORD)(MyCharPrev(lpstr, lpstr+Mylstrlen(lpstr)) - lpstr);

    //MakeAttrClause(lpCompStr);
    lmemset((LPBYTE)GETLPCOMPATTR(lpCompStr),ATTR_INPUT, Mylstrlen(lpstr));
    lmemset((LPBYTE)GETLPCOMPREADATTR(lpCompStr),ATTR_INPUT, Mylstrlen(lpread));

    // make length
    lpCompStr->dwCompStrLen = Mylstrlen(lpstr);
    lpCompStr->dwCompReadStrLen = Mylstrlen(lpread);
    lpCompStr->dwCompAttrLen = Mylstrlen(lpstr);
    lpCompStr->dwCompReadAttrLen = Mylstrlen(lpread);

    //
    // make clause info
    //
    SetClause(GETLPCOMPCLAUSE(lpCompStr),Mylstrlen(lpstr));
    SetClause(GETLPCOMPREADCLAUSE(lpCompStr),Mylstrlen(lpread));
    lpCompStr->dwCompClauseLen = 8;
    lpCompStr->dwCompReadClauseLen = 8;

    GnMsg.message = WM_IME_COMPOSITION;
    GnMsg.wParam = 0;
    GnMsg.lParam = GCS_COMPALL | GCS_CURSORPOS | GCS_DELTASTART | dwGCR;
    GenerateMessage(hIMC, lpIMC, lpCurTransKey,(LPTRANSMSG)&GnMsg);

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

#endif


/**********************************************************************/
/*                                                                    */
/* DicKeydownHandler()                                                */
/*                                                                    */
/* WM_KEYDOWN handler for dictionary routine                          */
/*                                                                    */
/* wParam                                                             */
/* virtual key                                                        */
/*                                                                    */
/* lParam                                                             */
/* differ depending on wParam                                         */
/*                                                                    */
/**********************************************************************/
BOOL PASCAL DicKeydownHandler( hIMC, wParam, lParam ,lpbKeyState)
HIMC hIMC;
UINT wParam;
LPARAM lParam;
LPBYTE lpbKeyState;
{
    LPINPUTCONTEXT lpIMC;
    LPCOMPOSITIONSTRING lpCompStr;
    DWORD fdwConversion;

    BOOL cf=FALSE;
    int next=0;
    UINT select=0;

    // Candidate巩磊 急琶
    if (IsConvertedCompStr(hIMC))
    {
	switch( wParam )
	{
	    case VK_UP:
		next=-1;
		break;
	    case VK_DOWN:
		next=1;
		break;
	    case VK_NEXT:
		next=2;
		break;
	    case VK_PRIOR:
		next=-2;
		break;
	    case VK_HOME:
		next=-100;
	        break;
	    case VK_END:
		next=100;
	        break;
	    case VK_1:
	    case VK_2:
	    case VK_3:
	    case VK_4:
	    case VK_5:
	    case VK_6:
	    case VK_7:
	    case VK_8:
	    case VK_9:
		select= wParam - VK_1 + 1;
		break;
	    default:
		break;
	}
	if (next || select)
	{
	    ConvHanja(hIMC,next,select);
            return TRUE;
	}
    }

    switch( wParam )
    {
        case VK_DELETE:
        case VK_BACK:
            if (IsConvertedCompStr(hIMC))
	    {
                FlushText(hIMC);
	        return TRUE;
	    } else if (IsCompStr(hIMC))
	    {
                DeleteChar(hIMC,wParam);
	        return TRUE;
	    }
            break;

        case VK_HANJA:
        case VK_F9:
	    hangul_ic_init(&ic);
	    ConvHanja(hIMC,1,0);
	    return TRUE;
	    break;

	case VK_SPACE:
	    lpIMC = ImmLockIMC(hIMC);
	    // Get ConvMode from IMC.
	    fdwConversion = lpIMC->fdwConversion;
            ImmUnlockIMC(hIMC);

	    if (IsCompStr(hIMC) &&
		    (fdwConversion & IME_CMODE_FULLSHAPE) &&
		    (fdwConversion & IME_CMODE_NATIVE)) {
		hangul_ic_init(&ic);
		ConvHanja(hIMC,1,0);
		return TRUE;
	    }

	    if (IsCompStr(hIMC))
            {
                MakeResultString(hIMC,TRUE);
#if 0
                lpIMC = ImmLockIMC(hIMC);
                lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
                InitCompStr(lpCompStr,CLR_UNDET);
                ImmUnlockIMC(hIMC);
#endif

                // Simulate a key press
                keybd_event( (BYTE)wParam, 0x0, 0, 0 );

                // Simulate a key release
                //keybd_event( (BYTE)wParam, 0x0, KEYEVENTF_KEYUP, 0);
		return TRUE;
	    }
#if 0
	    // 胶其捞胶甫 茄磊 其捞瘤 逞扁绰 虐肺 荤侩茄促.
	    // 可记栏肺 难绊 懦 荐 乐霸.
            if (IsConvertedCompStr(hIMC))
	    {
	        ConvHanja(hIMC,1);
	        return TRUE;
	    }
#endif
	    break;

	case VK_LEFT:
	case VK_RIGHT:
	case VK_UP:
	case VK_DOWN:
	case VK_HOME:
	case VK_END:
	case VK_NEXT:
	case VK_PRIOR:

	case VK_TAB:
	case VK_ESCAPE:
	    if (IsCompStr(hIMC))
            {
                MakeResultString(hIMC,TRUE);
                // Simulate a key press
                keybd_event( (BYTE)wParam, 0x0, 0, 0 );

                // Simulate a key release
                //keybd_event( (BYTE)wParam, 0x0, KEYEVENTF_KEYUP, 0);
		return TRUE;
	    }
	    break;

        case VK_RETURN:
            if (IsConvertedCompStr(hIMC))
		cf = TRUE;
            MakeResultString(hIMC,TRUE);

            lpIMC = ImmLockIMC(hIMC);

	    if (!cf)
	    {
#if 0
                if (IsWindow(lpIMC->hWnd))
                {
                   //PostMessage(lpIMC->hWnd,WM_IME_KEYDOWN,wParam,lParam);
		}
#endif
                TRANSMSG GnMsg;
                GnMsg.message = WM_IME_KEYDOWN;
                GnMsg.wParam = wParam;
                GnMsg.lParam = lParam;
                GenerateMessage(hIMC, lpIMC, lpCurTransKey,(LPTRANSMSG)&GnMsg);
                // Simulate a key press
                // keybd_event( VK_RETURN, 0x0d, 0, 0 );

                // Simulate a key release
                // keybd_event( VK_RETURN, 0x0d, KEYEVENTF_KEYUP, 0);
	    }
            ImmUnlockIMC(hIMC);
	    // spy++肺 茄臂 IME2002狼 青悼阑 混旗夯 搬苞,
	    // CompStr捞 乐阑 版快绰 RETURN阑 摹搁 贸澜 捞亥飘啊 积板阑 锭 茄锅
	    // 弊府绊, CompStr阑 commit茄 饶俊 促矫 茄锅 虐捞亥飘啊 积板促.
	    // strings肺 imekr61.ime甫 混旗夯 搬苞 keybd_event()甫 静绊 乐菌栏哥
	    // saenaru绰 捞 规侥阑 蝶耳促.
	    //
	    // 绊绊鸥磊甫 烹秦 盒籍秦焊聪, WM_IME_KEYDOWN捞 刚历 积板促.
	    // 弊贰辑 困贸烦 GenerateMessage()甫 捞侩秦焊聪 keybd_event甫 静瘤
	    // 臼酒档 登菌促.
	    //
            hangul_ic_init(&ic);
	    return TRUE;
#if 0
            lpIMC = ImmLockIMC(hIMC);
            if (IsCandidate(lpIMC))
	    {
                MakeResultString(hIMC,TRUE);
		cf = TRUE;
	    }
            ImmUnlockIMC(hIMC);
	    if (cf) return TRUE;
#endif
	    break;

	    /*
        case VK_HANGUL:
	    // Toggle HANGUL
            ChangeMode(hIMC,TO_CMODE_HANGUL);
	    return TRUE;
            break;
	    */

#ifdef DEBUG
        case VK_G:
            if (dwDebugFlag & DEBF_GUIDELINE)
            {
                if (IsCTLPushed(lpbKeyState))
                {
                    MakeGuideLine(hIMC,MYGL_TESTGUIDELINE);
                    //MakeGuideLine(hIMC,MYGL_TYPINGERROR);
                    return( TRUE );
                }
            }
            break;
#endif
        default:
            break;
    }

    if (( VK_0 <= wParam && VK_9 >= wParam ) ||
        ( VK_A <= wParam && VK_Z >= wParam ) ||
        ( VK_RETURN == wParam || VK_SPACE == wParam ) ||
        //( VK_NUMPAD0 <= wParam && VK_NUMPAD9 >= wParam ) ||
        ( VK_OEM_1 <= wParam && VK_OEM_9 >= wParam ) ||