conime.c File Reference

#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <winnls.h>
#include <winreg.h>
#include <wincon.h>
#include <imm.h>
#include <immdev.h>
#include <stdlib.h>
#include <wchar.h>
#include <undocuser.h>
#include <imm32_undoc.h>
#include <wincon_undoc.h>
#include <cjkcode.h>
#include <strsafe.h>
#include <ndk/ntndk.h>
#include "conime.h"
#include "resource.h"
#include <wine/debug.h>

Include dependency graph for conime.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	MAGIC_SEND_COMPSTR   0x4B425930
#define	MAGIC_SEND_IMEDISPLAY   0x4B425931
#define	MAGIC_SEND_GUIDELINE   0x4B425932
#define	MAGIC_SEND_CANDLIST   0x4B425935
#define	MAGIC_SEND_IMESYSTEM   0x4B425936
#define	_FOREGROUND_WHITE   (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
#define	_BACKGROUND_WHITE   (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
#define	PREFIX_LEN   2
#define	COLUMN_COUNT   7

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (conime)
void	IntFormatNumber (PWSTR pszBuffer, UINT value, UINT width)
BOOL	IntIsDoubleWidthChar (WCHAR wch)
	Determines if a Unicode character should be rendered as "Double Width" (2 columns).
INT	IntGetStringWidth (PCWSTR pch)
BOOL	IntSendDataToConsole (HWND hwndConsole, HWND hwndSender, PCOPYDATASTRUCT pCopyData)
BOOL	IntIsLogOnSession (void)
	Determines whether the current process is an interactive logon session (such as Winlogon)
void	IntFreeConsoleEntries (void)
static void	IntSetCurrentConsole (HANDLE hConsole)
PCONENTRY	IntFindConsoleEntry (HANDLE hConsole)
	Finds the CONENTRY structure corresponding to the specified console handle.
void	ConIme_OnEnd (HWND hwnd, UINT uMsg)
	Terminate Console IME.
BOOL	IntGrowEntries (void)
BOOL	ConIme_UnInitEntry (HWND hwnd, PCONENTRY pEntry)
	Frees the resources associated with the console entry.
BOOL	IntGetImeLayoutText (PCONENTRY pEntry)
	Gets the name of the current keyboard layout or IME and stores it in the entry.
BOOL	IntIsImeOpen (HIMC hIMC, PCONENTRY pEntry)
void	IntFillImeCandidatesCHT (PCONENTRY pEntry, PIMEDISPLAY pDisplay, UINT iCand)
	Fills the status buffer with characters and attributes from the.
UINT	IntFillImeModeCHT (PCONENTRY pEntry, PIMEDISPLAY pDisplay, INT cch)
	Builds a buffer for displaying the Traditional Chinese IME mode.
void	IntFillImeCompStrCHSorCHT (PCONENTRY pEntry, PIMEDISPLAY pDisplay, UINT cch)
UINT	IntGetCharInfoWidth (PCHAR_INFO pCharInfo, UINT cch)
UINT	IntGetCharDisplayWidth (WCHAR wch)
UINT	IntFillImeSpaceCHSorCHT (PCONENTRY pEntry, PIMEDISPLAY pDisplay, UINT cch)
	Adjusts the width of the status display and pads it with spaces.
BOOL	IntFillImeDisplayCHT (PCONENTRY pEntry, PIMEDISPLAY pDisplay)
	Converts the current Traditional Chinese IME status into a string for.
void	IntCopyUnicodeToCharInfo (PCHAR_INFO *ppDest, PCWSTR pszSrc)
BOOL	IntFillImeDisplayJPN (PCONENTRY pEntry, PIMEDISPLAY pDisplay)
	Converts the current Japanese IME status into a string for display (CHAR_INFO array).
BOOL	IntFillImeDisplayKOR (PCONENTRY pEntry, PIMEDISPLAY pDisplay)
	Converts the current Korean IME status into a string for display (CHAR_INFO array).
INT	IntFillImeModeCHS (PCONENTRY pEntry, PIMEDISPLAY pDisplay, UINT cch)
	Builds a buffer for displaying the Simplified Chinese IME mode.
UINT	IntFillImeCandidatesCHS (PCONENTRY pEntry, PIMEDISPLAY pDisplay, UINT cch)
	Fills the status buffer with characters and attributes from the.
BOOL	IntFillImeDisplayCHS (PCONENTRY pEntry, PIMEDISPLAY pDisplay)
	Converts the current Simplified Chinese IME status into a string for display (CHAR_INFO array).
BOOL	IntFillImeDisplay (PCONENTRY pEntry, PIMEDISPLAY pDisplay)
	Converts the current IME status into a string for display (CHAR_INFO array).
BOOL	ConIme_OnNotifySetOpenStatus (HWND hwndTarget)
	IMN_SETOPENSTATUS.
void	IntSendConversionStatusCHT (HWND hwnd, PCONENTRY pEntry)
void	IntSendConversionStatusJPNorKOR (HWND hwnd, PCONENTRY pEntry)
void	IntSendConversionStatusCHS (HWND hwnd, PCONENTRY pEntry)
void	IntSendConversionStatus (HWND hwnd)
BOOL	ConIme_OnSwitchIme (HWND hwnd, HANDLE hConsole, HKL hKL)
	WM_USER_SWITCHIME.
BOOL	ConIme_OnDeactivate (HWND hwnd, HANDLE hConsole)
	WM_USER_DEACTIVATE.
BOOL	ConIme_SetScreenSize (HWND hwnd, HANDLE hConsole, COORD ScreenSize)
	WM_USER_SETSCREENSIZE.
BOOL	ConIme_OnGo (HWND hwnd, HANDLE hConsole, HKL hKL, INT iDirection)
	Handles keyboard layout switch requests.
BOOL	ConIme_SendImeStatus (HWND hWnd)
	WM_USER_SENDIMESTATUS.
BOOL	ConIme_OnInputLangChange (HWND hwnd, WPARAM wParam, HKL hKL)
BOOL	ConIme_InitEntry (HWND hwnd, HANDLE hConsole, HWND hwndConsole)
	Initializes and allocates a CONENTRY structure for the new console connection.
BOOL	ConIme_OnUnInit (HWND hwnd, HANDLE hConsole)
	WM_USER_UNINIT.
BOOL	ConIme_OnInit (HWND hwnd, HANDLE hConsole, HWND hwndConsole)
	WM_USER_INIT.
BOOL	ConIme_OnCreate (HWND hwnd)
	WM_CREATE.
void	IntDoImeCompJPN (HWND hwnd, PCONENTRY pEntry, DWORD dwFlags)
	Processes Japanese IME Composition and Result strings.
void	IntDoImeCompCHS (HWND hwnd, PCONENTRY pEntry, DWORD dwFlags)
	Notifies the input composition status of the Chinese (Simplified) IME to the console.
void	IntDoImeCompCHT (HWND hWnd, PCONENTRY pEntry, DWORD dwFlags)
	Processes the input composition status of the Chinese (Traditional) IME and.
void	IntDoImeCompKOR (HWND hwnd, PCONENTRY pEntry, DWORD dwFlags, WCHAR wch)
	Processes the Korean IME input composition state and notifies the console.
void	IntDoImeComp (HWND hwnd, DWORD dwFlags, WCHAR wch)
void	ConIme_OnImeComposition (HWND hwnd, WPARAM wParam, LPARAM lParam)
	WM_IME_COMPOSITION.
UINT	IntFormatCandLineJPNorKOR (PCANDIDATELIST pCandList, PWSTR pszCandStrDest, PBYTE pbAttrsDest, UINT width, UINT labelWidth, PCONENTRY pEntry, BOOL bIsCode)
UINT	IntFormatCandLineCHT (PCANDIDATELIST pCandList, PWSTR pszCandStrDest, PBYTE pbAttrsDest, UINT width, UINT labelWidth, PCONENTRY pEntry)
UINT	IntFormatCandLineCHS (PCANDIDATELIST pCandList, PWSTR pszCandStrDest, PBYTE pbAttrsDest, UINT width, UINT labelWidth, PCONENTRY pEntry)
BOOL	IntSendCandListCHT (HWND hwnd, HIMC hIMC, PCONENTRY pEntry, DWORD dwCandidates, BOOL bOpen)
BOOL	IntSendCandListCHS (HWND hwnd, HIMC hIMC, PCONENTRY pEntry, DWORD dwCandidates, BOOL bOpen)
BOOL	IntSendCandListJPNorKOR (HWND hwnd, HIMC hIMC, PCONENTRY pEntry, DWORD dwCandidates, BOOL bOpen)
BOOL	ConIme_OnNotifyOpenCandidate (HWND hwnd, LPARAM lParam, BOOL bOpen)
	When the conversion candidate window opens, invoke the language-specific candidate.
BOOL	ConIme_OnNotifyChangeCandidate (HWND hwnd, LPARAM lParam)
BOOL	ConIme_OnNotifyGuideLine (HWND hWnd)
	Handles guideline notifications (error messages, etc.) from IME.
DWORD	IntGetImeState (HWND hWnd, HANDLE hConsole)
	WM_USER_GETIMESTATE.
BOOL	IntSetImeState (HWND hwnd, HANDLE hConsole, DWORD dwConversion)
	WM_USER_SETIMESTATE.
BOOL	ConIme_SetCodePage (HWND hwnd, HANDLE hConsole, BOOL bOutput, WORD wCodePage)
	WM_USER_SETCODEPAGE.
BOOL	ConIme_OnImeSystem (HWND hwnd, WPARAM wParam, LPARAM lParam)
	WM_IME_SYSTEM.
BOOL	IntCloseCandsCHT (HWND hwnd, HIMC hIMC, PCONENTRY pEntry, DWORD dwCandidates)
	Sends candidate list for Traditional Chinese (CHT).
BOOL	IntCloseCandsJPNorKOR (HWND hwnd, HIMC hIMC, PCONENTRY pEntry, DWORD dwCandidates)
	Sends the IME candidate list for Japanese/Korean.
BOOL	IntCloseCandsCHS (HWND hwnd, HIMC hIMC, PCONENTRY pEntry, DWORD dwCandidates)
	Sends the IME candidate list for Simplified Chinese (CHS).
BOOL	ConIme_OnNotifyCloseCandidate (HWND hwnd, DWORD dwCandidates)
	IMN_CLOSECANDIDATE.
BOOL	ConIme_OnImeNotify (HWND hWnd, WPARAM wParam, LPARAM lParam)
	WM_IME_NOTIFY.
BOOL	ConIme_OnKeyChar (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LRESULT	ConIme_OnRoute (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	WM_ROUTE_...
BOOL	ConIme_SimulateHotKey (HWND hwnd, WPARAM wParam, LPARAM lParam)
	WM_USER_SIMHOTKEY.
void	ConIme_OnEnable (void)
	WM_ENABLE.
void	ConIme_OnDisable (void)
	WM_ENABLE.
void	ConIme_OnImeStartComposition (HWND hwnd)
	WM_IME_STARTCOMPOSITION.
void	ConIme_OnImeEndComposition (HWND hWnd)
	WM_IME_ENDCOMPOSITION.
void	ConIme_OnChangeKeyboard (HWND hwnd, HANDLE hConsole, HKL hNewKL)
	WM_USER_CHANGEKEYBOARD.
LRESULT	ConIme_OnUser (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	(WM_USER + ...)
LRESULT	ConIme_OnInputLangChangeRequest (HWND hWnd, WPARAM wParam, LPARAM lParam)
	WM_INPUTLANGCHANGEREQUEST.
LRESULT CALLBACK	ConIme_WndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	The main window procedure for the Console IME.
BOOL	IntIsConImeOnSystemProcessEnabled (VOID)
	Is Console IME on system process enabled?
BOOL	ConIme_InitInstance (HINSTANCE hInstance)
	Initialize Console IME instance.
INT WINAPI	wWinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR lpCmdLine, INT nCmdShow)

Variables
HANDLE	g_hConsole = NULL
PCONENTRY *	g_ppEntries = NULL
UINT	g_cEntries = 0
HIMC	g_hOldIMC = NULL
DWORD	g_dwAttachToThreadId = 0
BOOL	g_bIsLogOnSession = FALSE
BOOL	g_bDisabled = FALSE
CRITICAL_SECTION	g_csLock

Macro Definition Documentation

_BACKGROUND_WHITE

#define _BACKGROUND_WHITE   (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)

Definition at line 42 of file conime.c.

_FOREGROUND_WHITE

#define _FOREGROUND_WHITE   (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)

Definition at line 41 of file conime.c.

COLUMN_COUNT

#define COLUMN_COUNT   7

MAGIC_SEND_CANDLIST

#define MAGIC_SEND_CANDLIST   0x4B425935

Definition at line 38 of file conime.c.

MAGIC_SEND_COMPSTR

#define MAGIC_SEND_COMPSTR   0x4B425930

Definition at line 35 of file conime.c.

MAGIC_SEND_GUIDELINE

#define MAGIC_SEND_GUIDELINE   0x4B425932

Definition at line 37 of file conime.c.

MAGIC_SEND_IMEDISPLAY

#define MAGIC_SEND_IMEDISPLAY   0x4B425931

Definition at line 36 of file conime.c.

MAGIC_SEND_IMESYSTEM

#define MAGIC_SEND_IMESYSTEM   0x4B425936

Definition at line 39 of file conime.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 25 of file conime.c.

PREFIX_LEN

#define PREFIX_LEN   2

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 8 of file conime.c.

Function Documentation

ConIme_InitEntry()

BOOL ConIme_InitEntry	(	HWND	hwnd,
		HANDLE	hConsole,
		HWND	hwndConsole
	)

Initializes and allocates a CONENTRY structure for the new console connection.

Definition at line 1147 of file conime.c.

{
    TRACE("(%p, %p, %p)\n", hwnd, hConsole, hwndConsole);
 
    PCONENTRY pEntry = NULL;
 
    for (UINT iEntry = 1; ; ++iEntry)
    {
        while (iEntry >= g_cEntries)
        {
            if (!IntGrowEntries())
                return FALSE;
        }
 
        pEntry = g_ppEntries[iEntry];
        if (!pEntry)
        {
            pEntry = LocalAlloc(LPTR, sizeof(CONENTRY));
            if (!pEntry)
                return FALSE;
 
            g_ppEntries[iEntry] = pEntry;
        }
 
        if (!pEntry->hConsole)
            break;
 
        if (pEntry->bWndEnabled && pEntry->bConsoleEnabled)
            ConIme_UnInitEntry(hwnd, pEntry);
 
        if (!pEntry->hConsole)
            break;
    }
 
    ZeroMemory(pEntry, sizeof(*pEntry));
    PKLINFO pKLInfo = pEntry->pKLInfo = LocalAlloc(LPTR, sizeof(KLINFO));
    if (!pEntry->pKLInfo)
        return FALSE;
 
    pKLInfo->hKL = NULL;
    pKLInfo->dwConversion = 0;
    pEntry->cKLs = 1;
 
    HIMC hIMC = ImmCreateContext();
    if (!hIMC)
    {
        LocalFree(pKLInfo);
        pEntry->pKLInfo = NULL;
        return FALSE;
    }
 
    pEntry->hNewIMC = hIMC;
    pEntry->hConsole = hConsole;
    pEntry->hwndConsole = hwndConsole;
    pEntry->bConsoleEnabled = TRUE;
    pEntry->ScreenSize.X = 80;
    pEntry->awAttrColor[0] = COMMON_LVB_UNDERSCORE | 0x7;
    pEntry->awAttrColor[1] = BACKGROUND_BLUE | _FOREGROUND_WHITE;
    pEntry->awAttrColor[2] = COMMON_LVB_UNDERSCORE | _FOREGROUND_WHITE;
    pEntry->awAttrColor[3] = COMMON_LVB_UNDERSCORE | _BACKGROUND_WHITE | FOREGROUND_BLUE;
    pEntry->awAttrColor[4] = COMMON_LVB_UNDERSCORE | FOREGROUND_RED;
    pEntry->awAttrColor[5] = COMMON_LVB_UNDERSCORE | FOREGROUND_RED;
    pEntry->awAttrColor[6] = COMMON_LVB_UNDERSCORE | FOREGROUND_RED;
    pEntry->awAttrColor[7] = COMMON_LVB_UNDERSCORE | FOREGROUND_RED;
    IntGetImeLayoutText(pEntry);
    TRACE("ConIme_InitEntry --> %p\n", pEntry);
    return TRUE;
}

Referenced by ConIme_OnInit().

ConIme_InitInstance()

BOOL ConIme_InitInstance

(

HINSTANCE

hInstance

)

Initialize Console IME instance.

Definition at line 3206 of file conime.c.

{
    BOOL bIsConImeOnSystemProcessEnabled = IntIsConImeOnSystemProcessEnabled();
    if (!bIsConImeOnSystemProcessEnabled && IntIsLogOnSession())
        return FALSE;
 
    const UINT cEntries = 10;
    g_ppEntries = LocalAlloc(LPTR, cEntries * sizeof(PCONENTRY));
    if (!g_ppEntries)
        return FALSE;
 
    InitializeCriticalSection(&g_csLock);
 
    g_cEntries = cEntries;
 
    // Open a startup synchronization event
    HANDLE hStartUpEvent = OpenEventW(EVENT_MODIFY_STATE, FALSE, L"ConsoleIME_StartUp_Event");
    if (!hStartUpEvent)
    {
        DeleteCriticalSection(&g_csLock);
        return FALSE;
    }
 
    INT x, y, cx, cy, cxScreen, cyMenu;
    HWND hWnd;
 
    // Register window class
    WNDCLASSEXW wc = { sizeof(wc) };
    wc.lpfnWndProc   = ConIme_WndProc;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_MAINICON));
    wc.hCursor       = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.lpszClassName = L"ConsoleIMEClass";
    ATOM atom = RegisterClassExW(&wc);
    if (!atom)
        goto Cleanup1;
 
    // Create main window
    cxScreen = GetSystemMetrics(SM_CXSCREEN);
    cyMenu = GetSystemMetrics(SM_CYMENU);
    x = cxScreen - (cxScreen / 3);
    y = cyMenu;
    cx = cxScreen / 3;
    cy = 10 * cyMenu;
    hWnd = CreateWindowW(L"ConsoleIMEClass", L"", WS_OVERLAPPEDWINDOW,
                         x, y, cx, cy, NULL, NULL, hInstance, NULL);
    if (!hWnd)
        goto Cleanup2;
 
    // Console IME registration and threaded input synchronization
    if (RegisterConsoleIME(hWnd, &g_dwAttachToThreadId) &&
        AttachThreadInput(GetCurrentThreadId(), g_dwAttachToThreadId, TRUE))
    {
        SetEvent(hStartUpEvent);
        CloseHandle(hStartUpEvent);
        return TRUE; // Success
    }
 
    if (g_dwAttachToThreadId)
        UnregisterConsoleIME();
 
    if (hWnd)
        DestroyWindow(hWnd);
 
Cleanup2:
    if (atom)
        UnregisterClassW(L"ConsoleIMEClass", hInstance);
 
Cleanup1:
    if (hStartUpEvent)
    {
        SetEvent(hStartUpEvent); // Set to release the waiting side even if it fails
        CloseHandle(hStartUpEvent);
    }
 
    DeleteCriticalSection(&g_csLock);
    return FALSE; // Failed
}

Referenced by wWinMain().

ConIme_OnChangeKeyboard()

void ConIme_OnChangeKeyboard	(	HWND	hwnd,
		HANDLE	hConsole,
		HKL	hNewKL
	)

WM_USER_CHANGEKEYBOARD.

Definition at line 2941 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry || !pEntry->pKLInfo)
        return;
 
    HKL hOldKL = pEntry->hKL;
 
    if (IS_IME_HKL(hOldKL)) // IME HKL?
    {
        INT iKL;
        PKLINFO pKLInfo = pEntry->pKLInfo;
 
        for (iKL = 0; iKL < pEntry->cKLs; ++iKL)
        {
            if (!pKLInfo[iKL].hKL || pKLInfo[iKL].hKL == hOldKL)
                break;
        }
 
        if (iKL >= pEntry->cKLs)
        {
            INT newCount = pEntry->cKLs + 1;
            PKLINFO phNewKLs = LocalAlloc(LPTR, newCount * sizeof(KLINFO));
            if (!phNewKLs)
                return;
 
            CopyMemory(phNewKLs, pEntry->pKLInfo, pEntry->cKLs * sizeof(KLINFO));
            LocalFree(pEntry->pKLInfo);
            pEntry->pKLInfo = phNewKLs;
            pEntry->cKLs = newCount;
        }
 
        pEntry->pKLInfo[iKL].hKL = hOldKL;
 
        DWORD dwConversion = pEntry->dwConversion | (pEntry->bOpened ? _IME_CMODE_OPEN : 0);
        pEntry->pKLInfo[iKL].dwConversion = dwConversion;
    }
 
    ActivateKeyboardLayout(hNewKL, 0);
    pEntry->hKL = hNewKL;
 
    IntGetImeLayoutText(pEntry);
    ConIme_SendImeStatus(hwnd);
    pEntry->dwImeProp = ImmGetProperty(pEntry->hKL, IGP_PROPERTY);
 
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return;
 
    COPYDATASTRUCT CopyData;
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    CopyData.cbData = sizeof(*pDisplay);
    CopyData.lpData = pDisplay;
 
    if (IS_IME_HKL(hNewKL)) // IME HKL?
    {
        for (INT iKL = 0; iKL < pEntry->cKLs; ++iKL)
        {
            if (pEntry->pKLInfo[iKL].hKL != hNewKL)
                continue;
 
            IntSetImeState(hwnd, hConsole, pEntry->pKLInfo[iKL].dwConversion);
            ConIme_SendImeStatus(hwnd);
 
            if (IntFillImeDisplay(pEntry, pDisplay))
                IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
            break;
        }
    }
    else // Non-IME HKL?
    {
        IntSetImeState(hwnd, hConsole, pEntry->dwConversion & ~_IME_CMODE_OPEN);
        pDisplay->uCharInfoLen = 0;
        pDisplay->bFlag = TRUE;
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
    }
 
    LocalFree(pDisplay);
}

Referenced by ConIme_OnUser().

ConIme_OnCreate()

BOOL ConIme_OnCreate ( HWND  hwnd )

inline

WM_CREATE.

Definition at line 1253 of file conime.c.

{
    HIMC hIMC = ImmGetContext(hwnd);
    if (hIMC)
    {
        g_hOldIMC = hIMC;
        ImmReleaseContext(hwnd, hIMC);
    }
    return TRUE;
}

Referenced by ConIme_WndProc().

ConIme_OnDeactivate()

BOOL ConIme_OnDeactivate	(	HWND	hwnd,
		HANDLE	hConsole
	)

WM_USER_DEACTIVATE.

Definition at line 991 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return FALSE;
 
    if (g_bDisabled)
    {
        g_bDisabled = FALSE;
    }
    else
    {
        ImmSetActiveContextConsoleIME(hwnd, FALSE);
        ImmAssociateContext(hwnd, g_hOldIMC);
    }
 
    return TRUE;
}

Referenced by ConIme_OnUser().

ConIme_OnDisable()

void ConIme_OnDisable

(

void

)

WM_ENABLE.

Definition at line 2900 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (pEntry && pEntry->hConsole)
    {
        pEntry->bConsoleEnabled = FALSE;
        EnableWindow(pEntry->hwndConsole, FALSE);
        g_bDisabled = TRUE;
    }
}

Referenced by ConIme_WndProc().

ConIme_OnEnable()

void ConIme_OnEnable

(

void

)

WM_ENABLE.

Definition at line 2878 of file conime.c.

{
    EnterCriticalSection(&g_csLock);
    for (UINT iEntry = 1; iEntry < g_cEntries; ++iEntry)
    {
        PCONENTRY pEntry = g_ppEntries[iEntry];
        if (pEntry && pEntry->hConsole)
        {
            // Enable the console window and bring it to the front
            if (!pEntry->bConsoleEnabled && !IsWindowEnabled(pEntry->hwndConsole))
            {
                EnableWindow(pEntry->hwndConsole, TRUE);
                pEntry->bConsoleEnabled = TRUE;
                if (!pEntry->bWndEnabled)
                    SetForegroundWindow(pEntry->hwndConsole);
            }
        }
    }
    LeaveCriticalSection(&g_csLock);
}

Referenced by ConIme_WndProc().

ConIme_OnEnd()

void ConIme_OnEnd	(	HWND	hwnd,
		UINT	uMsg
	)

Terminate Console IME.

Definition at line 286 of file conime.c.

{
    ImmAssociateContext(hwnd, g_hOldIMC);
 
    IntFreeConsoleEntries();
 
    if (g_dwAttachToThreadId && (uMsg != WM_ENDSESSION || !g_bIsLogOnSession))
    {
        AttachThreadInput(GetCurrentThreadId(), g_dwAttachToThreadId, FALSE);
        UnregisterConsoleIME();
        g_dwAttachToThreadId = 0;
    }
}

Referenced by ConIme_WndProc().

ConIme_OnGo()

BOOL ConIme_OnGo	(	HWND	hwnd,
		HANDLE	hConsole,
		HKL	hKL,
		INT	iDirection
	)

Handles keyboard layout switch requests.

Definition at line 1022 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return FALSE; // Deny
 
    LANGID wTargetLang = 0;
    switch (pEntry->nOutputCodePage)
    {
        case CP_CHINESE_SIMPLIFIED:
            wTargetLang = LANGID_CHINESE_SIMPLIFIED;
            break;
        case CP_CHINESE_TRADITIONAL:
            wTargetLang = LANGID_CHINESE_TRADITIONAL;
            break;
        case CP_JAPANESE:
            wTargetLang = LANGID_JAPANESE;
            break;
        case CP_KOREAN:
            wTargetLang = LANGID_KOREAN;
            break;
        default:
            return TRUE; // Allow
    }
 
    if (!IS_IME_HKL(hKL) || LOWORD(hKL) == wTargetLang)
        return TRUE; // Allow
 
    if (iDirection == 0)
        return FALSE; // Deny
 
    // Get keyboard list
    INT cKLs = GetKeyboardLayoutList(0, NULL);
    if (cKLs <= 0)
        return FALSE; // Deny
    HKL* phKLs = LocalAlloc(LPTR, cKLs * sizeof(HKL));
    if (!phKLs)
        return FALSE; // Deny
    GetKeyboardLayoutList(cKLs, phKLs);
 
    // Get current keyboard
    INT iCurrent = 0;
    for (; iCurrent < cKLs; ++iCurrent)
    {
        if (pEntry->hKL == phKLs[iCurrent])
            break;
    }
 
    if (iCurrent < cKLs)
    {
        for (INT iAttempt = 0, iNext = iCurrent; iAttempt < cKLs; ++iAttempt)
        {
            iNext += iDirection;
 
            if (iNext < 0)
                iNext = cKLs - 1;
            else if (iNext >= cKLs)
                iNext = 0;
 
            HKL hKL = phKLs[iNext];
            LANGID wLangId = LOWORD(hKL);
            if (!IS_IME_HKL(hKL) || wLangId == wTargetLang)
            {
                PostMessageW(pEntry->hwndConsole, WM_USER + 0x0F, (WPARAM)hKL, 0);
                break;
            }
        }
    }
 
    LocalFree(phKLs);
    return FALSE; // Deny
}

Referenced by ConIme_OnUser().

ConIme_OnImeComposition()

void ConIme_OnImeComposition	(	HWND	hwnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

WM_IME_COMPOSITION.

Definition at line 1743 of file conime.c.

{
    TRACE("WM_IME_COMPOSITION\n");
    if (!lParam)
        IntDoImeComp(hwnd, 0, wParam);
    if (lParam & GCS_RESULTSTR)
        IntDoImeComp(hwnd, (DWORD)(lParam & GCS_RESULTSTR), wParam);
    if (lParam & GCS_COMPSTR)
        IntDoImeComp(hwnd, (DWORD)(lParam & (GCS_COMPATTR | GCS_COMPSTR)), wParam);
    if (lParam & _GCS_SINGLECHAR)
        IntDoImeComp(hwnd, (DWORD)(lParam & (_GCS_SINGLECHAR | GCS_COMPATTR)), wParam);
    if (lParam & 0x4000)
        IntDoImeComp(hwnd, (DWORD)(lParam & 0x4010), wParam);
}

Referenced by ConIme_WndProc().

ConIme_OnImeEndComposition()

void ConIme_OnImeEndComposition

(

HWND

hWnd

)

WM_IME_ENDCOMPOSITION.

Definition at line 2921 of file conime.c.

{
    TRACE("WM_IME_ENDCOMPOSITION\n");
 
    // Find the currently active console entry
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return;
 
    pEntry->bInComposition = FALSE;
 
    // Free composition string info
    if (pEntry->pCompStr)
    {
        LocalFree(pEntry->pCompStr);
        pEntry->pCompStr = NULL;
    }
}

Referenced by ConIme_WndProc().

ConIme_OnImeNotify()

BOOL ConIme_OnImeNotify	(	HWND	hWnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

WM_IME_NOTIFY.

Definition at line 2780 of file conime.c.

{
    switch (wParam)
    {
        case IMN_OPENSTATUSWINDOW:
            TRACE("IMN_OPENSTATUSWINDOW\n");
            ConIme_SendImeStatus(hWnd);
            break;
        case IMN_OPENCANDIDATE:
            TRACE("IMN_OPENCANDIDATE\n");
            ConIme_OnNotifyOpenCandidate(hWnd, lParam, TRUE);
            break;
        case IMN_CHANGECANDIDATE:
            TRACE("IMN_CHANGECANDIDATE\n");
            ConIme_OnNotifyChangeCandidate(hWnd, lParam);
            break;
        case IMN_CLOSECANDIDATE:
            TRACE("IMN_CLOSECANDIDATE\n");
            ConIme_OnNotifyCloseCandidate(hWnd, (DWORD)lParam);
            break;
        case IMN_SETCONVERSIONMODE:
            TRACE("IMN_SETCONVERSIONMODE\n");
            ConIme_SendImeStatus(hWnd);
            return FALSE; // Return FALSE to allow default processing to continue
        case IMN_SETOPENSTATUS:
            TRACE("IMN_SETOPENSTATUS\n");
            ConIme_OnNotifySetOpenStatus(hWnd);
            return FALSE;
        case IMN_GUIDELINE:
            TRACE("IMN_GUIDELINE\n");
            ConIme_OnNotifyGuideLine(hWnd);
            break;
        default:
            return FALSE;
    }
 
    return TRUE;
}

Referenced by ConIme_WndProc().

ConIme_OnImeStartComposition()

void ConIme_OnImeStartComposition

(

HWND

hwnd

)

WM_IME_STARTCOMPOSITION.

Definition at line 2912 of file conime.c.

{
    TRACE("WM_IME_STARTCOMPOSITION\n");
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (pEntry)
        pEntry->bInComposition = TRUE;
}

Referenced by ConIme_WndProc().

ConIme_OnImeSystem()

BOOL ConIme_OnImeSystem	(	HWND	hwnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

WM_IME_SYSTEM.

Definition at line 2653 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    COPYDATASTRUCT CopyData;
    CopyData.lpData = &wParam;
    CopyData.dwData = MAGIC_SEND_IMESYSTEM;
    CopyData.cbData = sizeof(wParam);
    IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
    return TRUE;
}

Referenced by ConIme_WndProc().

ConIme_OnInit()

BOOL ConIme_OnInit	(	HWND	hwnd,
		HANDLE	hConsole,
		HWND	hwndConsole
	)

WM_USER_INIT.

Definition at line 1231 of file conime.c.

{
    if (IntFindConsoleEntry(hConsole))
        return TRUE;
 
    BOOL ret;
    EnterCriticalSection(&g_csLock);
    if (ConIme_InitEntry(hwnd, hConsole, hwndConsole))
    {
        ConIme_OnNotifySetOpenStatus(hwndConsole);
        ret = TRUE;
    }
    else
    {
        ret = FALSE;
    }
 
    LeaveCriticalSection(&g_csLock);
    return ret;
}

Referenced by ConIme_OnUser().

ConIme_OnInputLangChange()

BOOL ConIme_OnInputLangChange	(	HWND	hwnd,
		WPARAM	wParam,
		HKL	hKL
	)

Definition at line 1131 of file conime.c.

{
    TRACE("(%p, %p, %p)\n", hwnd, wParam, hKL);
 
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    pEntry->hKL = hKL;
    ActivateKeyboardLayout(hKL, 0);
    IntGetImeLayoutText(pEntry);
    ConIme_SendImeStatus(hwnd);
    return TRUE;
}

Referenced by ConIme_WndProc().

ConIme_OnInputLangChangeRequest()

LRESULT ConIme_OnInputLangChangeRequest	(	HWND	hWnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

WM_INPUTLANGCHANGEREQUEST.

Definition at line 3069 of file conime.c.

{
    TRACE("(%p, %p, %p)\n", hWnd, wParam, lParam);
 
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    // Forward messages to the console window
    PostMessageW(pEntry->hwndConsole, WM_INPUTLANGCHANGEREQUEST, wParam, lParam);
    return TRUE;
}

Referenced by ConIme_WndProc().

ConIme_OnKeyChar()

BOOL ConIme_OnKeyChar	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2819 of file conime.c.

{
    TRACE("(%p, %u, %p, %p)\n", hwnd, uMsg, wParam, lParam);
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (pEntry)
        return PostMessageW(pEntry->hwndConsole, uMsg + WM_ROUTE, wParam, lParam);
    return FALSE;
}

Referenced by ConIme_OnRoute(), and ConIme_WndProc().

ConIme_OnNotifyChangeCandidate()

BOOL ConIme_OnNotifyChangeCandidate ( HWND  hwnd, LPARAM  lParam  )

inline

Definition at line 2532 of file conime.c.

{
    return ConIme_OnNotifyOpenCandidate(hwnd, lParam, FALSE);
}

Referenced by ConIme_OnImeNotify().

ConIme_OnNotifyCloseCandidate()

BOOL ConIme_OnNotifyCloseCandidate	(	HWND	hwnd,
		DWORD	dwCandidates
	)

IMN_CLOSECANDIDATE.

Definition at line 2745 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    HIMC hIMC = ImmGetContext(hwnd);
    if (!hIMC)
        return FALSE;
 
    pEntry->bHasAnyCand = FALSE;
 
    LANGID wLang = LOWORD(pEntry->hKL);
    switch (wLang)
    {
        case LANGID_CHINESE_SIMPLIFIED:
            IntCloseCandsCHS(hwnd, hIMC, pEntry, dwCandidates);
            break;
        case LANGID_CHINESE_TRADITIONAL:
            IntCloseCandsCHT(hwnd, hIMC, pEntry, dwCandidates);
            break;
        case LANGID_JAPANESE:
        case LANGID_KOREAN:
            IntCloseCandsJPNorKOR(hwnd, hIMC, pEntry, dwCandidates);
            break;
        default:
            ImmReleaseContext(hwnd, hIMC);
            return FALSE;
    }
 
    ImmReleaseContext(hwnd, hIMC);
    return TRUE;
}

Referenced by ConIme_OnImeNotify().

ConIme_OnNotifyGuideLine()

BOOL ConIme_OnNotifyGuideLine

(

HWND

hWnd

)

Handles guideline notifications (error messages, etc.) from IME.

Definition at line 2538 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    HIMC hIMC = ImmGetContext(hWnd);
    if (!hIMC)
        return FALSE;
 
    COPYDATASTRUCT CopyData;
    CopyData.dwData = MAGIC_SEND_GUIDELINE;
 
    BOOL ret = FALSE;
    size_t cbGuideLine = ImmGetGuideLineW(hIMC, GGL_STRING, NULL, 0);
    if (!cbGuideLine)
    {
        CopyData.cbData = 0;
        CopyData.lpData = NULL;
        IntSendDataToConsole(pEntry->hwndConsole, hWnd, &CopyData);
        ret = TRUE;
    }
    else
    {
        size_t cbAlloc = cbGuideLine + sizeof(UNICODE_NULL);
        PWSTR pszGuideLine = LocalAlloc(LPTR, cbAlloc);
        if (pszGuideLine)
        {
            ImmGetGuideLineW(hIMC, GGL_STRING, pszGuideLine, cbGuideLine);
 
            CopyData.cbData = cbAlloc;
            CopyData.lpData = pszGuideLine;
            IntSendDataToConsole(pEntry->hwndConsole, hWnd, &CopyData);
 
            LocalFree(pszGuideLine);
            ret = TRUE;
        }
    }
 
    ImmReleaseContext(hWnd, hIMC);
    return ret;
}

Referenced by ConIme_OnImeNotify().

ConIme_OnNotifyOpenCandidate()

BOOL ConIme_OnNotifyOpenCandidate	(	HWND	hwnd,
		LPARAM	lParam,
		BOOL	bOpen
	)

When the conversion candidate window opens, invoke the language-specific candidate.

Definition at line 2495 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    if (pEntry->bSkipPageMsg)
        return TRUE;
 
    HIMC hIMC = ImmGetContext(hwnd);
    if (!hIMC)
        return FALSE;
 
    pEntry->bHasAnyCand = TRUE;
 
    LANGID wLangId = LOWORD(pEntry->hKL);
    switch (wLangId)
    {
        case LANGID_CHINESE_SIMPLIFIED:
            IntSendCandListCHS(hwnd, hIMC, pEntry, (DWORD)lParam, bOpen);
            break;
        case LANGID_CHINESE_TRADITIONAL:
            IntSendCandListCHT(hwnd, hIMC, pEntry, (DWORD)lParam, bOpen);
            break;
        case LANGID_JAPANESE:
        case LANGID_KOREAN:
            IntSendCandListJPNorKOR(hwnd, hIMC, pEntry, (DWORD)lParam, bOpen);
            break;
        default:
            ImmReleaseContext(hwnd, hIMC);
            return FALSE;
    }
 
    ImmReleaseContext(hwnd, hIMC);
    return TRUE;
}

Referenced by ConIme_OnImeNotify(), and ConIme_OnNotifyChangeCandidate().

ConIme_OnNotifySetOpenStatus()

BOOL ConIme_OnNotifySetOpenStatus

(

HWND

hwndTarget

)

IMN_SETOPENSTATUS.

Definition at line 848 of file conime.c.

{
    // Find active console entries
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    // Get IME context
    HIMC hIMC = ImmGetContext(hwndTarget);
    if (!hIMC)
        return FALSE;
 
    // Update IME state in an entry
    pEntry->bOpened = IntIsImeOpen(hIMC, pEntry);
    ImmGetConversionStatus(hIMC, &pEntry->dwConversion, &pEntry->dwSentence);
 
    // Send status to console according to conditions
    BOOL bSuccess = TRUE;
    if (pEntry->ScreenSize.X)
    {
        PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
        if (pDisplay)
        {
            COPYDATASTRUCT CopyData;
            CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
            CopyData.cbData = sizeof(*pDisplay);
            CopyData.lpData = pDisplay;
 
            if (IntFillImeDisplay(pEntry, pDisplay))
                IntSendDataToConsole(pEntry->hwndConsole, hwndTarget, &CopyData);
 
            LocalFree(pDisplay);
        }
        else
        {
            bSuccess = FALSE;
        }
    }
 
    ImmReleaseContext(hwndTarget, hIMC);
    return bSuccess;
}

Referenced by ConIme_OnImeNotify(), ConIme_OnInit(), and ConIme_OnSwitchIme().

ConIme_OnRoute()

LRESULT ConIme_OnRoute	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

WM_ROUTE_...

Definition at line 2829 of file conime.c.

{
    TRACE("(%p, %u, %p, %p)\n", hwnd, uMsg, wParam, lParam);
 
    WPARAM wch = wParam;
    if (HIWORD(wParam))
    {
        if (uMsg == WM_ROUTE_KEYDOWN || uMsg == WM_ROUTE_KEYUP ||
            uMsg == WM_ROUTE_SYSKEYDOWN || uMsg == WM_ROUTE_SYSKEYUP)
        {
            wch = UNICODE_NULL;
        }
        else if (HIWORD(wParam) <= 0xFF)
        {
            wch = HIWORD(wParam);
        }
        else
        {
            WCHAR wsz[2] = { HIWORD(wParam), 0 };
            CHAR ach;
            WideCharToMultiByte(CP_ACP, 0, wsz, 1, &ach, 1, NULL, NULL);
            wch = ach;
        }
    }
 
    UINT vkey, uKeyMsg = ((HIWORD(lParam) & KF_UP) ? WM_KEYUP : WM_KEYDOWN);
    LRESULT ret = ImmCallImeConsoleIME(hwnd, uKeyMsg, wParam, lParam, &vkey);
 
    if (!(ret & IPHK_HOTKEY))
    {
        if (ret & IPHK_PROCESSBYIME)
            return ImmTranslateMessage(hwnd, uKeyMsg, wParam, lParam);
        else if ((ret & IPHK_CHECKCTRL) || uMsg == WM_ROUTE_CHAR || uMsg == WM_ROUTE_SYSCHAR)
            return ConIme_OnKeyChar(hwnd, uMsg - WM_ROUTE, wch, lParam);
        else
            return ConIme_OnKeyChar(hwnd, uMsg - WM_ROUTE, (UINT)wParam, lParam);
    }
 
    return ret;
}

Referenced by ConIme_WndProc().

ConIme_OnSwitchIme()

BOOL ConIme_OnSwitchIme	(	HWND	hwnd,
		HANDLE	hConsole,
		HKL	hKL
	)

WM_USER_SWITCHIME.

Definition at line 959 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return FALSE;
 
    if (g_bDisabled)
        g_bDisabled = FALSE;
 
    HKL hOldKL = pEntry->hKL;
    pEntry->hKL = hKL;
    ActivateKeyboardLayout(hKL, 0);
 
    ImmAssociateContext(hwnd, pEntry->hOldIMC);
 
    if (!hOldKL)
    {
        IntGetImeLayoutText(pEntry);
        pEntry->dwImeProp = ImmGetProperty(pEntry->hKL, IGP_PROPERTY);
    }
 
    ImmSetActiveContextConsoleIME(hwnd, TRUE);
    IntSetCurrentConsole(hConsole);
    ConIme_OnNotifySetOpenStatus(hwnd);
 
    if (pEntry->pCompStr)
        IntSendConversionStatus(hwnd);
 
    return TRUE;
}

Referenced by ConIme_OnUser().

ConIme_OnUnInit()

BOOL ConIme_OnUnInit	(	HWND	hwnd,
		HANDLE	hConsole
	)

WM_USER_UNINIT.

Definition at line 1217 of file conime.c.

{
    EnterCriticalSection(&g_csLock);
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    BOOL ret;
    if (pEntry)
        ret = ConIme_UnInitEntry(hwnd, pEntry);
    else
        ret = FALSE;
    LeaveCriticalSection(&g_csLock);
    return ret;
}

Referenced by ConIme_OnUser().

ConIme_OnUser()

LRESULT ConIme_OnUser	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

(WM_USER + ...)

Definition at line 3025 of file conime.c.

{
    TRACE("(%p, %u, %p, %p)\n", hWnd, uMsg, wParam, lParam);
    switch (uMsg)
    {
        case WM_USER_INIT:
            return ConIme_OnInit(hWnd, (HANDLE)wParam, (HWND)lParam);
        case WM_USER_UNINIT:
            return ConIme_OnUnInit(hWnd, (HANDLE)wParam);
        case WM_USER_SWITCHIME:
            return ConIme_OnSwitchIme(hWnd, (HANDLE)wParam, (HKL)lParam);
        case WM_USER_DEACTIVATE:
            return ConIme_OnDeactivate(hWnd, (HANDLE)wParam);
        case WM_USER_SIMHOTKEY:
            return ConIme_SimulateHotKey(hWnd, wParam, lParam);
        case WM_USER_GETIMESTATE:
            return IntGetImeState(hWnd, (HANDLE)wParam);
        case WM_USER_SETIMESTATE:
            return IntSetImeState(hWnd, (HANDLE)wParam, (DWORD)lParam);
        case WM_USER_SETSCREENSIZE:
        {
            COORD coord = { LOWORD(lParam), HIWORD(lParam) };
            return ConIme_SetScreenSize(hWnd, (HANDLE)wParam, coord);
        }
        case WM_USER_SENDIMESTATUS:
            return ConIme_SendImeStatus(hWnd);
        case WM_USER_CHANGEKEYBOARD:
            ConIme_OnChangeKeyboard(hWnd, (HANDLE)wParam, (HKL)lParam);
            return TRUE;
        case WM_USER_SETCODEPAGE:
            return ConIme_SetCodePage(hWnd, (HANDLE)wParam, LOWORD(lParam), HIWORD(lParam));
        case WM_USER_GO:
            return ConIme_OnGo(hWnd, (HANDLE)wParam, (HKL)lParam, 0);
        case WM_USER_GONEXT:
            return ConIme_OnGo(hWnd, (HANDLE)wParam, (HKL)lParam, +1);
        case WM_USER_GOBACK:
            return ConIme_OnGo(hWnd, (HANDLE)wParam, (HKL)lParam, -1);
        default:
            ERR("Unknown uMsg %u\n", uMsg);
            return FALSE;
    }
}

Referenced by ConIme_WndProc().

ConIme_SendImeStatus()

BOOL ConIme_SendImeStatus

(

HWND

hWnd

)

WM_USER_SENDIMESTATUS.

Definition at line 1096 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return FALSE;
 
    HIMC hIMC = ImmGetContext(hWnd);
    if (!hIMC)
        return FALSE;
 
    BOOL ret;
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (pDisplay)
    {
        ImmGetConversionStatus(hIMC, &pEntry->dwConversion, &pEntry->dwSentence);
 
        COPYDATASTRUCT CopyData;
        CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
        CopyData.cbData = sizeof(*pDisplay);
        CopyData.lpData = pDisplay;
        if (IntFillImeDisplay(pEntry, pDisplay))
            IntSendDataToConsole(pEntry->hwndConsole, hWnd, &CopyData);
 
        LocalFree(pDisplay);
        ret = TRUE;
    }
    else
    {
        ret = FALSE;
    }
 
    ImmReleaseContext(hWnd, hIMC);
    return ret;
}

Referenced by ConIme_OnChangeKeyboard(), ConIme_OnImeNotify(), ConIme_OnInputLangChange(), and ConIme_OnUser().

ConIme_SetCodePage()

BOOL ConIme_SetCodePage	(	HWND	hwnd,
		HANDLE	hConsole,
		BOOL	bOutput,
		WORD	wCodePage
	)

WM_USER_SETCODEPAGE.

Definition at line 2638 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return FALSE;
 
    if (bOutput)
        pEntry->nOutputCodePage = wCodePage;
    else
        pEntry->nCodePage = wCodePage;
 
    return TRUE;
}

Referenced by ConIme_OnUser().

ConIme_SetScreenSize()

BOOL ConIme_SetScreenSize	(	HWND	hwnd,
		HANDLE	hConsole,
		COORD	ScreenSize
	)

WM_USER_SETSCREENSIZE.

Definition at line 1011 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return FALSE;
 
    pEntry->ScreenSize = ScreenSize;
    return TRUE;
}

Referenced by ConIme_OnUser().

ConIme_SimulateHotKey()

BOOL ConIme_SimulateHotKey	(	HWND	hwnd,
		WPARAM	wParam,
		LPARAM	lParam
	)

WM_USER_SIMHOTKEY.

Definition at line 2871 of file conime.c.

{
    TRACE("WM_USER_SIMHOTKEY\n");
    return ImmSimulateHotKey(hwnd, (DWORD)lParam);
}

Referenced by ConIme_OnUser().

ConIme_UnInitEntry()

BOOL ConIme_UnInitEntry	(	HWND	hwnd,
		PCONENTRY	pEntry
	)

Frees the resources associated with the console entry.

Definition at line 321 of file conime.c.

{
    TRACE("ConIme_UnInitEntry: %p\n", pEntry);
 
    if (!pEntry->bConsoleEnabled)
    {
        pEntry->bWndEnabled = TRUE;
        return TRUE;
    }
 
    pEntry->hConsole = NULL;
    pEntry->ScreenSize.X = 0;
    pEntry->nCodePage = pEntry->nOutputCodePage = CP_ACP;
    pEntry->hKL = NULL;
    ImmDestroyContext(pEntry->hNewIMC);
 
    // Free composition string info
    if (pEntry->pCompStr)
    {
        LocalFree(pEntry->pCompStr);
        pEntry->pCompStr = NULL;
    }
 
    // Free candidate list
    for (UINT iList = 0; iList < _countof(pEntry->apCandList); ++iList)
    {
        if (!pEntry->apCandList[iList])
            continue;
        LocalFree(pEntry->apCandList[iList]);
        pEntry->apCandList[iList] = NULL;
    }
 
    // Free candidate separators
    if (pEntry->pdwCandPageStart)
    {
        LocalFree(pEntry->pdwCandPageStart);
        pEntry->pdwCandPageStart = NULL;
    }
 
    // Free keyboard list info
    if (pEntry->pKLInfo)
    {
        LocalFree(pEntry->pKLInfo);
        pEntry->pKLInfo = NULL;
    }
 
    pEntry->bConsoleEnabled = FALSE;
    pEntry->bWndEnabled = FALSE;
    return TRUE;
}

Referenced by ConIme_InitEntry(), and ConIme_OnUnInit().

ConIme_WndProc()

LRESULT CALLBACK ConIme_WndProc	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

The main window procedure for the Console IME.

Definition at line 3084 of file conime.c.

{
    switch (uMsg)
    {
        case WM_CREATE:
            return (ConIme_OnCreate(hWnd) ? 0 : -1);
 
        case WM_DESTROY:
            ConIme_OnEnd(hWnd, uMsg);
            PostQuitMessage(0);
            break;
 
        case WM_CLOSE:
            DestroyWindow(hWnd);
            break;
 
        case WM_QUERYENDSESSION:
            return TRUE;
 
        case WM_ENDSESSION:
            ConIme_OnEnd(hWnd, uMsg);
            break;
 
        case WM_INPUTLANGCHANGE:
            ConIme_OnInputLangChange(hWnd, wParam, (HKL)lParam);
            return TRUE;
 
        case WM_INPUTLANGCHANGEREQUEST:
            if (ConIme_OnInputLangChangeRequest(hWnd, wParam, lParam))
                return TRUE;
            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 
        case WM_ENABLE:
            if (wParam) // Enabled?
                ConIme_OnEnable();
            else
                ConIme_OnDisable();
            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 
        case WM_IME_STARTCOMPOSITION:
            ConIme_OnImeStartComposition(hWnd);
            return TRUE;
 
        case WM_IME_ENDCOMPOSITION:
            ConIme_OnImeEndComposition(hWnd);
            return TRUE;
 
        case WM_IME_COMPOSITION:
            ConIme_OnImeComposition(hWnd, wParam, lParam);
            return TRUE;
 
        case WM_KEYDOWN:
        case WM_KEYUP:
        case WM_CHAR:
        case WM_DEADCHAR:
        case WM_SYSKEYDOWN:
        case WM_SYSKEYUP:
        case WM_SYSCHAR:
        case WM_SYSDEADCHAR:
            ConIme_OnKeyChar(hWnd, uMsg, wParam, lParam);
            return TRUE;
 
        case WM_IME_SETCONTEXT:
            return DefWindowProcW(hWnd, uMsg, wParam, (lParam & ~ISC_SHOWUIALL));
 
        case WM_IME_NOTIFY:
            if (!ConIme_OnImeNotify(hWnd, wParam, lParam))
                return DefWindowProcW(hWnd, uMsg, wParam, lParam);
            return TRUE;
 
        case WM_IME_COMPOSITIONFULL:
            return TRUE;
 
        case WM_IME_SYSTEM:
            if (wParam == IMS_CONSOLEIME_1A || wParam == IMS_CONSOLEIME_1B)
            {
                ConIme_OnImeSystem(hWnd, wParam, lParam);
                return TRUE;
            }
            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
 
        default:
        {
            if (WM_USER_INIT <= uMsg && uMsg <= WM_USER_GOBACK)
                return ConIme_OnUser(hWnd, uMsg, wParam, lParam);
 
            if (WM_ROUTE_KEYDOWN <= uMsg && uMsg <= WM_ROUTE_SYSDEADCHAR)
            {
                ConIme_OnRoute(hWnd, uMsg, wParam, lParam);
                return TRUE;
            }
 
            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
        }
    }
 
    return 0;
}

Referenced by ConIme_InitInstance().

IntCloseCandsCHS()

BOOL IntCloseCandsCHS	(	HWND	hwnd,
		HIMC	hIMC,
		PCONENTRY	pEntry,
		DWORD	dwCandidates
	)

Sends the IME candidate list for Simplified Chinese (CHS).

Definition at line 2716 of file conime.c.

{
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return FALSE;
 
    PCANDIDATELIST* apCandList = pEntry->apCandList;
    for (DWORD iCand = 0; iCand < MAX_CANDLIST; ++iCand)
    {
        if ((dwCandidates & (1 << iCand)) && apCandList[iCand])
        {
            LocalFree(apCandList[iCand]);
            apCandList[iCand] = NULL;
            pEntry->acbCandList[iCand] = 0;
        }
    }
 
    COPYDATASTRUCT CopyData;
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    CopyData.cbData = sizeof(*pDisplay);
    CopyData.lpData = pDisplay;
    if (IntFillImeDisplayCHS(pEntry, pDisplay))
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
    LocalFree(pDisplay);
    return TRUE;
}

Referenced by ConIme_OnNotifyCloseCandidate().

IntCloseCandsCHT()

BOOL IntCloseCandsCHT	(	HWND	hwnd,
		HIMC	hIMC,
		PCONENTRY	pEntry,
		DWORD	dwCandidates
	)

Sends candidate list for Traditional Chinese (CHT).

Definition at line 2668 of file conime.c.

{
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return FALSE;
 
    PCANDIDATELIST* apCandList = pEntry->apCandList;
    for (DWORD iCand = 0; iCand < MAX_CANDLIST; ++iCand)
    {
        if ((dwCandidates & (1 << iCand)) && apCandList[iCand])
        {
            LocalFree(apCandList[iCand]);
            apCandList[iCand] = NULL;
            pEntry->acbCandList[iCand] = 0;
        }
    }
 
    COPYDATASTRUCT CopyData;
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    CopyData.cbData = sizeof(*pDisplay);
    CopyData.lpData = pDisplay;
    if (IntFillImeDisplayCHT(pEntry, pDisplay))
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
    LocalFree(pDisplay);
    return TRUE;
}

Referenced by ConIme_OnNotifyCloseCandidate().

IntCloseCandsJPNorKOR()

BOOL IntCloseCandsJPNorKOR	(	HWND	hwnd,
		HIMC	hIMC,
		PCONENTRY	pEntry,
		DWORD	dwCandidates
	)

Sends the IME candidate list for Japanese/Korean.

Definition at line 2697 of file conime.c.

{
    PCANDIDATELIST* apCandList = pEntry->apCandList;
    for (DWORD iCand = 0; iCand < MAX_CANDLIST; ++iCand)
    {
        if ((dwCandidates & (1 << iCand)) && apCandList[iCand])
        {
            LocalFree(apCandList[iCand]);
            apCandList[iCand] = NULL;
            pEntry->acbCandList[iCand] = 0;
        }
    }
 
    COPYDATASTRUCT CopyData = { MAGIC_SEND_CANDLIST };
    IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
    return TRUE;
}

Referenced by ConIme_OnNotifyCloseCandidate().

IntCopyUnicodeToCharInfo()

void IntCopyUnicodeToCharInfo ( PCHAR_INFO *  ppDest, PCWSTR  pszSrc  )

inline

Definition at line 609 of file conime.c.

{
    if (!ppDest || !*ppDest || !pszSrc)
        return;
 
    PCHAR_INFO pCurrent;
    for (pCurrent = *ppDest; *pszSrc; ++pCurrent)
    {
        pCurrent->Char.UnicodeChar = *pszSrc++;
        pCurrent->Attributes = 0;
    }
 
    *ppDest = pCurrent;
}

Referenced by IntFillImeDisplayJPN().

IntDoImeComp()

void IntDoImeComp	(	HWND	hwnd,
		DWORD	dwFlags,
		WCHAR	wch
	)

Definition at line 1719 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry)
        return;
 
    switch (pEntry->nOutputCodePage)
    {
        case CP_CHINESE_SIMPLIFIED:
            IntDoImeCompCHS(hwnd, pEntry, dwFlags);
            break;
        case CP_CHINESE_TRADITIONAL:
            IntDoImeCompCHT(hwnd, pEntry, dwFlags);
            break;
        case CP_JAPANESE:
            IntDoImeCompJPN(hwnd, pEntry, dwFlags);
            break;
        case CP_KOREAN:
            IntDoImeCompKOR(hwnd, pEntry, dwFlags, wch);
            break;
    }
}

Referenced by ConIme_OnImeComposition().

IntDoImeCompCHS()

void IntDoImeCompCHS	(	HWND	hwnd,
		PCONENTRY	pEntry,
		DWORD	dwFlags
	)

Notifies the input composition status of the Chinese (Simplified) IME to the console.

Definition at line 1368 of file conime.c.

{
    HIMC hIMC = ImmGetContext(hwnd);
    if (!hIMC)
        return;
 
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
    {
        ImmReleaseContext(hwnd, hIMC);
        return;
    }
 
    DWORD dwCompLen = 0; // composition string length (in bytes, excluding)
    DWORD dwAttrLen = 0; // attribute info length (in bytes)
    size_t cbCompStr, cbNeeded;
    COPYDATASTRUCT CopyData;
 
    if (dwFlags & GCS_COMPSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
 
        if (dwFlags & GCS_COMPATTR)
        {
            dwAttrLen = ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
            if ((LONG)dwAttrLen < 0)
                goto EXIT;
        }
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
    }
    else if (dwFlags == 0)
    {
        dwCompLen = 0;
    }
    else
    {
        goto EXIT;
    }
 
    cbCompStr = dwCompLen + sizeof(UNICODE_NULL);
    cbNeeded = sizeof(COMPSTRINFO) + cbCompStr + (dwAttrLen + 1);
    if (pEntry->pCompStr && cbNeeded > pEntry->pCompStr->dwSize)
    {
        LocalFree(pEntry->pCompStr);
        pEntry->pCompStr = NULL;
    }
 
    if (!pEntry->pCompStr)
    {
        pEntry->pCompStr = LocalAlloc(LPTR, cbNeeded);
        if (!pEntry->pCompStr)
            goto EXIT;
        pEntry->pCompStr->dwSize = (DWORD)cbNeeded;
    }
 
    PCOMPSTRINFO pCompStr = pEntry->pCompStr;
    ZeroMemory(&pCompStr->dwCompAttrLen, pCompStr->dwSize - offsetof(COMPSTRINFO, dwCompAttrLen));
    CopyMemory(pCompStr->awAttrColor, pEntry->awAttrColor, sizeof(pCompStr->awAttrColor));
 
    PWCHAR pszDest = (PWCHAR)&pCompStr[1]; // bottom of COMPSTRINFO
    PBYTE pAttrDest = (PBYTE)pszDest + cbCompStr;
 
    if (dwFlags & GCS_COMPSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_COMPSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        if (dwAttrLen)
        {
            ImmGetCompositionStringW(hIMC, GCS_COMPATTR, pAttrDest, dwAttrLen);
            pAttrDest[dwAttrLen] = 0;
        }
 
        pCompStr->dwCompStrLen = dwCompLen;
        pCompStr->dwCompStrOffset = sizeof(COMPSTRINFO);
        pCompStr->dwCompAttrLen = dwAttrLen;
        pCompStr->dwCompAttrOffset = sizeof(COMPSTRINFO) + cbCompStr;
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        pCompStr->dwResultStrLen = dwCompLen;
        pCompStr->dwResultStrOffset = sizeof(COMPSTRINFO);
 
        CopyData.dwData = MAGIC_SEND_COMPSTR;
        CopyData.cbData = pCompStr->dwSize;
        CopyData.lpData = pCompStr;
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
        goto EXIT;
    }
 
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    CopyData.cbData = sizeof(IMEDISPLAY);
    CopyData.lpData = pDisplay;
    if (IntFillImeDisplayCHS(pEntry, pDisplay))
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
EXIT:
    if (pDisplay)
        LocalFree(pDisplay);
    ImmReleaseContext(hwnd, hIMC);
}

Referenced by IntDoImeComp().

IntDoImeCompCHT()

void IntDoImeCompCHT	(	HWND	hWnd,
		PCONENTRY	pEntry,
		DWORD	dwFlags
	)

Processes the input composition status of the Chinese (Traditional) IME and.

Definition at line 1482 of file conime.c.

{
    HIMC hIMC = ImmGetContext(hWnd);
    if (!hIMC)
        return;
 
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
    {
        ImmReleaseContext(hWnd, hIMC);
        return;
    }
 
    DWORD dwCompLen = 0; // composition string length (in bytes)
    DWORD dwAttrLen = 0; // attribute info length (in bytes)
    COPYDATASTRUCT CopyData;
    size_t cbCompStr, cbNeeded;
    PCOMPSTRINFO pCompStr;
    PWCHAR pszDest;
    PBYTE pAttrDest;
 
    if (dwFlags & GCS_COMPSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
 
        if (dwFlags & GCS_COMPATTR)
        {
            dwAttrLen = ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
            if ((LONG)dwAttrLen < 0)
                goto EXIT;
        }
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
    }
    else if (dwFlags != 0)
    {
        goto EXIT;
    }
 
    cbCompStr = dwCompLen + sizeof(UNICODE_NULL);
    cbNeeded = sizeof(COMPSTRINFO) + cbCompStr + (dwAttrLen + 1);
    if (pEntry->pCompStr && cbNeeded > pEntry->pCompStr->dwSize)
    {
        LocalFree(pEntry->pCompStr);
        pEntry->pCompStr = NULL;
    }
 
    if (!pEntry->pCompStr)
    {
        pEntry->pCompStr = LocalAlloc(LPTR, cbNeeded);
        if (!pEntry->pCompStr)
            goto EXIT;
        pEntry->pCompStr->dwSize = (DWORD)cbNeeded;
    }
 
    pCompStr = pEntry->pCompStr;
    ZeroMemory(&pCompStr->dwCompAttrLen, pCompStr->dwSize - sizeof(DWORD));
    CopyMemory(pCompStr->awAttrColor, pEntry->awAttrColor, sizeof(pCompStr->awAttrColor));
 
    pszDest = (PWCHAR)&pCompStr[1]; // bottom of COMPSTRINFO
    pAttrDest = (PBYTE)pszDest + cbCompStr;
 
    if (dwFlags & GCS_COMPSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_COMPSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        if (dwAttrLen)
        {
            ImmGetCompositionStringW(hIMC, GCS_COMPATTR, pAttrDest, dwAttrLen);
            pAttrDest[dwAttrLen] = 0;
        }
 
        pCompStr->dwCompStrLen = dwCompLen;
        if (dwCompLen)
            pCompStr->dwCompStrOffset = sizeof(COMPSTRINFO);
        else
            pCompStr->dwCompStrOffset = 0;
 
        pCompStr->dwCompAttrLen = dwAttrLen;
        if (dwAttrLen)
            pCompStr->dwCompAttrOffset = sizeof(COMPSTRINFO) + cbCompStr;
        else
            pCompStr->dwCompAttrOffset = 0;
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        pCompStr->dwResultStrLen = dwCompLen;
        if (dwCompLen)
            pCompStr->dwResultStrOffset = sizeof(COMPSTRINFO);
        else
            pCompStr->dwResultStrOffset = 0;
 
        CopyData.dwData = MAGIC_SEND_COMPSTR;
        CopyData.cbData = pCompStr->dwSize;
        CopyData.lpData = pCompStr;
        IntSendDataToConsole(pEntry->hwndConsole, hWnd, &CopyData);
        goto EXIT;
    }
 
    CopyData.lpData = pDisplay;
    CopyData.cbData = sizeof(*pDisplay);
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    if (IntFillImeDisplayCHT(pEntry, pDisplay))
        IntSendDataToConsole(pEntry->hwndConsole, hWnd, &CopyData);
 
EXIT:
    if (pDisplay)
        LocalFree(pDisplay);
    ImmReleaseContext(hWnd, hIMC);
}

Referenced by IntDoImeComp().

IntDoImeCompJPN()

void IntDoImeCompJPN	(	HWND	hwnd,
		PCONENTRY	pEntry,
		DWORD	dwFlags
	)

Processes Japanese IME Composition and Result strings.

Definition at line 1265 of file conime.c.

{
    HIMC hIMC = ImmGetContext(hwnd);
    if (!hIMC)
        return;
 
    DWORD dwCompLen = 0; // composition string length (in bytes, excluding)
    DWORD dwAttrLen = 0; // attribute info length (in bytes)
    size_t cbCompStr, cbNeeded;
    COPYDATASTRUCT CopyData;
 
    if (dwFlags & GCS_COMPSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
 
        if (dwFlags & GCS_COMPATTR)
        {
            dwAttrLen = ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
            if ((LONG)dwAttrLen < 0)
                goto EXIT;
        }
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
    }
    else if (dwFlags == 0)
    {
        dwCompLen = 0;
    }
    else
    {
        goto EXIT;
    }
 
    cbCompStr = dwCompLen + sizeof(UNICODE_NULL);
    cbNeeded = sizeof(COMPSTRINFO) + cbCompStr + (dwAttrLen + 1);
    if (pEntry->pCompStr && pEntry->pCompStr->dwSize < cbNeeded)
    {
        LocalFree(pEntry->pCompStr);
        pEntry->pCompStr = NULL;
    }
 
    if (!pEntry->pCompStr)
    {
        pEntry->pCompStr = LocalAlloc(LPTR, cbNeeded);
        if (!pEntry->pCompStr)
            goto EXIT;
        pEntry->pCompStr->dwSize = (DWORD)cbNeeded;
    }
 
    PCOMPSTRINFO pCompStr = pEntry->pCompStr;
    ZeroMemory(&pCompStr->dwCompAttrLen, pCompStr->dwSize - offsetof(COMPSTRINFO, dwCompAttrLen));
    CopyMemory(pCompStr->awAttrColor, pEntry->awAttrColor, sizeof(pCompStr->awAttrColor));
 
    PWCHAR pszDest = (PWCHAR)&pCompStr[1]; // bottom of COMPSTRINFO
    PBYTE pAttrDest = (PBYTE)pszDest + cbCompStr;
 
    if (dwFlags & GCS_COMPSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_COMPSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        if (dwAttrLen)
        {
            ImmGetCompositionStringW(hIMC, GCS_COMPATTR, pAttrDest, dwAttrLen);
            pAttrDest[dwAttrLen] = 0;
        }
 
        LONG cursorPos = ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, NULL, 0);
        if (cursorPos >= 0 && (DWORD)cursorPos < dwAttrLen)
            pAttrDest[cursorPos] |= BACKGROUND_BLUE;
        else
            pAttrDest[0] |= BACKGROUND_GREEN;
 
        pCompStr->dwCompStrLen = dwCompLen;
        pCompStr->dwCompStrOffset = sizeof(COMPSTRINFO);
        pCompStr->dwCompAttrLen = dwAttrLen;
        pCompStr->dwCompAttrOffset = sizeof(COMPSTRINFO) + cbCompStr;
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        pCompStr->dwResultStrLen = dwCompLen;
        pCompStr->dwResultStrOffset = sizeof(COMPSTRINFO);
    }
 
    CopyData.dwData = MAGIC_SEND_COMPSTR;
    CopyData.cbData = pCompStr->dwSize;
    CopyData.lpData = pCompStr;
    IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
EXIT:
    ImmReleaseContext(hwnd, hIMC);
}

Referenced by IntDoImeComp().

IntDoImeCompKOR()

void IntDoImeCompKOR	(	HWND	hwnd,
		PCONENTRY	pEntry,
		DWORD	dwFlags,
		WCHAR	wch
	)

Processes the Korean IME input composition state and notifies the console.

Definition at line 1604 of file conime.c.

{
    HIMC hIMC = ImmGetContext(hwnd);
    if (!hIMC)
        return;
 
    DWORD dwCompLen = 0; // composition string length (in bytes)
    DWORD dwAttrLen = 0; // attribute info length (in bytes)
    size_t cbCompStr, cbNeeded;
    PCOMPSTRINFO pCompStr;
    PWCHAR pszDest;
    PBYTE pAttrDest;
    COPYDATASTRUCT CopyData;
 
    if (dwFlags & GCS_COMPSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
 
        if (dwFlags & GCS_COMPATTR)
        {
            dwAttrLen = ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
            if ((LONG)dwAttrLen < 0)
                goto EXIT;
        }
        else
        {
            dwAttrLen = dwCompLen;
        }
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        dwCompLen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
        if ((LONG)dwCompLen < 0)
            goto EXIT;
        dwAttrLen = 0;
    }
    else if (dwFlags == 0)
    {
        dwCompLen = 0;
        dwAttrLen = 0;
    }
    else
    {
        goto EXIT;
    }
 
    cbCompStr = dwCompLen + sizeof(UNICODE_NULL);
    cbNeeded = sizeof(COMPSTRINFO) + cbCompStr + (dwAttrLen + 1);
    if (pEntry->pCompStr && pEntry->pCompStr->dwSize < cbNeeded)
    {
        LocalFree(pEntry->pCompStr);
        pEntry->pCompStr = NULL;
    }
 
    if (!pEntry->pCompStr)
    {
        pEntry->pCompStr = LocalAlloc(LPTR, cbNeeded);
        if (!pEntry->pCompStr)
            goto EXIT;
        pEntry->pCompStr->dwSize = cbNeeded;
    }
 
    pCompStr = pEntry->pCompStr;
    ZeroMemory(&pCompStr->dwCompAttrLen, pCompStr->dwSize - offsetof(COMPSTRINFO, dwCompAttrLen));
    CopyMemory(pCompStr->awAttrColor, pEntry->awAttrColor, sizeof(pCompStr->awAttrColor));
 
    pszDest = (PWCHAR)&pCompStr[1]; // bottom of COMPSTRINFO
    pAttrDest = (PBYTE)pszDest + cbCompStr;
 
    if (dwFlags & _GCS_SINGLECHAR)
    {
        *pszDest = wch;
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
        *pAttrDest = 1;
        pAttrDest[dwAttrLen] = 0;
    }
    else if (dwFlags & GCS_COMPSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_COMPSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
 
        if (dwFlags & GCS_COMPATTR)
        {
            ImmGetCompositionStringW(hIMC, GCS_COMPATTR, pAttrDest, dwAttrLen);
            pAttrDest[dwAttrLen] = 0;
        }
        else
        {
            ZeroMemory(pAttrDest, dwAttrLen);
            pAttrDest[dwAttrLen] = 0;
        }
        pCompStr->dwCompStrLen = dwCompLen;
        pCompStr->dwCompStrOffset = (DWORD)((PBYTE)pszDest - (PBYTE)pCompStr);
        pCompStr->dwCompAttrLen = dwAttrLen;
        pCompStr->dwCompAttrOffset = (DWORD)((PBYTE)pAttrDest - (PBYTE)pCompStr);
    }
    else if (dwFlags & GCS_RESULTSTR)
    {
        ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, pszDest, dwCompLen);
        pszDest[dwCompLen / sizeof(WCHAR)] = UNICODE_NULL;
        pCompStr->dwResultStrLen = dwCompLen;
        pCompStr->dwResultStrOffset = (DWORD)((PBYTE)pszDest - (PBYTE)pCompStr);
    }
 
    CopyData.dwData = MAGIC_SEND_COMPSTR;
    CopyData.cbData = pCompStr->dwSize;
    CopyData.lpData = pCompStr;
    IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
EXIT:
    ImmReleaseContext(hwnd, hIMC);
}

Referenced by IntDoImeComp().

IntFillImeCandidatesCHS()

UINT IntFillImeCandidatesCHS	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay,
		UINT	cch
	)

Fills the status buffer with characters and attributes from the.

Definition at line 755 of file conime.c.

{
    PCOMPSTRINFO pCompStr = pEntry->pCompStr;
 
    if (!pEntry->pCandInfo)
        return cch;
 
    UINT displayCols = 0;
    DWORD strPosByte = 0;
 
    if (pCompStr->dwCompStrLen > 0)
    {
        PWCHAR pszComp = (PWCHAR)&pCompStr[1]; // bottom of COMPSTRINFO
        size_t cbCompStr = pCompStr->dwCompStrLen + sizeof(UNICODE_NULL);
        PBYTE pbAttrs = (PBYTE)pszComp + cbCompStr;
 
        while (displayCols < 10)
        {
            pDisplay->CharInfo[cch].Char.UnicodeChar = *pszComp;
            pDisplay->CharInfo[cch].Attributes = pCompStr->awAttrColor[*pbAttrs];
            ++cch;
 
            strPosByte += sizeof(WCHAR);
            displayCols += IntIsDoubleWidthChar(*pszComp) + 1;
            ++pszComp;
            ++pbAttrs;
 
            if (strPosByte >= pCompStr->dwCompStrLen)
                break;
        }
    }
 
    INT padCount = 10 - displayCols;
    for (INT i = 0; i < padCount; ++i)
        pDisplay->CharInfo[cch++].Char.UnicodeChar = L' ';
 
    pDisplay->CharInfo[cch++].Char.UnicodeChar = L':';
 
    PCANDINFO pCandInfo = pEntry->pCandInfo;
    PBYTE pbCandAttrs = (PBYTE)pCandInfo + pCandInfo->dwAttrsOffset;
 
    for (PWCHAR pszCand = pCandInfo->szCandStr; *pszCand; ++pszCand)
    {
        pDisplay->CharInfo[cch].Char.UnicodeChar = *pszCand;
        pDisplay->CharInfo[cch].Attributes = pCompStr->awAttrColor[*pbCandAttrs];
        ++cch;
        ++pbCandAttrs;
    }
 
    return cch;
}

Referenced by IntFillImeDisplayCHS().

IntFillImeCandidatesCHT()

void IntFillImeCandidatesCHT	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay,
		UINT	iCand
	)

Fills the status buffer with characters and attributes from the.

Definition at line 464 of file conime.c.

{
    PCOMPSTRINFO pCompStr = pEntry->pCompStr;
    PCANDINFO pCandInfo = pEntry->pCandInfo;
    if (!pCandInfo)
        return;
 
    PBYTE pbAttrIndex = (PBYTE)pCandInfo + pCandInfo->dwAttrsOffset;
    PCHAR_INFO pDest = &pDisplay->CharInfo[iCand];
 
    for (PWCHAR pchSrc = pCandInfo->szCandStr; *pchSrc; ++pchSrc, ++pbAttrIndex, ++pDest)
    {
        pDest->Char.UnicodeChar = *pchSrc;
        if (*pbAttrIndex < _countof(pCompStr->awAttrColor))
            pDest->Attributes = pCompStr->awAttrColor[*pbAttrIndex];
    }
}

Referenced by IntFillImeDisplayCHT().

IntFillImeCompStrCHSorCHT()

void IntFillImeCompStrCHSorCHT	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay,
		UINT	cch
	)

Definition at line 515 of file conime.c.

{
    UINT maxX = max(pEntry->ScreenSize.X, IMEDISPLAY_MAX_X);
 
    PCOMPSTRINFO pCompStr = pEntry->pCompStr;
    if (!pCompStr || !pCompStr->dwCompStrLen)
        return;
 
    PWCHAR pchSrc = (PWCHAR)&pCompStr[1]; // bottom of COMPSTRINFO
    size_t cbCompStr = pCompStr->dwCompStrLen + sizeof(UNICODE_NULL);
    PBYTE pbAttrIndex = (PBYTE)pchSrc + cbCompStr;
    PCHAR_INFO pDest = &pDisplay->CharInfo[cch];
 
    DWORD dwCharCount = pCompStr->dwCompStrLen / sizeof(WCHAR);
    for (DWORD ich = 0; ich < dwCharCount && ich < maxX; ++ich, ++pDest)
    {
        pDest->Char.UnicodeChar = pchSrc[ich];
 
        BYTE ibColor = pbAttrIndex[ich];
        if (ibColor < _countof(pCompStr->awAttrColor))
            pDest->Attributes = pCompStr->awAttrColor[ibColor];
    }
}

Referenced by IntFillImeDisplayCHS(), and IntFillImeDisplayCHT().

IntFillImeDisplay()

BOOL IntFillImeDisplay	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay
	)

Converts the current IME status into a string for display (CHAR_INFO array).

Definition at line 829 of file conime.c.

{
    LANGID wLangId = LOWORD(pEntry->hKL);
    switch (wLangId)
    {
        case LANGID_CHINESE_SIMPLIFIED:
            return IntFillImeDisplayCHS(pEntry, pDisplay);
        case LANGID_CHINESE_TRADITIONAL:
            return IntFillImeDisplayCHT(pEntry, pDisplay);
        case LANGID_JAPANESE:
            return IntFillImeDisplayJPN(pEntry, pDisplay);
        case LANGID_KOREAN:
            return IntFillImeDisplayKOR(pEntry, pDisplay);
        default:
            return FALSE;
    }
}

Referenced by ConIme_OnChangeKeyboard(), ConIme_OnNotifySetOpenStatus(), and ConIme_SendImeStatus().

IntFillImeDisplayCHS()

BOOL IntFillImeDisplayCHS	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay
	)

Converts the current Simplified Chinese IME status into a string for display (CHAR_INFO array).

Definition at line 808 of file conime.c.

{
    UINT cch = 0;
    if (ImmIsIME(pEntry->hKL))
    {
        cch = IntFillImeModeCHS(pEntry, pDisplay, cch);
        if (pEntry->bInComposition)
        {
            if (pEntry->bHasAnyCand)
                cch = IntFillImeCandidatesCHS(pEntry, pDisplay, cch);
            else
                IntFillImeCompStrCHSorCHT(pEntry, pDisplay, cch);
        }
        cch = IntFillImeSpaceCHSorCHT(pEntry, pDisplay, cch);
    }
    pDisplay->bFlag = FALSE;
    pDisplay->uCharInfoLen = cch;
    return TRUE;
}

Referenced by IntCloseCandsCHS(), IntDoImeCompCHS(), IntFillImeDisplay(), IntSendCandListCHS(), and IntSendConversionStatusCHS().

IntFillImeDisplayCHT()

BOOL IntFillImeDisplayCHT	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay
	)

Converts the current Traditional Chinese IME status into a string for.

Definition at line 588 of file conime.c.

{
    UINT cch = 0;
    if (ImmIsIME(pEntry->hKL))
    {
        cch = IntFillImeModeCHT(pEntry, pDisplay, cch);
        if (pEntry->bInComposition)
        {
            if (pEntry->bHasAnyCand)
                IntFillImeCandidatesCHT(pEntry, pDisplay, cch);
            else
                IntFillImeCompStrCHSorCHT(pEntry, pDisplay, cch);
        }
        cch = IntFillImeSpaceCHSorCHT(pEntry, pDisplay, cch);
    }
 
    pDisplay->bFlag = FALSE;
    pDisplay->uCharInfoLen = cch;
    return TRUE;
}

Referenced by IntCloseCandsCHT(), IntDoImeCompCHT(), IntFillImeDisplay(), IntSendCandListCHT(), and IntSendConversionStatusCHT().

IntFillImeDisplayJPN()

BOOL IntFillImeDisplayJPN	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay
	)

Converts the current Japanese IME status into a string for display (CHAR_INFO array).

Definition at line 625 of file conime.c.

{
    PCHAR_INFO pChar = pDisplay->CharInfo;
    DWORD dwConversion = pEntry->dwConversion, dwSentence = pEntry->dwSentence;
    UINT cch = 0;
    WCHAR wchSentence = L' ';
 
    if (!pEntry->bOpened)
        goto DoSetAttributes;
 
    // Determines the input character type (full-width/half-width, hiragana/katakana/alphanumeric)
    if (dwConversion & IME_CMODE_FULLSHAPE) // Full-width (全角)
    {
        if (dwConversion & IME_CMODE_NATIVE)
        {
            if (dwConversion & IME_CMODE_KATAKANA)
                IntCopyUnicodeToCharInfo(&pChar, L"\x5168\x30AB"); // L"全カ"
            else
                IntCopyUnicodeToCharInfo(&pChar, L"\x5168\x3042"); // L"全あ"
        }
        else
        {
            IntCopyUnicodeToCharInfo(&pChar, L"\x5168\xFF21"); // L"全Ａ"
        }
        cch = 2;
    }
    else // Half-width (半角)
    {
        if (dwConversion & IME_CMODE_NATIVE)
        {
            if (dwConversion & IME_CMODE_KATAKANA)
                IntCopyUnicodeToCharInfo(&pChar, L"\x534A\xFF76 "); // L"半ｶ "
            else
                IntCopyUnicodeToCharInfo(&pChar, L"\x534A\xFF71 "); // L"半ｱ "
        }
        else
        {
            IntCopyUnicodeToCharInfo(&pChar, L"\x534A\x0041 "); // L"半A "
        }
        cch = 3;
    }
 
    // Determine phrase conversion mode (compound phrase, simple phrase, automatic, multi-phrase)
    if (dwSentence & IME_SMODE_PLAURALCLAUSE)
        wchSentence = L'\x8907'; // L'複'
    else if (dwSentence & IME_SMODE_SINGLECONVERT)
        wchSentence = L'\x5358'; // L'単'
    else if (dwSentence & IME_SMODE_AUTOMATIC)
        wchSentence = L'\x81EA'; // L'自'
    else if (dwSentence & IME_SMODE_PHRASEPREDICT)
        wchSentence = L'\x9023'; // L'連'
 
    pDisplay->CharInfo[cch++].Char.UnicodeChar = wchSentence;
    ++pChar;
 
    // Input method (kana input / romaji input) detection
    if (GetKeyState(VK_KANA) & 1)
    {
        IntCopyUnicodeToCharInfo(&pChar, L"\xFF76\xFF85  "); // L"ｶﾅ  "
        cch += 4;
    }
    else if (dwConversion & IME_CMODE_ROMAN)
    {
        IntCopyUnicodeToCharInfo(&pChar, L"\xFF9B\xFF70\xFF8F "); // L"ﾛｰﾏ "
        cch += 4;
    }
 
DoSetAttributes:
    for (UINT ich = 0; ich < cch; ++ich)
        pDisplay->CharInfo[ich].Attributes = _FOREGROUND_WHITE;
 
    pDisplay->uCharInfoLen = cch;
    pDisplay->bFlag = TRUE;
    return TRUE;
}

Referenced by IntFillImeDisplay().

IntFillImeDisplayKOR()

BOOL IntFillImeDisplayKOR	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay
	)

Converts the current Korean IME status into a string for display (CHAR_INFO array).

Definition at line 702 of file conime.c.

{
    pDisplay->CharInfo[0].Char.UnicodeChar = L' ';
    pDisplay->CharInfo[0].Attributes = _FOREGROUND_WHITE;
    pDisplay->uCharInfoLen = 1;
    pDisplay->bFlag = TRUE;
    return TRUE;
}

Referenced by IntFillImeDisplay().

IntFillImeModeCHS()

INT IntFillImeModeCHS	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay,
		UINT	cch
	)

Builds a buffer for displaying the Simplified Chinese IME mode.

Definition at line 712 of file conime.c.

{
    DWORD dwConversion = pEntry->dwConversion;
    UINT width = 0;
 
    for (PWCHAR pLayoutSrc = pEntry->szLayoutText; *pLayoutSrc; ++pLayoutSrc)
    {
        WCHAR wch = *pLayoutSrc;
        if (wch == 0x8F93) // U+8F93 L'输'
            break;
 
        pDisplay->CharInfo[cch++].Char.UnicodeChar = wch;
 
        width += (IntIsDoubleWidthChar(wch) + 1);
        if (width >= 9)
        {
            cch++;
            pLayoutSrc++;
            break;
        }
    }
 
    INT paddingCount = 9 - width;
    for (INT i = 0; i < paddingCount; ++i)
        pDisplay->CharInfo[cch++].Char.UnicodeChar = L' ';
 
    WCHAR modeChar;
    if (dwConversion & IME_CMODE_FULLSHAPE)
        modeChar = 0x5168; // U+5168 L'全'
    else
        modeChar = 0x534A; // U+534A L'半'
 
    pDisplay->CharInfo[cch++].Char.UnicodeChar = modeChar;
    pDisplay->CharInfo[cch++].Char.UnicodeChar = L':';
 
    for (UINT ich = 0; ich < cch; ++ich)
        pDisplay->CharInfo[ich].Attributes = _FOREGROUND_WHITE;
 
    return cch;
}

Referenced by IntFillImeDisplayCHS().

IntFillImeModeCHT()

UINT IntFillImeModeCHT	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay,
		INT	cch
	)

Builds a buffer for displaying the Traditional Chinese IME mode.

Definition at line 483 of file conime.c.

{
    PWCHAR pLayoutSrc = pEntry->szLayoutText;
 
    UINT width;
    for (width = 0; *pLayoutSrc && width < 5 - 1;)
    {
        WCHAR wch = *pLayoutSrc++;
        pDisplay->CharInfo[cch++].Char.UnicodeChar = wch;
        width += IntIsDoubleWidthChar(wch) + 1;
    }
 
    INT paddingCount = 5 - width;
    for (INT i = 0; i < paddingCount; ++i)
        pDisplay->CharInfo[cch++].Char.UnicodeChar = L' ';
 
    WCHAR modeChar;
    if (pEntry->dwConversion & IME_CMODE_FULLSHAPE)
        modeChar = 0x5168; // L'全' (full-width)
    else
        modeChar = 0x534A; // L'半' (half-width)
 
    pDisplay->CharInfo[cch++].Char.UnicodeChar = modeChar;
    pDisplay->CharInfo[cch++].Char.UnicodeChar = L' ';
    pDisplay->CharInfo[cch++].Char.UnicodeChar = L':';
 
    for (UINT i = 0; i < cch; ++i)
        pDisplay->CharInfo[i].Attributes = _FOREGROUND_WHITE;
 
    return cch;
}

Referenced by IntFillImeDisplayCHT().

IntFillImeSpaceCHSorCHT()

UINT IntFillImeSpaceCHSorCHT	(	PCONENTRY	pEntry,
		PIMEDISPLAY	pDisplay,
		UINT	cch
	)

Adjusts the width of the status display and pads it with spaces.

Definition at line 553 of file conime.c.

{
    const UINT maxX = max(pEntry->ScreenSize.X, IMEDISPLAY_MAX_X);
 
    UINT currentWidth = IntGetCharInfoWidth(pDisplay->CharInfo, cch);
    UINT index = cch;
    while (currentWidth > maxX && index > 0)
    {
        --index;
        WCHAR wch = pDisplay->CharInfo[index].Char.UnicodeChar;
        currentWidth -= IntGetCharDisplayWidth(wch);
    }
 
    const UINT remainingSpace = maxX - currentWidth;
    const UINT ichFinal = index + remainingSpace;
 
    if (remainingSpace > 0)
    {
        for (UINT ich = index; ich < ichFinal; ++ich)
        {
            PCHAR_INFO pChar = &pDisplay->CharInfo[ich];
            pChar->Char.UnicodeChar = L' ';
 
            if (ich < cch)
                pChar->Attributes = pDisplay->CharInfo[ich].Attributes;
            else
                pChar->Attributes = _FOREGROUND_WHITE;
        }
    }
 
    return ichFinal;
}

Referenced by IntFillImeDisplayCHS(), and IntFillImeDisplayCHT().

IntFindConsoleEntry()

PCONENTRY IntFindConsoleEntry

(

HANDLE

hConsole

)

Finds the CONENTRY structure corresponding to the specified console handle.

Definition at line 262 of file conime.c.

{
    EnterCriticalSection(&g_csLock);
 
    if (!g_hConsole)
        IntSetCurrentConsole(hConsole);
 
    PCONENTRY pFound = NULL;
    for (UINT iEntry = 1; iEntry < g_cEntries; ++iEntry)
    {
        PCONENTRY pEntry = g_ppEntries[iEntry];
        if (pEntry && pEntry->hConsole == hConsole && !pEntry->bWndEnabled)
        {
            pFound = pEntry;
            break;
        }
    }
 
    LeaveCriticalSection(&g_csLock);
    TRACE("hConsole %p --> PCONENTRY %p\n", hConsole, pFound);
    return pFound;
}

Referenced by ConIme_OnChangeKeyboard(), ConIme_OnDeactivate(), ConIme_OnDisable(), ConIme_OnGo(), ConIme_OnImeEndComposition(), ConIme_OnImeStartComposition(), ConIme_OnImeSystem(), ConIme_OnInit(), ConIme_OnInputLangChange(), ConIme_OnInputLangChangeRequest(), ConIme_OnKeyChar(), ConIme_OnNotifyCloseCandidate(), ConIme_OnNotifyGuideLine(), ConIme_OnNotifyOpenCandidate(), ConIme_OnNotifySetOpenStatus(), ConIme_OnSwitchIme(), ConIme_OnUnInit(), ConIme_SendImeStatus(), ConIme_SetCodePage(), ConIme_SetScreenSize(), IntDoImeComp(), IntGetImeState(), IntSendConversionStatus(), and IntSetImeState().

IntFormatCandLineCHS()

UINT IntFormatCandLineCHS	(	PCANDIDATELIST	pCandList,
		PWSTR	pszCandStrDest,
		PBYTE	pbAttrsDest,
		UINT	width,
		UINT	labelWidth,
		PCONENTRY	pEntry
	)

Definition at line 1981 of file conime.c.

{
    if (pCandList->dwSelection >= pCandList->dwCount)
        pCandList->dwSelection = 0;
 
    UINT pageIndex;
    for (pageIndex = pEntry->dwCandIndexMax; pageIndex > 0; --pageIndex)
    {
        if (pCandList->dwSelection >= pEntry->pdwCandPageStart[pageIndex])
            break;
    }
 
    ZeroMemory(pbAttrsDest, width);
 
    PWSTR pszCurrentPos = pszCandStrDest;
    PBYTE pbCurrentAttr = pbAttrsDest;
    UINT currentX = 0;
    UINT usableWidth = width - labelWidth;
    WORD candidateNum = !!(pEntry->dwImeProp & IME_PROP_CANDLIST_START_FROM_1);
 
    DWORD iStart = pEntry->pdwCandPageStart[pageIndex];
    DWORD iEnd = pEntry->pdwCandPageStart[pageIndex + 1];
    for (DWORD i = iStart; i < iEnd; ++i)
    {
        const WCHAR* pszSrc = (const WCHAR*)((PBYTE)pCandList + pCandList->dwOffset[i]);
        size_t cchSrc = wcslen(pszSrc);
        UINT strWidth = IntGetStringWidth(pszSrc);
        BOOL bTruncated = FALSE;
 
        if (strWidth + currentX + 3 > usableWidth)
        {
            size_t tmpW = 0, ichSrc = 0;
            for (ichSrc = 0; ichSrc < cchSrc; ++ichSrc)
            {
                tmpW += IntIsDoubleWidthChar(pszSrc[ichSrc]) + 1;
                if (currentX + tmpW > usableWidth - 3)
                    break;
            }
 
            cchSrc = (ichSrc > 0) ? ichSrc - 1 : 0;
            strWidth = tmpW;
            bTruncated = TRUE;
        }
 
        if (currentX + strWidth + labelWidth + 3 > width)
            break;
 
        if (i == pCandList->dwSelection)
            FillMemory(pbCurrentAttr, cchSrc + 2, FOREGROUND_BLUE);
 
        *pszCurrentPos++ = (WCHAR)(L'0' + candidateNum);
        *pszCurrentPos++ = L':';
        CopyMemory(pszCurrentPos, pszSrc, cchSrc * sizeof(WCHAR));
        pszCurrentPos += cchSrc;
        *pszCurrentPos++ = L' ';
 
        currentX += strWidth + 3;
        pbCurrentAttr += cchSrc + 3;
        candidateNum++;
 
        if (bTruncated)
            break;
    }
 
    *pszCurrentPos = UNICODE_NULL;
    return pageIndex;
}

Referenced by IntSendCandListCHS().

IntFormatCandLineCHT()

UINT IntFormatCandLineCHT	(	PCANDIDATELIST	pCandList,
		PWSTR	pszCandStrDest,
		PBYTE	pbAttrsDest,
		UINT	width,
		UINT	labelWidth,
		PCONENTRY	pEntry
	)

Definition at line 1888 of file conime.c.

{
    if (pCandList->dwSelection >= pCandList->dwCount)
        pCandList->dwSelection = 0;
 
    UINT pageIndex;
    for (pageIndex = pEntry->dwCandIndexMax; pageIndex > 0; --pageIndex)
    {
        if (pCandList->dwSelection >= pEntry->pdwCandPageStart[pageIndex])
            break;
    }
 
    ZeroMemory(pbAttrsDest, width);
 
    PWSTR pszCurrentStr = pszCandStrDest;
    PBYTE pbCurrentAttr = pbAttrsDest;
 
    DWORD iStart = pEntry->pdwCandPageStart[pageIndex];
    DWORD iEnd = pEntry->pdwCandPageStart[pageIndex + 1];
 
    UINT currentX = 0;
    UINT usableWidth = width - labelWidth;
    WORD candidateNum = !!(pEntry->dwImeProp & IME_PROP_CANDLIST_START_FROM_1);
 
    for (DWORD i = iStart; i < iEnd; ++i)
    {
        const WCHAR* pszSrc = (const WCHAR*)((PBYTE)pCandList + pCandList->dwOffset[i]);
        size_t cchSrc = wcslen(pszSrc);
        UINT strWidth = IntGetStringWidth(pszSrc);
        BOOL bTruncated = FALSE;
 
        if (currentX + strWidth + 3 > usableWidth)
        {
            size_t tmpW = 0, ichSrc;
            for (ichSrc = 0; ichSrc < cchSrc; ++ichSrc)
            {
                tmpW += IntIsDoubleWidthChar(pszSrc[ichSrc]) + 1;
                if (currentX + tmpW > usableWidth - 3)
                    break;
            }
 
            cchSrc = (ichSrc > 0) ? ichSrc - 1 : 0;
            strWidth = tmpW;
            bTruncated = TRUE;
        }
 
        if (currentX + strWidth + labelWidth + 3 > width)
            break;
 
        if (i == pCandList->dwSelection)
            FillMemory(pbCurrentAttr, cchSrc + 2, FOREGROUND_BLUE);
 
        *pszCurrentStr++ = (WCHAR)(L'0' + candidateNum);
        *pszCurrentStr++ = L':';
 
        CopyMemory(pszCurrentStr, pszSrc, cchSrc * sizeof(WCHAR));
        pszCurrentStr += cchSrc;
        *pszCurrentStr++ = L' ';
 
        currentX += strWidth + 3;
        pbCurrentAttr += cchSrc + 3;
        candidateNum++;
 
        if (bTruncated)
            break;
    }
 
    *pszCurrentStr = UNICODE_NULL;
 
    if (IntGetStringWidth(pszCandStrDest) <= usableWidth)
    {
        *pszCurrentStr = L' ';
        PWSTR pszLabelPos = pszCurrentStr + 1;
 
        UINT halfLabel = (labelWidth - 1) / 2;
 
        IntFormatNumber(pszLabelPos, pCandList->dwSelection + 1, halfLabel);
 
        pszLabelPos[halfLabel] = L'/';
 
        IntFormatNumber(&pszLabelPos[halfLabel + 1], pCandList->dwCount, halfLabel);
        pszLabelPos[labelWidth] = UNICODE_NULL;
    }
 
    return pageIndex;
}

Referenced by IntSendCandListCHT().

IntFormatCandLineJPNorKOR()

UINT IntFormatCandLineJPNorKOR	(	PCANDIDATELIST	pCandList,
		PWSTR	pszCandStrDest,
		PBYTE	pbAttrsDest,
		UINT	width,
		UINT	labelWidth,
		PCONENTRY	pEntry,
		BOOL	bIsCode
	)

Definition at line 1758 of file conime.c.

{
    if (pCandList->dwSelection >= pCandList->dwCount)
        pCandList->dwSelection = 0;
 
    UINT pageIndex;
    for (pageIndex = pEntry->dwCandIndexMax; pageIndex > 0; --pageIndex)
    {
        if (pCandList->dwSelection >= pEntry->pdwCandPageStart[pageIndex])
            break;
    }
 
    ZeroMemory(pbAttrsDest, width);
 
    PWSTR pszCurrentPos = pszCandStrDest;
    PBYTE pbCurrentAttr = pbAttrsDest;
    UINT currentX = 0;
    UINT candNum = 1;
 
    if (bIsCode)
    {
        WCHAR szCharCode[8];
        CHAR asz[2];
 
        PCWCH pwchCand = (PCWCH)((PBYTE)pCandList + pCandList->dwOffset[pCandList->dwSelection]);
        WideCharToMultiByte(CP_OEMCP, 0, pwchCand, 1, asz, _countof(asz), NULL, NULL);
 
        StringCchPrintfW(szCharCode, _countof(szCharCode), L"[%04X] ", MAKEWORD(asz[0], asz[1]));
 
        size_t cchCode = wcslen(szCharCode);
        StringCchCopyW(pszCurrentPos, cchCode + 1, szCharCode);
 
        currentX = cchCode;
        pszCurrentPos += cchCode;
        pbCurrentAttr += cchCode;
    }
 
    DWORD iStart = pEntry->pdwCandPageStart[pageIndex];
    DWORD iEnd = pEntry->pdwCandPageStart[pageIndex + 1];
    for (DWORD i = iStart; i < iEnd; ++i)
    {
        const WCHAR* pszSrc = (const WCHAR*)((PBYTE)pCandList + pCandList->dwOffset[i]);
        size_t cchSrc = wcslen(pszSrc);
        UINT strWidth = IntGetStringWidth(pszSrc);
        BOOL bTruncated = FALSE;
 
        if (currentX + strWidth + 3 > width - labelWidth)
        {
            UINT tmpW = 0, ichSrc = 0;
            for (ichSrc = 0; ichSrc < cchSrc; ++ichSrc)
            {
                tmpW += IntIsDoubleWidthChar(pszSrc[ichSrc]) + 1;
                if (currentX + tmpW > width - labelWidth - 3)
                    break;
            }
 
            cchSrc = (ichSrc > 0) ? ichSrc - 1 : 0;
            strWidth = tmpW;
            bTruncated = TRUE;
        }
 
        if (currentX + strWidth + labelWidth + 3 > width)
            break;
 
        if (i == pCandList->dwSelection)
            FillMemory(pbCurrentAttr, cchSrc + 2, FOREGROUND_BLUE);
 
        *pszCurrentPos++ = (WCHAR)(L'0' + candNum);
        *pszCurrentPos++ = L':';
        CopyMemory(pszCurrentPos, pszSrc, cchSrc * sizeof(WCHAR));
        pszCurrentPos += cchSrc;
        *pszCurrentPos++ = L' ';
 
        currentX += strWidth + 3;
        pbCurrentAttr += cchSrc + 3;
        candNum++;
 
        if (bTruncated)
            break;
    }
 
    *pszCurrentPos = UNICODE_NULL;
 
    UINT totalWidth = IntGetStringWidth(pszCandStrDest);
    UINT usableWidth = width - labelWidth;
 
    if (totalWidth <= usableWidth)
    {
        if (bIsCode)
        {
            if (totalWidth < width)
            {
                UINT pad = width - totalWidth;
                wmemset(pszCurrentPos, L' ', pad);
                pszCurrentPos += pad;
            }
        }
        else
        {
            if (totalWidth < usableWidth)
            {
                UINT pad = usableWidth - totalWidth;
                wmemset(pszCurrentPos, L' ', pad);
                pszCurrentPos += pad;
            }
 
            UINT halfLabel = (labelWidth - 1) / 2;
 
            IntFormatNumber(pszCurrentPos, pCandList->dwSelection + 1, halfLabel);
            pszCurrentPos += halfLabel;
 
            *pszCurrentPos++ = L'/';
 
            IntFormatNumber(pszCurrentPos, pCandList->dwCount, halfLabel);
            pszCurrentPos += halfLabel;
        }
 
        *pszCurrentPos = UNICODE_NULL;
    }
 
    return pageIndex;
}

Referenced by IntSendCandListJPNorKOR().

IntFormatNumber()

void IntFormatNumber	(	PWSTR	pszBuffer,
		UINT	value,
		UINT	width
	)

Definition at line 54 of file conime.c.

{
    UINT divisor = 1;
    if (width > 1)
    {
        UINT tempWidth = width - 1;
        do
        {
            divisor *= 10;
            --tempWidth;
        } while (tempWidth);
    }
 
    for (UINT i = divisor, ich = 0; i > 0; i /= 10, ++ich)
    {
        UINT digit = value / i;
        value %= i;
 
        if (digit == 0 && ich > 0)
        {
            WCHAR prevChar = pszBuffer[ich - 1];
            if (prevChar == L' ' || prevChar == L'/')
            {
                pszBuffer[ich] = L' ';
                continue;
            }
        }
 
        pszBuffer[ich] = (WCHAR)(L'0' + digit);
    }
}

Referenced by IntFormatCandLineCHT(), and IntFormatCandLineJPNorKOR().

IntFreeConsoleEntries()

void IntFreeConsoleEntries

(

void

)

Definition at line 189 of file conime.c.

{
    EnterCriticalSection(&g_csLock);
 
    if (g_ppEntries)
    {
        for (UINT iEntry = 1; iEntry < g_cEntries; ++iEntry)
        {
            PCONENTRY pEntry = g_ppEntries[iEntry];
            if (!pEntry)
                continue;
 
            if (!pEntry->hConsole)
            {
                LocalFree(pEntry);
                continue;
            }
 
            if (pEntry->bOpened)
            {
                pEntry->bOpened = FALSE;
                ImmSetOpenStatus(pEntry->hNewIMC, FALSE);
            }
 
            if (pEntry->hNewIMC)
                ImmDestroyContext(pEntry->hNewIMC);
 
            if (pEntry->pCompStr)
            {
                LocalFree(pEntry->pCompStr);
                pEntry->pCompStr = NULL;
            }
 
            for (UINT iList = 0; iList < MAX_CANDLIST; ++iList)
            {
                if (!pEntry->apCandList[iList])
                    continue;
                LocalFree(pEntry->apCandList[iList]);
                pEntry->apCandList[iList] = NULL;
                pEntry->acbCandList[iList] = 0;
            }
 
            if (pEntry->pdwCandPageStart)
            {
                LocalFree(pEntry->pdwCandPageStart);
                pEntry->pdwCandPageStart = NULL;
                pEntry->cbCandPageData = 0;
            }
 
            if (pEntry->pKLInfo)
            {
                LocalFree(pEntry->pKLInfo);
                pEntry->pKLInfo = NULL;
            }
 
            LocalFree(pEntry);
        }
 
        LocalFree(g_ppEntries);
        g_ppEntries = NULL;
        g_cEntries = 0;
    }
 
    LeaveCriticalSection(&g_csLock);
}

Referenced by ConIme_OnEnd(), and wWinMain().

IntGetCharDisplayWidth()

UINT IntGetCharDisplayWidth ( WCHAR  wch )

inline

Definition at line 547 of file conime.c.

{
    return IntIsDoubleWidthChar(wch) ? 2 : 1;
}

Referenced by IntFillImeSpaceCHSorCHT().

IntGetCharInfoWidth()

UINT IntGetCharInfoWidth	(	PCHAR_INFO	pCharInfo,
		UINT	cch
	)

Definition at line 539 of file conime.c.

{
    UINT ret = 0;
    for (UINT ich = 0; ich < cch; ++ich)
        ret += IntIsDoubleWidthChar(pCharInfo[ich].Char.UnicodeChar) + 1;
    return ret;
}

Referenced by IntFillImeSpaceCHSorCHT().

IntGetImeLayoutText()

BOOL IntGetImeLayoutText

(

PCONENTRY

pEntry

)

Gets the name of the current keyboard layout or IME and stores it in the entry.

Definition at line 374 of file conime.c.

{
    pEntry->szMode[0] = pEntry->szLayoutText[0] = UNICODE_NULL;
 
    HIMC hIMC = pEntry->hOldIMC;
    HKL hKL = pEntry->hKL;
 
    // Attempt to get IME name
    WCHAR szLayoutName[MAX_PATH];
    if (ImmEscapeW(hKL, hIMC, IME_ESC_IME_NAME, szLayoutName) ||
        ImmGetIMEFileNameW(hKL, szLayoutName, _countof(szLayoutName)))
    {
        StringCchCopyW(pEntry->szLayoutText, _countof(pEntry->szLayoutText), szLayoutName);
        return TRUE;
    }
 
    // Non IME Keyboard?
    if (!GetKeyboardLayoutNameW(szLayoutName) ||
        (szLayoutName[0] != L'E' && szLayoutName[0] != L'e'))
    {
        return FALSE;
    }
 
    // Build registry path
    WCHAR szKeyPath[MAX_PATH];
    StringCchCopyW(szKeyPath, _countof(szKeyPath),
                   L"SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\");
    StringCchCatW(szKeyPath, _countof(szKeyPath), szLayoutName);
 
    HKEY hKey;
    LSTATUS error = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szKeyPath, 0, KEY_QUERY_VALUE, &hKey);
    if (error == ERROR_SUCCESS)
    {
        DWORD cbData = sizeof(pEntry->szLayoutText);
        RegQueryValueExW(hKey, L"Layout Text", NULL, NULL, (PBYTE)pEntry->szLayoutText, &cbData);
        RegCloseKey(hKey);
    }
 
    PCWSTR pszText = pEntry->szLayoutText;
    if (pszText[0])
    {
#define PREFIX_LEN 2
#define COLUMN_COUNT 7
        static const WCHAR awchTable[] =
        {
            0x5009, 0x9821, 0x8ACB, 0x8F38, 0x5165, 0x5B57, 0x6839, // L"倉頡請輸入字根"
            0x5167, 0x78BC, 0x8ACB, 0x8F38, 0x5165, 0x5167, 0x78BC, // L"內碼請輸入內碼"
            0x55AE, 0x78BC, 0x8ACB, 0x8F38, 0x5165, 0x55AE, 0x78BC, // L"單碼請輸入單碼"
            0x901F, 0x6210, 0x8ACB, 0x8F38, 0x5165, 0x5B57, 0x6839, // L"速成請輸入字根"
            0x5927, 0x6613, 0x8ACB, 0x8F38, 0x5165, 0x5B57, 0x6839, // L"大易請輸入字根"
            0x82F1, 0x6570, 0x3000, 0x3000, 0x3000, 0x3000, 0x3000, // L"英数　　　　　"
            0xFF55, 0xFF53, 0x3000, 0x3000, 0x3000, 0x3000, 0x3000, // L"ｕｓ　　　　　"
            0x6CE8, 0x97F3, 0x8ACB, 0x8F38, 0x5165, 0x7B26, 0x865F, // L"注音請輸入符號"
            0x6CE8, 0x97F3, 0x8ACB, 0x3000, 0x9078, 0x3000, 0x5B57, // L"注音請　選　字"
        };
 
        INT ich;
        for (ich = 0; ich < _countof(awchTable); ich += COLUMN_COUNT)
        {
            if (RtlEqualMemory(pszText, &awchTable[ich], PREFIX_LEN * sizeof(WCHAR)))
                break;
        }
 
        if (ich < _countof(awchTable))
            StringCchCopyW(pEntry->szMode, (COLUMN_COUNT - PREFIX_LEN) + 1, &awchTable[ich + 2]);
    }
 
    return TRUE;
}

Referenced by ConIme_InitEntry(), ConIme_OnChangeKeyboard(), ConIme_OnInputLangChange(), and ConIme_OnSwitchIme().

IntGetImeState()

DWORD IntGetImeState	(	HWND	hWnd,
		HANDLE	hConsole
	)

WM_USER_GETIMESTATE.

Definition at line 2582 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return 0;
 
    HIMC hIMC = ImmGetContext(hWnd);
    if (!hIMC)
        return _IME_CMODE_DEACTIVATE;
 
    ImmGetConversionStatus(hIMC, &pEntry->dwConversion, &pEntry->dwSentence);
    pEntry->bOpened = IntIsImeOpen(hIMC, pEntry);
    ImmReleaseContext(hWnd, hIMC);
    return pEntry->dwConversion + (pEntry->bOpened ? _IME_CMODE_OPEN : 0);
}

Referenced by ConIme_OnUser().

IntGetStringWidth()

INT IntGetStringWidth

(

PCWSTR

pch

)

Definition at line 132 of file conime.c.

{
    INT cch = 0;
    while (*pch)
        cch += IntIsDoubleWidthChar(*pch++) + 1;
    return cch;
}

Referenced by IntFormatCandLineCHS(), IntFormatCandLineCHT(), IntFormatCandLineJPNorKOR(), IntSendCandListCHS(), IntSendCandListCHT(), and IntSendCandListJPNorKOR().

IntGrowEntries()

BOOL IntGrowEntries

(

void

)

Definition at line 300 of file conime.c.

{
    size_t cGrow = 5;
    size_t cNewCount = g_cEntries + cGrow;
    size_t cbOld = sizeof(PCONENTRY) * g_cEntries;
    size_t cbNew = sizeof(PCONENTRY) * cNewCount;
    PCONENTRY* ppEntries = LocalAlloc(LPTR, cbNew);
    if (!ppEntries)
        return FALSE;
 
    CopyMemory(ppEntries, g_ppEntries, cbOld);
 
    PCONENTRY* ppOldEntries = g_ppEntries;
    g_ppEntries = ppEntries;
    g_cEntries = cNewCount;
    LocalFree(ppOldEntries);
 
    return TRUE;
}

Referenced by ConIme_InitEntry().

IntIsConImeOnSystemProcessEnabled()

BOOL IntIsConImeOnSystemProcessEnabled

(

VOID

)

Is Console IME on system process enabled?

Definition at line 3184 of file conime.c.

{
    BOOL bIsConImeOnSystemProcessEnabled = FALSE;
 
    HKEY hKey;
    LSTATUS error = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                                  L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Console",
                                  0, KEY_QUERY_VALUE, &hKey);
    if (error == ERROR_SUCCESS)
    {
        DWORD dwValue = FALSE, cbValue = sizeof(dwValue);
        error = RegQueryValueExW(hKey, L"EnableConImeOnSystemProcess", NULL, NULL,
                                 (PBYTE)&dwValue, &cbValue);
        if (error == ERROR_SUCCESS)
            bIsConImeOnSystemProcessEnabled = !!dwValue;
        RegCloseKey(hKey);
    }
 
    return bIsConImeOnSystemProcessEnabled;
}

Referenced by ConIme_InitInstance().

IntIsDoubleWidthChar()

BOOL IntIsDoubleWidthChar

(

WCHAR

wch

)

Determines if a Unicode character should be rendered as "Double Width" (2 columns).

Definition at line 87 of file conime.c.

{
    // Characters from SPACE (0x20) to TILDE (0x7E) are always single-width
    if (0x0020 <= wch && wch <= 0x007E)
        return FALSE;
 
    // East Asian scripts (Full-width blocks)
    if ((0x3041 <= wch && wch <= 0x3094) || // Hiragana
        (0x30A1 <= wch && wch <= 0x30F6) || // Katakana
        (0x3105 <= wch && wch <= 0x312C) || // Bopomofo
        (0x3131 <= wch && wch <= 0x318E) || // Hangul Compatibility Jamo
        (0xAC00 <= wch && wch <= 0xD7A3) || // Hangul Syllables
        (0xFF01 <= wch && wch <= 0xFF5E))   // Full-width Forms (e.g., Ａ, Ｂ, ！）
    {
        return TRUE;
    }
 
    // Half-width East Asian blocks
    if ((0xFF61 <= wch && wch <= 0xFF9F) || // Half-width Katakana
        (0xFFA0 <= wch && wch <= 0xFFBE) || // Half-width Hangul
        (0xFFC2 <= wch && wch <= 0xFFC7) || // Specific Half-width Jamo variants
        (0xFFCA <= wch && wch <= 0xFFCF) ||
        (0xFFD2 <= wch && wch <= 0xFFD7) ||
        (0xFFDA <= wch && wch <= 0xFFDC))
    {
        return FALSE;
    }
 
    // CJK Ideographs and supplemental Full-width symbols
    if ((0xFFE0 <= wch && wch <= 0xFFE6) || // Full-width currency/symbols (￠, ￡, ￥, etc.)
        (0x4E00 <= wch && wch <= 0x9FA5) || // CJK Unified Ideographs (Common Kanji/Hanzi)
        (0xF900 <= wch && wch <= 0xFA2D))   // CJK Compatibility Ideographs
    {
        return TRUE;
    }
 
    // Fallback for undefined ranges
    ULONG cbMultiByte = 0;
    NTSTATUS Status = RtlUnicodeToMultiByteSize(&cbMultiByte, &wch, sizeof(WCHAR));
    if (NT_SUCCESS(Status))
        return cbMultiByte == 2;
 
    return FALSE;
}

Referenced by IntFillImeCandidatesCHS(), IntFillImeModeCHS(), IntFillImeModeCHT(), IntFormatCandLineCHS(), IntFormatCandLineCHT(), IntFormatCandLineJPNorKOR(), IntGetCharDisplayWidth(), IntGetCharInfoWidth(), and IntGetStringWidth().

IntIsImeOpen()

BOOL IntIsImeOpen	(	HIMC	hIMC,
		PCONENTRY	pEntry
	)

Definition at line 444 of file conime.c.

{
    LANGID wLangId = LOWORD(pEntry->hKL);
    switch (wLangId)
    {
        case LANGID_CHINESE_SIMPLIFIED:
        case LANGID_CHINESE_TRADITIONAL:
        case LANGID_KOREAN:
            if (!ImmGetOpenStatus(hIMC))
                return FALSE;
            return ImmIsIME(pEntry->hKL);
        case LANGID_JAPANESE:
            return ImmGetOpenStatus(hIMC);
        default:
            return FALSE;
    }
}

Referenced by ConIme_OnNotifySetOpenStatus(), and IntGetImeState().

IntIsLogOnSession()

BOOL IntIsLogOnSession

(

void

)

Determines whether the current process is an interactive logon session (such as Winlogon)

Definition at line 165 of file conime.c.

{
    NTSTATUS Status;
    HANDLE hToken;
    ULONG returnLength;
    TOKEN_STATISTICS tokenStats;
    static const LUID systemLuid = SYSTEM_LUID;
 
    Status = NtOpenProcessToken(INVALID_HANDLE_VALUE, TOKEN_QUERY, &hToken);
    if (!NT_SUCCESS(Status))
        return g_bIsLogOnSession;
 
    Status = NtQueryInformationToken(hToken, TokenStatistics, &tokenStats, sizeof(tokenStats),
                                     &returnLength);
    NtClose(hToken);
 
    if (!NT_SUCCESS(Status))
        return g_bIsLogOnSession;
 
    g_bIsLogOnSession = RtlEqualMemory(&tokenStats.AuthenticationId, &systemLuid,
                                       sizeof(systemLuid));
    return g_bIsLogOnSession;
}

Referenced by ConIme_InitInstance().

IntSendCandListCHS()

BOOL IntSendCandListCHS	(	HWND	hwnd,
		HIMC	hIMC,
		PCONENTRY	pEntry,
		DWORD	dwCandidates,
		BOOL	bOpen
	)

Definition at line 2197 of file conime.c.

{
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return FALSE;
 
    for (DWORD dwIndex = 0; dwIndex < MAX_CANDLIST; ++dwIndex)
    {
        if (!(dwCandidates & (1 << dwIndex)))
            continue;
 
        DWORD cbList = ImmGetCandidateListW(hIMC, dwIndex, NULL, 0);
        if (!cbList)
        {
            LocalFree(pDisplay);
            return FALSE;
        }
 
        if (pEntry->apCandList[dwIndex] && pEntry->acbCandList[dwIndex] != cbList)
        {
            LocalFree(pEntry->apCandList[dwIndex]);
            pEntry->apCandList[dwIndex] = NULL;
            pEntry->acbCandList[dwIndex] = 0;
        }
 
        if (!pEntry->apCandList[dwIndex])
        {
            pEntry->apCandList[dwIndex] = LocalAlloc(LPTR, cbList);
            if (!pEntry->apCandList[dwIndex])
            {
                LocalFree(pDisplay);
                return FALSE;
            }
            pEntry->acbCandList[dwIndex] = cbList;
        }
 
        PCANDIDATELIST pCandList = pEntry->apCandList[dwIndex];
        ImmGetCandidateListW(hIMC, dwIndex, pCandList, cbList);
 
        UINT screenX = max(min(pEntry->ScreenSize.X, 128), 12);
 
        INT usableWidth = (INT)screenX - 25;
 
        UINT maxItemsPerPage;
        if (usableWidth <= 7)
            maxItemsPerPage = 1;
        else
            maxItemsPerPage = (UINT)((usableWidth - 7) / 5);
 
        if (maxItemsPerPage > 9)
            maxItemsPerPage = 9;
 
        DWORD nPageCountNeeded = pCandList->dwCount / maxItemsPerPage + 10;
        if (nPageCountNeeded > 100)
            nPageCountNeeded = 100;
 
        if (pEntry->pdwCandPageStart &&
            pEntry->cbCandPageData != nPageCountNeeded * sizeof(DWORD))
        {
            LocalFree(pEntry->pdwCandPageStart);
            pEntry->pdwCandPageStart = NULL;
        }
        if (!pEntry->pdwCandPageStart)
        {
            pEntry->pdwCandPageStart = LocalAlloc(LPTR, nPageCountNeeded * sizeof(DWORD));
            if (!pEntry->pdwCandPageStart)
            {
                LocalFree(pDisplay);
                return FALSE;
            }
            pEntry->cbCandPageData = nPageCountNeeded * sizeof(DWORD);
        }
 
        if (bOpen)
            pEntry->dwCandOffset = 0;
 
        pEntry->pdwCandPageStart[0] = pEntry->dwCandOffset;
 
        PWCHAR szFirstStr = (PWCHAR)((PBYTE)pCandList + pCandList->dwOffset[0]);
        UINT currentX = IntGetStringWidth(szFirstStr) + 3;
 
        UINT iItem = 0, iCand = 1;
        for (iItem = 1; iItem < pCandList->dwCount && iCand < nPageCountNeeded - 1; ++iItem)
        {
            WCHAR* szText = (WCHAR*)((BYTE*)pCandList + pCandList->dwOffset[iItem]);
            UINT strWidth = IntGetStringWidth(szText);
 
            if (currentX + strWidth + 3 > usableWidth ||
                (iItem - pEntry->pdwCandPageStart[iCand-1]) >= 9)
            {
                pEntry->pdwCandPageStart[iCand++] = iItem;
                currentX = strWidth + 3;
            }
            else
            {
                currentX += strWidth + 3;
            }
        }
 
        pEntry->pdwCandPageStart[iCand] = pCandList->dwCount;
        pEntry->dwCandIndexMax = iCand;
 
        DWORD cbCandInfo = 3 * usableWidth + 4;
        if (pEntry->dwSystemLineSize < cbCandInfo)
        {
            if (pEntry->pCandInfo)
                LocalFree(pEntry->pCandInfo);
            pEntry->pCandInfo = LocalAlloc(LPTR, cbCandInfo);
            if (!pEntry->pCandInfo)
            {
                LocalFree(pDisplay);
                return FALSE;
            }
            pEntry->dwSystemLineSize = cbCandInfo;
        }
 
        PCANDINFO pCI = pEntry->pCandInfo;
        pCI->dwAttrsOffset = 2 * usableWidth + 4;
 
        PBYTE pbAttrs = (PBYTE)pCI + pCI->dwAttrsOffset;
        UINT iPage = IntFormatCandLineCHS(pCandList, pCI->szCandStr, pbAttrs, usableWidth, 0,
                                          pEntry);
 
        // Send page messages
        pEntry->bSkipPageMsg = TRUE;
        ImmNotifyIME(hIMC, NI_SETCANDIDATE_PAGESTART, dwIndex, pEntry->pdwCandPageStart[iPage]);
        ImmNotifyIME(hIMC, NI_SETCANDIDATE_PAGESIZE, dwIndex,
                     pEntry->pdwCandPageStart[iPage + 1] - pEntry->pdwCandPageStart[iPage]);
        pEntry->bSkipPageMsg = FALSE;
 
        COPYDATASTRUCT CopyData;
        CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
        CopyData.cbData = sizeof(*pDisplay);
        CopyData.lpData = pDisplay;
 
        if (IntFillImeDisplayCHS(pEntry, pDisplay))
            IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
    }
 
    LocalFree(pDisplay);
    return TRUE;
}

Referenced by ConIme_OnNotifyOpenCandidate().

IntSendCandListCHT()

BOOL IntSendCandListCHT	(	HWND	hwnd,
		HIMC	hIMC,
		PCONENTRY	pEntry,
		DWORD	dwCandidates,
		BOOL	bOpen
	)

Definition at line 2055 of file conime.c.

{
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return FALSE;
 
    for (DWORD dwIndex = 0; dwIndex < MAX_CANDLIST; ++dwIndex)
    {
        if (!(dwCandidates & (1 << dwIndex)))
            continue;
 
        DWORD cbList = ImmGetCandidateListW(hIMC, dwIndex, NULL, 0);
        if (cbList == 0)
            continue;
 
        if (pEntry->apCandList[dwIndex] && pEntry->acbCandList[dwIndex] != cbList)
        {
            LocalFree(pEntry->apCandList[dwIndex]);
            pEntry->apCandList[dwIndex] = NULL;
        }
 
        if (!pEntry->apCandList[dwIndex])
        {
            pEntry->apCandList[dwIndex] = LocalAlloc(LPTR, cbList);
            if (!pEntry->apCandList[dwIndex])
                continue;
            pEntry->acbCandList[dwIndex] = cbList;
        }
 
        PCANDIDATELIST pCandList = pEntry->apCandList[dwIndex];
        ImmGetCandidateListW(hIMC, dwIndex, pCandList, cbList);
 
        UINT screenX = max(min(pEntry->ScreenSize.X, 128), 12);
        UINT usableWidth = screenX - 8;
        if (usableWidth < 7)
            usableWidth = 7;
 
        UINT maxItemsPerPage = (usableWidth - 7) / 5;
        maxItemsPerPage = min(max(maxItemsPerPage, 1), 9);
 
        UINT numDigits = 0;
        for (UINT tmpCount = 1; tmpCount <= pCandList->dwCount; (tmpCount *= 10), ++numDigits)
        {
            if (tmpCount > MAXDWORD / 10)
                break;
        }
 
        UINT labelWidth = 2 * numDigits + 1;
 
        DWORD nPageCountNeeded;
        if ((pCandList->dwCount / maxItemsPerPage + 10) >= 100)
            nPageCountNeeded = 100;
        else
            nPageCountNeeded = (pCandList->dwCount / maxItemsPerPage + 10);
 
        if (pEntry->pdwCandPageStart &&
            pEntry->cbCandPageData != nPageCountNeeded * sizeof(DWORD))
        {
            LocalFree(pEntry->pdwCandPageStart);
            pEntry->pdwCandPageStart = NULL;
        }
 
        if (!pEntry->pdwCandPageStart)
        {
            pEntry->pdwCandPageStart = LocalAlloc(LPTR, nPageCountNeeded * sizeof(DWORD));
            if (!pEntry->pdwCandPageStart)
            {
                LocalFree(pDisplay);
                return FALSE;
            }
            pEntry->cbCandPageData = nPageCountNeeded * sizeof(DWORD);
        }
 
        if (bOpen)
            pEntry->dwCandOffset = 0;
 
        pEntry->pdwCandPageStart[0] = pEntry->dwCandOffset;
 
        PWCHAR firstStr = (PWCHAR)((PBYTE)pCandList + pCandList->dwOffset[0]);
        UINT currentX = IntGetStringWidth(firstStr) + 3;
 
        UINT iItem = 0, iCand = 1;
        for (iItem = 1; iItem < pCandList->dwCount && iCand < nPageCountNeeded - 1; ++iItem)
        {
            PWCHAR szText = (PWCHAR)((PBYTE)pCandList + pCandList->dwOffset[iItem]);
            UINT strWidth = IntGetStringWidth(szText);
 
            if (currentX + strWidth + 3 > (usableWidth - labelWidth))
            {
                pEntry->pdwCandPageStart[iCand++] = iItem;
                currentX = strWidth + 3;
            }
            else
            {
                currentX += strWidth + 3;
            }
        }
 
        pEntry->pdwCandPageStart[iCand] = pCandList->dwCount;
        pEntry->dwCandIndexMax = iCand;
 
        UINT cbCandInfo = 3 * usableWidth + 4;
        if (pEntry->dwSystemLineSize < cbCandInfo)
        {
            if (pEntry->pCandInfo)
                LocalFree(pEntry->pCandInfo);
            pEntry->pCandInfo = LocalAlloc(LPTR, cbCandInfo);
            if (!pEntry->pCandInfo)
            {
                LocalFree(pDisplay);
                return FALSE;
            }
            pEntry->dwSystemLineSize = cbCandInfo;
        }
 
        PCANDINFO pCI = pEntry->pCandInfo;
        pCI->dwAttrsOffset = 2 * usableWidth + 4;
 
        PBYTE pbAttrs = (PBYTE)pCI + pCI->dwAttrsOffset;
        UINT iPage = IntFormatCandLineCHT(pCandList, pCI->szCandStr, pbAttrs, usableWidth,
                                          labelWidth, pEntry);
 
        // Send page messages
        pEntry->bSkipPageMsg = TRUE;
        ImmNotifyIME(hIMC, NI_SETCANDIDATE_PAGESTART, dwIndex, pEntry->pdwCandPageStart[iPage]);
        ImmNotifyIME(hIMC, NI_SETCANDIDATE_PAGESIZE, dwIndex,
                     pEntry->pdwCandPageStart[iPage + 1] - pEntry->pdwCandPageStart[iPage]);
        pEntry->bSkipPageMsg = FALSE;
 
        COPYDATASTRUCT CopyData;
        CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
        CopyData.cbData = sizeof(*pDisplay);
        CopyData.lpData = pDisplay;
 
        if (IntFillImeDisplayCHT(pEntry, pDisplay))
            IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
    }
 
    LocalFree(pDisplay);
    return TRUE;
}

Referenced by ConIme_OnNotifyOpenCandidate().

IntSendCandListJPNorKOR()

BOOL IntSendCandListJPNorKOR	(	HWND	hwnd,
		HIMC	hIMC,
		PCONENTRY	pEntry,
		DWORD	dwCandidates,
		BOOL	bOpen
	)

Definition at line 2341 of file conime.c.

{
    for (DWORD dwIndex = 0; dwIndex < MAX_CANDLIST; ++dwIndex)
    {
        if (!(dwCandidates & (1 << dwIndex)))
            continue;
 
        DWORD cbList = ImmGetCandidateListW(hIMC, dwIndex, NULL, 0);
        if (!cbList)
            return FALSE;
 
        if (pEntry->apCandList[dwIndex] && pEntry->acbCandList[dwIndex] != cbList)
        {
            LocalFree(pEntry->apCandList[dwIndex]);
            pEntry->apCandList[dwIndex] = NULL;
        }
 
        if (!pEntry->apCandList[dwIndex])
        {
            pEntry->apCandList[dwIndex] = LocalAlloc(LPTR, cbList);
            if (!pEntry->apCandList[dwIndex])
                return FALSE;
            pEntry->acbCandList[dwIndex] = cbList;
        }
 
        PCANDIDATELIST pCandList = pEntry->apCandList[dwIndex];
        ImmGetCandidateListW(hIMC, dwIndex, pCandList, cbList);
 
        UINT screenX = max(min(pEntry->ScreenSize.X, 128), 12);
 
        UINT maxItems = (screenX - 7) / 5;
        if (maxItems > 9) maxItems = 9;
 
        BOOL bIsCode = (pCandList->dwStyle == IME_CAND_CODE);
        UINT labelWidth;
        if (bIsCode)
        {
            labelWidth = 7;
        }
        else
        {
            UINT digits = 0;
            for (UINT tmp = 1; tmp <= pCandList->dwCount; tmp *= 10)
            {
                if (tmp > MAXDWORD / 10)
                    break;
                ++digits;
            }
            labelWidth = 2 * digits + 1;
        }
 
        DWORD nPageCountNeeded = (pCandList->dwCount / maxItems + 10);
        if (nPageCountNeeded > 100)
            nPageCountNeeded = 100;
 
        if (pEntry->pdwCandPageStart &&
            pEntry->cbCandPageData != nPageCountNeeded * sizeof(DWORD))
        {
            LocalFree(pEntry->pdwCandPageStart);
            pEntry->pdwCandPageStart = NULL;
        }
 
        if (!pEntry->pdwCandPageStart)
        {
            pEntry->pdwCandPageStart = LocalAlloc(LPTR, nPageCountNeeded * sizeof(DWORD));
            if (!pEntry->pdwCandPageStart)
                return FALSE;
            pEntry->cbCandPageData = nPageCountNeeded * sizeof(DWORD);
        }
 
        DWORD iItem, iCand = 1;
 
        if (bIsCode)
        {
            if (bOpen)
                pEntry->dwCandOffset = pCandList->dwSelection % 9;
 
            pEntry->pdwCandPageStart[0] = 0;
            for (iItem = pEntry->dwCandOffset; iItem < pCandList->dwCount; iItem += 9)
                pEntry->pdwCandPageStart[iCand++] = iItem;
 
            if (iItem > pCandList->dwCount)
                iItem = pCandList->dwCount;
        }
        else
        {
            if (bOpen)
                pEntry->dwCandOffset = 0;
 
            pEntry->pdwCandPageStart[0] = pEntry->dwCandOffset;
 
            UINT currentX =
                IntGetStringWidth((PWCHAR)((PBYTE)pCandList + pCandList->dwOffset[0])) + 3;
            UINT usableWidth = screenX - labelWidth;
 
            for (DWORD i = 1; i < pCandList->dwCount; ++i)
            {
                UINT strWidth =
                    IntGetStringWidth((PWCHAR)((PBYTE)pCandList + pCandList->dwOffset[i]));
                if (currentX + strWidth + 3 > usableWidth ||
                    (i - pEntry->pdwCandPageStart[iCand - 1]) >= 9)
                {
                    pEntry->pdwCandPageStart[iCand++] = i;
                    currentX = strWidth + 3;
                }
                else
                {
                    currentX += strWidth + 3;
                }
            }
 
            iItem = pCandList->dwCount;
        }
 
        pEntry->pdwCandPageStart[iCand] = iItem;
        pEntry->dwCandIndexMax = iCand;
 
        DWORD cbCandInfo = 3 * screenX + 4;
        if (pEntry->dwSystemLineSize < cbCandInfo)
        {
            if (pEntry->pCandInfo)
                LocalFree(pEntry->pCandInfo);
            pEntry->pCandInfo = LocalAlloc(LPTR, cbCandInfo);
            if (!pEntry->pCandInfo)
                return FALSE;
            pEntry->dwSystemLineSize = cbCandInfo;
        }
 
        PCANDINFO pCI = pEntry->pCandInfo;
        pCI->dwAttrsOffset = 2 * screenX + 4;
 
        PBYTE pbAttrs = (PBYTE)pCI + pCI->dwAttrsOffset;
        UINT iPage = IntFormatCandLineJPNorKOR(pCandList, pCI->szCandStr, pbAttrs,
                                               screenX, labelWidth, pEntry, bIsCode);
 
        // Send page messages
        pEntry->bSkipPageMsg = TRUE;
        ImmNotifyIME(hIMC, NI_SETCANDIDATE_PAGESTART, dwIndex, pEntry->pdwCandPageStart[iPage]);
        ImmNotifyIME(hIMC, NI_SETCANDIDATE_PAGESIZE, dwIndex,
                     pEntry->pdwCandPageStart[iPage + 1] - pEntry->pdwCandPageStart[iPage]);
        pEntry->bSkipPageMsg = FALSE;
 
        COPYDATASTRUCT CopyData;
        CopyData.dwData = MAGIC_SEND_CANDLIST;
        CopyData.cbData = cbCandInfo;
        CopyData.lpData = pCI;
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
    }
 
    return TRUE;
}

Referenced by ConIme_OnNotifyOpenCandidate().

IntSendConversionStatus()

void IntSendConversionStatus

(

HWND

hwnd

)

Definition at line 936 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(g_hConsole);
    if (!pEntry || !pEntry->bInComposition)
        return;
 
    LANGID wLangId = LOWORD(pEntry->hKL);
    switch (wLangId)
    {
        case LANGID_CHINESE_SIMPLIFIED:
            IntSendConversionStatusCHS(hwnd, pEntry);
            break;
        case LANGID_CHINESE_TRADITIONAL:
            IntSendConversionStatusCHT(hwnd, pEntry);
            break;
        case LANGID_JAPANESE:
        case LANGID_KOREAN:
            IntSendConversionStatusJPNorKOR(hwnd, pEntry);
            break;
    }
}

Referenced by ConIme_OnSwitchIme().

IntSendConversionStatusCHS()

void IntSendConversionStatusCHS	(	HWND	hwnd,
		PCONENTRY	pEntry
	)

Definition at line 920 of file conime.c.

{
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return;
 
    COPYDATASTRUCT CopyData;
    CopyData.cbData = sizeof(*pDisplay);
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    CopyData.lpData = pDisplay;
    if (IntFillImeDisplayCHS(pEntry, pDisplay))
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
    LocalFree(pDisplay);
}

Referenced by IntSendConversionStatus().

IntSendConversionStatusCHT()

void IntSendConversionStatusCHT	(	HWND	hwnd,
		PCONENTRY	pEntry
	)

Definition at line 891 of file conime.c.

{
    PIMEDISPLAY pDisplay = LocalAlloc(LPTR, sizeof(IMEDISPLAY));
    if (!pDisplay)
        return;
 
    COPYDATASTRUCT CopyData;
    CopyData.cbData = sizeof(*pDisplay);
    CopyData.dwData = MAGIC_SEND_IMEDISPLAY;
    CopyData.lpData = pDisplay;
    if (IntFillImeDisplayCHT(pEntry, pDisplay))
        IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
 
    LocalFree(pDisplay);
}

Referenced by IntSendConversionStatus().

IntSendConversionStatusJPNorKOR()

void IntSendConversionStatusJPNorKOR	(	HWND	hwnd,
		PCONENTRY	pEntry
	)

Definition at line 907 of file conime.c.

{
    PCOMPSTRINFO pCompStr = pEntry->pCompStr;
    if (!pCompStr)
        return;
 
    COPYDATASTRUCT CopyData;
    CopyData.dwData = MAGIC_SEND_COMPSTR;
    CopyData.lpData = pCompStr;
    CopyData.cbData = pCompStr->dwSize;
    IntSendDataToConsole(pEntry->hwndConsole, hwnd, &CopyData);
}

Referenced by IntSendConversionStatus().

IntSendDataToConsole()

BOOL IntSendDataToConsole	(	HWND	hwndConsole,
		HWND	hwndSender,
		PCOPYDATASTRUCT	pCopyData
	)

Definition at line 140 of file conime.c.

{
    TRACE("IntSendDataToConsole(%p, %p): 0x%lX, 0x%lX\n", hwndConsole, hwndSender,
          pCopyData->dwData, pCopyData->cbData);
 
    if (!hwndConsole || !IsWindow(hwndConsole))
    {
        ERR("%p is null or invalid window\n", hwndConsole);
        return FALSE;
    }
 
    DWORD_PTR result;
    if (!SendMessageTimeoutW(hwndConsole, WM_COPYDATA, (WPARAM)hwndSender, (LPARAM)pCopyData,
                             SMTO_ABORTIFHUNG, 3000, &result))
    {
        ERR("SendMessageTimeoutW(%p) failed\n", hwndConsole);
        return FALSE;
    }
 
    TRACE("IntSendDataToConsole -> %p\n", result);
    return TRUE;
}

Referenced by ConIme_OnChangeKeyboard(), ConIme_OnImeSystem(), ConIme_OnNotifyGuideLine(), ConIme_OnNotifySetOpenStatus(), ConIme_SendImeStatus(), IntCloseCandsCHS(), IntCloseCandsCHT(), IntCloseCandsJPNorKOR(), IntDoImeCompCHS(), IntDoImeCompCHT(), IntDoImeCompJPN(), IntDoImeCompKOR(), IntSendCandListCHS(), IntSendCandListCHT(), IntSendCandListJPNorKOR(), IntSendConversionStatusCHS(), IntSendConversionStatusCHT(), and IntSendConversionStatusJPNorKOR().

IntSetCurrentConsole()

static void IntSetCurrentConsole ( HANDLE  hConsole )

static

Definition at line 255 of file conime.c.

{
    TRACE("g_hConsole: %p\n", hConsole);
    g_hConsole = hConsole;
}

Referenced by ConIme_OnSwitchIme(), and IntFindConsoleEntry().

IntSetImeState()

BOOL IntSetImeState	(	HWND	hwnd,
		HANDLE	hConsole,
		DWORD	dwConversion
	)

WM_USER_SETIMESTATE.

Definition at line 2599 of file conime.c.

{
    PCONENTRY pEntry = IntFindConsoleEntry(hConsole);
    if (!pEntry)
        return FALSE;
 
    if (dwConversion & _IME_CMODE_DEACTIVATE)
    {
        ImmSetActiveContextConsoleIME(hwnd, FALSE);
        ImmAssociateContext(hwnd, NULL);
        pEntry->hOldIMC = NULL;
    }
    else
    {
        ImmAssociateContext(hwnd, pEntry->hNewIMC);
        ImmSetActiveContextConsoleIME(hwnd, TRUE);
        pEntry->hOldIMC = pEntry->hNewIMC;
    }
 
    HIMC hIMC = ImmGetContext(hwnd);
    if (!hIMC)
        return TRUE;
 
    BOOL bOpened = !!(dwConversion & _IME_CMODE_OPEN);
    pEntry->bOpened = bOpened;
    ImmSetOpenStatus(hIMC, bOpened);
 
    DWORD dwImeConversion = (dwConversion & ~_IME_CMODE_MASK);
    if (pEntry->dwConversion != dwImeConversion)
    {
        pEntry->dwConversion = dwImeConversion;
        ImmSetConversionStatus(hIMC, dwImeConversion, pEntry->dwSentence);
    }
 
    ImmReleaseContext(hwnd, hIMC);
    return TRUE;
}

Referenced by ConIme_OnChangeKeyboard(), and ConIme_OnUser().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

conime

)

wWinMain()

INT WINAPI wWinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInstance,
		PWSTR	lpCmdLine,
		INT	nCmdShow
	)

Definition at line 3287 of file conime.c.

{
    WCHAR szSysDir[MAX_PATH];
    if (GetSystemDirectoryW(szSysDir, _countof(szSysDir)))
        SetCurrentDirectoryW(szSysDir);
 
    ImmDisableTextFrameService(0xFFFFFFFF);
 
    if (!ConIme_InitInstance(hInstance))
    {
        ERR("ConIme_InitInstance failed\n");
        IntFreeConsoleEntries();
        return 0;
    }
 
    MSG msg;
    _SEH2_TRY
    {
        // Main loop
        while (GetMessageW(&msg, NULL, 0, 0))
        {
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ERR("Exception\n");
        msg.wParam = -1;
    }
    _SEH2_END;
 
    IntFreeConsoleEntries();
    DeleteCriticalSection(&g_csLock);
 
    return (INT)msg.wParam;
}

Variable Documentation

g_bDisabled

BOOL g_bDisabled = FALSE

Definition at line 51 of file conime.c.

Referenced by ConIme_OnDeactivate(), ConIme_OnDisable(), and ConIme_OnSwitchIme().

g_bIsLogOnSession

BOOL g_bIsLogOnSession = FALSE

Definition at line 50 of file conime.c.

Referenced by ConIme_OnEnd(), and IntIsLogOnSession().

g_cEntries

UINT g_cEntries = 0

Definition at line 47 of file conime.c.

Referenced by ConIme_InitEntry(), ConIme_InitInstance(), ConIme_OnEnable(), IntFindConsoleEntry(), IntFreeConsoleEntries(), and IntGrowEntries().

g_csLock

CRITICAL_SECTION g_csLock

Definition at line 52 of file conime.c.

Referenced by ConIme_InitInstance(), ConIme_OnEnable(), ConIme_OnInit(), ConIme_OnUnInit(), IntFindConsoleEntry(), IntFreeConsoleEntries(), and wWinMain().

g_dwAttachToThreadId

DWORD g_dwAttachToThreadId = 0

Definition at line 49 of file conime.c.

Referenced by ConIme_InitInstance(), and ConIme_OnEnd().

g_hConsole

HANDLE g_hConsole = NULL

Definition at line 45 of file conime.c.

Referenced by ConIme_OnChangeKeyboard(), ConIme_OnDisable(), ConIme_OnImeEndComposition(), ConIme_OnImeStartComposition(), ConIme_OnImeSystem(), ConIme_OnInputLangChange(), ConIme_OnInputLangChangeRequest(), ConIme_OnKeyChar(), ConIme_OnNotifyCloseCandidate(), ConIme_OnNotifyGuideLine(), ConIme_OnNotifyOpenCandidate(), ConIme_OnNotifySetOpenStatus(), ConIme_SendImeStatus(), IntDoImeComp(), IntFindConsoleEntry(), IntSendConversionStatus(), and IntSetCurrentConsole().

g_hOldIMC

HIMC g_hOldIMC = NULL

Definition at line 48 of file conime.c.

Referenced by ConIme_OnCreate(), ConIme_OnDeactivate(), and ConIme_OnEnd().

g_ppEntries

PCONENTRY* g_ppEntries = NULL

Definition at line 46 of file conime.c.

Referenced by ConIme_InitEntry(), ConIme_InitInstance(), ConIme_OnEnable(), IntFindConsoleEntry(), IntFreeConsoleEntries(), and IntGrowEntries().