CIMEUIWindowHandler Struct Reference

Static Public Member Functions
static LRESULT CALLBACK	ImeUIMsImeHandler (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	@implemented
static HRESULT CALLBACK	ImeUIMsImeMouseHandler (HWND hWnd, WPARAM wParam, LPARAM lParam)
	@implemented
static LRESULT CALLBACK	ImeUIMsImeModeBiasHandler (HWND hWnd, WPARAM wParam, LPARAM lParam)
	@implemented
static LRESULT CALLBACK	ImeUIMsImeReconvertRequest (HWND hWnd, WPARAM wParam, LPARAM lParam)
	@implemented
static LRESULT CALLBACK	ImeUIWndProcWorker (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	@implemented
static HRESULT CALLBACK	ImeUIDelayedReconvertFuncCall (HWND hWnd)
	@implemented
static HRESULT CALLBACK	ImeUIOnLayoutChange (LPARAM lParam)
	@implemented
static HRESULT CALLBACK	ImeUIPrivateHandler (UINT uMsg, WPARAM wParam, LPARAM lParam)
	@implemented
static LRESULT CALLBACK	ImeUINotifyHandler (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	@unimplemented

Detailed Description

Definition at line 935 of file ui.cpp.

Member Function Documentation

ImeUIDelayedReconvertFuncCall()

HRESULT CALLBACK CIMEUIWindowHandler::ImeUIDelayedReconvertFuncCall ( HWND  hWnd )

static

@implemented

Definition at line 1127 of file ui.cpp.

{
    HIMC hIMC = (HIMC)::GetWindowLongPtrW(hWnd, UI_GWLP_HIMC);
    CicIMCLock imcLock(hIMC);
    if (FAILED(imcLock.m_hr))
        return imcLock.m_hr;
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return imeContext.m_hr;
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    if (pCicIC)
        pCicIC->DelayedReconvertFuncCall(imcLock);
    return S_OK;
}

Referenced by ImeUIWndProcWorker().

ImeUIMsImeHandler()

LRESULT CALLBACK CIMEUIWindowHandler::ImeUIMsImeHandler ( HWND  hWnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

@implemented

Definition at line 1102 of file ui.cpp.

{
    if (uMsg == WM_MSIME_MOUSE)
        return ImeUIMsImeMouseHandler(hWnd, wParam, lParam);
    if (uMsg == WM_MSIME_MODEBIAS)
        return ImeUIMsImeModeBiasHandler(hWnd, wParam, lParam);
    if (uMsg == WM_MSIME_RECONVERTREQUEST)
        return ImeUIMsImeReconvertRequest(hWnd, wParam, lParam);
    if (uMsg == WM_MSIME_SERVICE)
    {
        TLS *pTLS = TLS::GetTLS();
        if (pTLS && pTLS->m_pProfile)
        {
            LANGID LangID;
            pTLS->m_pProfile->GetLangId(&LangID);
            if (PRIMARYLANGID(LangID) == LANG_KOREAN)
                return FALSE;
        }
        return TRUE;
    }
    return 0;
}

Referenced by ImeUIWndProcWorker().

ImeUIMsImeModeBiasHandler()

LRESULT CALLBACK CIMEUIWindowHandler::ImeUIMsImeModeBiasHandler ( HWND  hWnd, WPARAM  wParam, LPARAM  lParam  )

static

@implemented

Definition at line 1028 of file ui.cpp.

{
    if (!wParam)
        return TRUE;
 
    CicIMCLock imcLock((HIMC)lParam);
    if (FAILED(imcLock.m_hr))
        return imcLock.m_hr;
 
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return FALSE;
 
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    if (!pCicIC)
        return FALSE;
 
    if (wParam == 1)
    {
        if (lParam == 0 || lParam == 1 || lParam == 4 || lParam == 0x10000)
        {
            GUID guid = pCicIC->m_ModeBias.ConvertModeBias((DWORD)lParam);
            pCicIC->m_ModeBias.SetModeBias(guid);
 
            pCicIC->m_dwUnknown7[2] |= 1;
            pCicIC->m_pContextOwnerServices->AddRef();
            pCicIC->m_pContextOwnerServices->OnAttributeChange(GUID_PROP_MODEBIAS);
            pCicIC->m_pContextOwnerServices->Release();
            return TRUE;
        }
    }
    else if (wParam == 2)
    {
        return pCicIC->m_ModeBias.ConvertModeBias(pCicIC->m_ModeBias.m_guid);
    }
 
    return FALSE;
}

Referenced by ImeUIMsImeHandler().

ImeUIMsImeMouseHandler()

HRESULT CALLBACK CIMEUIWindowHandler::ImeUIMsImeMouseHandler ( HWND  hWnd, WPARAM  wParam, LPARAM  lParam  )

static

@implemented

Definition at line 950 of file ui.cpp.

{
    if ((BYTE)wParam == 0xFF)
        return TRUE;
 
    CicIMCLock imcLock((HIMC)lParam);
    if (FAILED(imcLock.m_hr))
        return imcLock.m_hr;
 
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return FALSE;
 
    HRESULT hr = E_FAIL;
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    if (pCicIC)
    {
        UINT keys = 0;
        if (wParam & MK_LBUTTON)
            keys |= 0x1;
        if (wParam & MK_SHIFT)
            keys |= 0x10;
        if (wParam & MK_RBUTTON)
            keys |= 0x2;
        if (wParam & MK_MBUTTON)
            keys |= 0x780000;
        else if (wParam & MK_ALT)
            keys |= 0xFF880000;
        hr = pCicIC->MsImeMouseHandler(HIWORD(wParam), HIBYTE(LOWORD(wParam)), keys, imcLock);
    }
 
    return hr;
}

Referenced by ImeUIMsImeHandler().

ImeUIMsImeReconvertRequest()

LRESULT CALLBACK CIMEUIWindowHandler::ImeUIMsImeReconvertRequest ( HWND  hWnd, WPARAM  wParam, LPARAM  lParam  )

static

@implemented

Definition at line 1069 of file ui.cpp.

{
    if (wParam == 0x10000000)
        return TRUE;
 
    HIMC hIMC = (HIMC)::GetWindowLongPtrW(hWnd, UI_GWLP_HIMC);
    CicIMCLock imcLock(hIMC);
    if (FAILED(imcLock.m_hr))
        return FALSE;
 
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return FALSE;
 
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    TLS *pTLS = TLS::GetTLS();
    if (!pCicIC || !pTLS)
        return FALSE;
 
    auto pThreadMgr = pTLS->m_pThreadMgr;
    auto pProfile = pTLS->m_pProfile;
    if (!pThreadMgr || !pProfile)
        return FALSE;
 
    UINT uCodePage = 0;
    pProfile->GetCodePageA(&uCodePage);
    pCicIC->SetupReconvertString(imcLock, pThreadMgr, uCodePage, WM_MSIME_RECONVERT, FALSE);
    pCicIC->EndReconvertString(imcLock);
    return TRUE;
}

Referenced by ImeUIMsImeHandler().

ImeUINotifyHandler()

LRESULT CALLBACK CIMEUIWindowHandler::ImeUINotifyHandler ( HWND  hWnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

@unimplemented

Definition at line 1144 of file ui.cpp.

{
    HIMC hIMC = (HIMC)::GetWindowLongPtrW(hWnd, UI_GWLP_HIMC);
    CicIMCLock imcLock(hIMC);
    if (FAILED(imcLock.m_hr))
        return imcLock.m_hr;
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return imeContext.m_hr;
 
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    if (pCicIC)
    {
        switch (wParam)
        {
            case IMN_CLOSECANDIDATE:
            {
                pCicIC->m_bCandidateOpen = FALSE;
                HWND hImeWnd = ::ImmGetDefaultIMEWnd(NULL);
                if (::IsWindow(hImeWnd))
                    ::PostMessage(hImeWnd, WM_IME_NOTIFY, 0x10, (LPARAM)hIMC);
                break;
            }
            case IMN_OPENCANDIDATE:
            {
                pCicIC->m_bCandidateOpen = TRUE;
                pCicIC->ClearPrevCandidatePos();
                break;
            }
            case IMN_SETCANDIDATEPOS:
            {
                //FIXME
                break;
            }
            case IMN_SETCOMPOSITIONFONT:
            {
                //FIXME
                break;
            }
            case IMN_SETCOMPOSITIONWINDOW:
            {
                //FIXME
                break;
            }
            case 0xF:
            {
                CIMEUIWindowHandler::ImeUIOnLayoutChange(lParam);
                break;
            }
            case 0x10:
            {
                CIMEUIWindowHandler::ImeUIPrivateHandler(uMsg, 0x10, lParam);
                break;
            }
            case 0x13:
            {
                CIMEUIWindowHandler::ImeUIOnLayoutChange(lParam);
                break;
            }
            case 0x14:
            {
                //FIXME
                break;
            }
            case 0x16:
            {
                ::SetTimer(hWnd, 2, 100, NULL);
                break;
            }
            case 0x17:
            {
                return (LRESULT)hWnd;
            }
            case 0x10D:
            {
                //FIXME
                break;
            }
            case 0x10E:
                pCicIC->m_dwQueryPos = 0;
                break;
        }
    }
 
    return 0;
}

ImeUIOnLayoutChange()

HRESULT CALLBACK CIMEUIWindowHandler::ImeUIOnLayoutChange ( LPARAM  lParam )

static

@implemented

Definition at line 985 of file ui.cpp.

{
    CicIMCLock imcLock((HIMC)lParam);
    if (FAILED(imcLock.m_hr))
        return S_OK;
 
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return S_OK;
 
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    if (pCicIC)
    {
        auto pContextOwnerServices = pCicIC->m_pContextOwnerServices;
        pContextOwnerServices->AddRef();
        pContextOwnerServices->OnLayoutChange();
        pContextOwnerServices->Release();
    }
 
    return S_OK;
}

Referenced by ImeUINotifyHandler().

ImeUIPrivateHandler()

HRESULT CALLBACK CIMEUIWindowHandler::ImeUIPrivateHandler ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

@implemented

Definition at line 1009 of file ui.cpp.

{
    CicIMCLock imcLock((HIMC)lParam);
    if (FAILED(imcLock.m_hr))
        return imcLock.m_hr;
 
    CicIMCCLock<CTFIMECONTEXT> imeContext(imcLock.get().hCtfImeContext);
    if (FAILED(imeContext.m_hr))
        return imeContext.m_hr;
 
    CicInputContext *pCicIC = imeContext.get().m_pCicIC;
    if (pCicIC && wParam == 0x10)
        pCicIC->EscbClearDocFeedBuffer(imcLock, TRUE);
 
    return S_OK;
}

Referenced by ImeUINotifyHandler().

ImeUIWndProcWorker()

LRESULT CALLBACK CIMEUIWindowHandler::ImeUIWndProcWorker ( HWND  hWnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

@implemented

Definition at line 1233 of file ui.cpp.

{
    TLS *pTLS = TLS::GetTLS();
    if (pTLS && (pTLS->m_dwSystemInfoFlags & IME_SYSINFO_WINLOGON))
    {
        if (uMsg == WM_CREATE)
            return -1;
        return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
    }
 
    switch (uMsg)
    {
        case WM_CREATE:
        {
            UI::OnCreate(hWnd);
            break;
        }
        case WM_DESTROY:
        case WM_ENDSESSION:
        {
            UI::OnDestroy(hWnd);
            break;
        }
        case WM_IME_STARTCOMPOSITION:
        case WM_IME_COMPOSITION:
        case WM_IME_ENDCOMPOSITION:
        case WM_IME_SETCONTEXT:
        case WM_IME_NOTIFY:
        case WM_IME_SELECT:
        case WM_TIMER:
        {
            HIMC hIMC = (HIMC)GetWindowLongPtrW(hWnd, UI_GWLP_HIMC);
            UI* pUI = (UI*)GetWindowLongPtrW(hWnd, UI_GWLP_UI);
            CicIMCLock imcLock(hIMC);
            switch (uMsg)
            {
                case WM_IME_STARTCOMPOSITION:
                {
                    pUI->m_pComp->OnImeStartComposition(imcLock, pUI->m_hWnd);
                    break;
                }
                case WM_IME_COMPOSITION:
                {
                    if (lParam & GCS_COMPSTR)
                    {
                        pUI->m_pComp->OnImeCompositionUpdate(imcLock);
                        ::SetTimer(hWnd, 0, 10, NULL);
                        pUI->m_pComp->m_bInComposition = TRUE;
                    }
                    break;
                }
                case WM_IME_ENDCOMPOSITION:
                {
                    ::KillTimer(hWnd, 0);
                    pUI->m_pComp->OnImeEndComposition();
                    break;
                }
                case WM_IME_SETCONTEXT:
                {
                    pUI->OnImeSetContext(imcLock, wParam, lParam);
                    ::KillTimer(hWnd, 1);
                    ::SetTimer(hWnd, 1, 300, NULL);
                    break;
                }
                case WM_TIMER:
                {
                    switch (wParam)
                    {
                        case 0:
                            ::KillTimer(hWnd, wParam);
                            pUI->m_pComp->m_bInComposition = FALSE;
                            pUI->m_pComp->OnImeNotifySetCompositionWindow(imcLock);
                            break;
                        case 1:
                            ::KillTimer(hWnd, wParam);
                            pUI->m_pComp->OnImeSetContextAfter(imcLock);
                            break;
                        case 2:
                            ::KillTimer(hWnd, wParam);
                            CIMEUIWindowHandler::ImeUIDelayedReconvertFuncCall(hWnd);
                            break;
                        default:
                            break;
                    }
                    break;
                }
                case WM_IME_NOTIFY:
                case WM_IME_SELECT:
                default:
                {
                    pUI->m_pComp->OnPaintTheme(wParam);
                    break;
                }
            }
            break;
        }
        default:
        {
            if (IsMsImeMessage(uMsg))
                return CIMEUIWindowHandler::ImeUIMsImeHandler(hWnd, uMsg, wParam, lParam);
            return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
        }
    }
 
    return 0;
}

Referenced by UIWndProc().

---

The documentation for this struct was generated from the following file:

• dll/ime/msctfime/ui.cpp