[reactos] 01/01: [IMM32] Implement Soft Keyboard Type C1 (#6036)

[Katayama Hirofumi MZ]

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6783061894743604dd057…
commit 6783061894743604dd057858f5ae3b1d38f238f7
Author:     Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com>
AuthorDate: Sat Nov 25 18:56:33 2023 +0900
Commit:     GitHub <noreply(a)github.com>
CommitDate: Sat Nov 25 18:56:33 2023 +0900
    [IMM32] Implement Soft Keyboard Type C1 (#6036)
    Follow-up to #6021. This PR will finish ImmCreateSoftKeyboard implementation.
    - Add c1key.h to define C1 internal codes.
    - The tests are done, using FreeCJ2004 on Chinese/Taiwanese system.
    FreeCJ2004:
https://web.archive.org/web/20061208204431/http://input.foruto.com/download…
    CORE-19268
---
 dll/win32/imm32/c1keys.h  |   64 +++
 dll/win32/imm32/softkbd.c | 1029 ++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 1027 insertions(+), 66 deletions(-)
diff --git a/dll/win32/imm32/c1keys.h b/dll/win32/imm32/c1keys.h
new file mode 100644
index 00000000000..34f1ea3049e
--- /dev/null
+++ b/dll/win32/imm32/c1keys.h
@@ -0,0 +1,64 @@
+/*
+ * PROJECT:     ReactOS IMM32
+ * LICENSE:     LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
+ * PURPOSE:     Defining internal codes (C1K_...) of IME Soft Keyboard Type C1
+ * COPYRIGHT:   Copyright 2023 Katayama Hirofumi MZ
<katayama.hirofumi.mz(a)gmail.com>
+ */
+
+/* DEFINE_C1K(c1k_code, virtual_key_code, c1k_code_name, virtual_key_name, is_special) */
+DEFINE_C1K( 0, 0xC0, C1K_OEM_3,     VK_OEM_3,      FALSE)
+DEFINE_C1K( 1, 0x31, C1K_1,         VK_1,          FALSE)
+DEFINE_C1K( 2, 0x32, C1K_2,         VK_2,          FALSE)
+DEFINE_C1K( 3, 0x33, C1K_3,         VK_3,          FALSE)
+DEFINE_C1K( 4, 0x34, C1K_4,         VK_4,          FALSE)
+DEFINE_C1K( 5, 0x35, C1K_5,         VK_5,          FALSE)
+DEFINE_C1K( 6, 0x36, C1K_6,         VK_6,          FALSE)
+DEFINE_C1K( 7, 0x37, C1K_7,         VK_7,          FALSE)
+DEFINE_C1K( 8, 0x38, C1K_8,         VK_8,          FALSE)
+DEFINE_C1K( 9, 0x39, C1K_9,         VK_9,          FALSE)
+DEFINE_C1K(10, 0x30, C1K_0,         VK_0,          FALSE)
+DEFINE_C1K(11, 0xBD, C1K_OEM_MINUS, VK_OEM_MINUS,  FALSE)
+DEFINE_C1K(12, 0xBB, C1K_OEM_PLUS,  VK_OEM_PLUS,   FALSE)
+DEFINE_C1K(13, 0x51, C1K_Q,         VK_Q,          FALSE)
+DEFINE_C1K(14, 0x57, C1K_W,         VK_W,          FALSE)
+DEFINE_C1K(15, 0x45, C1K_E,         VK_E,          FALSE)
+DEFINE_C1K(16, 0x52, C1K_R,         VK_R,          FALSE)
+DEFINE_C1K(17, 0x54, C1K_T,         VK_T,          FALSE)
+DEFINE_C1K(18, 0x59, C1K_Y,         VK_Y,          FALSE)
+DEFINE_C1K(19, 0x55, C1K_U,         VK_U,          FALSE)
+DEFINE_C1K(20, 0x49, C1K_I,         VK_I,          FALSE)
+DEFINE_C1K(21, 0x4F, C1K_O,         VK_O,          FALSE)
+DEFINE_C1K(22, 0x50, C1K_P,         VK_P,          FALSE)
+DEFINE_C1K(23, 0xDB, C1K_OEM_4,     VK_OEM_4,      FALSE)
+DEFINE_C1K(24, 0xDD, C1K_OEM_6,     VK_OEM_6,      FALSE)
+DEFINE_C1K(25, 0xDC, C1K_OEM_5,     VK_OEM_5,      FALSE)
+DEFINE_C1K(26, 0x41, C1K_A,         VK_A,          FALSE)
+DEFINE_C1K(27, 0x53, C1K_S,         VK_S,          FALSE)
+DEFINE_C1K(28, 0x44, C1K_D,         VK_D,          FALSE)
+DEFINE_C1K(29, 0x46, C1K_F,         VK_F,          FALSE)
+DEFINE_C1K(30, 0x47, C1K_G,         VK_G,          FALSE)
+DEFINE_C1K(31, 0x48, C1K_H,         VK_H,          FALSE)
+DEFINE_C1K(32, 0x4A, C1K_J,         VK_J,          FALSE)
+DEFINE_C1K(33, 0x4B, C1K_K,         VK_K,          FALSE)
+DEFINE_C1K(34, 0x4C, C1K_L,         VK_L,          FALSE)
+DEFINE_C1K(35, 0xBA, C1K_OEM_1,     VK_OEM_1,      FALSE)
+DEFINE_C1K(36, 0xDE, C1K_OEM_7,     VK_OEM_7,      FALSE)
+DEFINE_C1K(37, 0x5A, C1K_Z,         VK_Z,          FALSE)
+DEFINE_C1K(38, 0x58, C1K_X,         VK_X,          FALSE)
+DEFINE_C1K(39, 0x43, C1K_C,         VK_C,          FALSE)
+DEFINE_C1K(40, 0x56, C1K_V,         VK_V,          FALSE)
+DEFINE_C1K(41, 0x42, C1K_B,         VK_B,          FALSE)
+DEFINE_C1K(42, 0x4E, C1K_N,         VK_N,          FALSE)
+DEFINE_C1K(43, 0x4D, C1K_M,         VK_M,          FALSE)
+DEFINE_C1K(44, 0xBC, C1K_OEM_COMMA, VK_OEM_COMMA,  FALSE)
+DEFINE_C1K(45, 0xBE, C1K_OEM_DOT,   VK_OEM_PERIOD, FALSE)
+DEFINE_C1K(46, 0xBF, C1K_OEM_2,     VK_OEM_2,      FALSE)
+DEFINE_C1K(47, 0x08, C1K_BACKSPACE, VK_BACK,       TRUE)
+DEFINE_C1K(48, 0x09, C1K_TAB,       VK_TAB,        TRUE)
+DEFINE_C1K(49, 0x14, C1K_CAPS,      VK_CAPITAL,    TRUE)
+DEFINE_C1K(50, 0x0D, C1K_ENTER,     VK_RETURN,     TRUE)
+DEFINE_C1K(51, 0x10, C1K_SHIFT,     VK_SHIFT,      TRUE)
+DEFINE_C1K(52, 0x2D, C1K_INSERT,    VK_INSERT,     TRUE)
+DEFINE_C1K(53, 0x2E, C1K_DELETE,    VK_DELETE,     TRUE)
+DEFINE_C1K(54, 0x20, C1K_SPACE,     VK_SPACE,      TRUE)
+DEFINE_C1K(55, 0x1B, C1K_ESCAPE,    VK_ESCAPE,     TRUE)
diff --git a/dll/win32/imm32/softkbd.c b/dll/win32/imm32/softkbd.c
index 8cf17248760..522ff99185c 100644
--- a/dll/win32/imm32/softkbd.c
+++ b/dll/win32/imm32/softkbd.c
@@ -32,6 +32,23 @@ Imm32PtInRect(
     return (x <= ppt->x) && (ppt->x < x + cx) && (y <=
ppt->y) && (ppt->y < y + cy);
 }
+static void
+Imm32DrawBitmap(
+    _In_ HDC hdc,
+    _In_ INT x,
+    _In_ INT y,
+    _In_ INT width,
+    _In_ INT height,
+    _In_ INT nBitmapID)
+{
+    HBITMAP hBitmap = LoadBitmapW(ghImm32Inst, MAKEINTRESOURCEW(nBitmapID));
+    HDC hMemDC = CreateCompatibleDC(hdc);
+    HGDIOBJ hbmOld = SelectObject(hMemDC, hBitmap);
+    BitBlt(hdc, x, y, width, height, hMemDC, 0, 0, SRCCOPY);
+    DeleteObject(SelectObject(hMemDC, hbmOld));
+    DeleteDC(hMemDC);
+}
+
 static inline INT
 Imm32Clamp(
     _In_ INT x,
@@ -320,24 +337,6 @@ T1_DrawConvexRect(
     PatBlt(hDC, x0 + dx - 1, y + dy - 3, -1, 2 - dy, PATCOPY);
 }
-static void
-T1_DrawBitmap(
-    _In_ HDC hDC,
-    _In_ INT x,
-    _In_ INT y,
-    _In_ INT cx,
-    _In_ INT cy,
-    _In_ INT nBitmapID)
-{
-    HBITMAP hBitmap = LoadBitmapW(ghImm32Inst, MAKEINTRESOURCEW(nBitmapID));
-    HDC hMemDC = CreateCompatibleDC(hDC);
-    HGDIOBJ hbmOld = SelectObject(hMemDC, hBitmap);
-    BitBlt(hDC, x, y, cx, cy, hMemDC, 0, 0, SRCCOPY);
-    SelectObject(hMemDC, hbmOld);
-    DeleteObject(hBitmap);
-    DeleteDC(hMemDC);
-}
-
 static void
 T1_DrawLabels(
     _In_ HDC hDC,
@@ -386,46 +385,46 @@ T1_InitBitmap(
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_L_CTRL).x, T1_KEYPOS(T1K_L_CTRL).y,
                       pT1->cxWidth53or54, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth53or54 / 2 + T1_KEYPOS(T1K_L_CTRL).x - 8,
-                  pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_L_CTRL).y - 4,
-                  16, 9, IDB_T1_CTRL);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth53or54 / 2 + T1_KEYPOS(T1K_L_CTRL).x - 8,
+                    pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_L_CTRL).y - 4,
+                    16, 9, IDB_T1_CTRL);
     /* 54 --> Right [Ctrl] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_R_CTRL).x, T1_KEYPOS(T1K_R_CTRL).y,
                       pT1->cxWidth53or54, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth53or54 / 2 + T1_KEYPOS(T1K_R_CTRL).x - 8,
-                  pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_R_CTRL).y - 4,
-                  16, 9, IDB_T1_CTRL);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth53or54 / 2 + T1_KEYPOS(T1K_R_CTRL).x - 8,
+                    pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_R_CTRL).y - 4,
+                    16, 9, IDB_T1_CTRL);
     /* 57 --> [Esc] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_ESCAPE).x, T1_KEYPOS(T1K_ESCAPE).y,
                       pT1->cxWidth57, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth57   / 2 + T1_KEYPOS(T1K_ESCAPE).x - 9,
-                  pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_ESCAPE).y - 4,
-                  18, 9, IDB_T1_ESCAPE);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth57   / 2 + T1_KEYPOS(T1K_ESCAPE).x - 9,
+                    pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_ESCAPE).y - 4,
+                    18, 9, IDB_T1_ESCAPE);
     /* 55 --> Left [Alt] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_L_ALT).x, T1_KEYPOS(T1K_L_ALT).y,
                       pT1->cxWidth55or56, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth55or56 / 2 + T1_KEYPOS(T1K_L_ALT).x - 8,
-                  pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_L_ALT).y - 4,
-                  16, 9, IDB_T1_ALT);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth55or56 / 2 + T1_KEYPOS(T1K_L_ALT).x - 8,
+                    pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_L_ALT).y - 4,
+                    16, 9, IDB_T1_ALT);
     /* 56 --> Right [Alt] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_R_ALT).x, T1_KEYPOS(T1K_R_ALT).y,
                       pT1->cxWidth55or56, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth55or56 / 2 + T1_KEYPOS(T1K_R_ALT).x - 8,
-                  pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_R_ALT).y - 4,
-                  16, 9, IDB_T1_ALT);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth55or56 / 2 + T1_KEYPOS(T1K_R_ALT).x - 8,
+                    pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_R_ALT).y - 4,
+                    16, 9, IDB_T1_ALT);
     /* 58 --> [Space] */
     T1_DrawConvexRect(hMemDC,
@@ -436,55 +435,55 @@ T1_InitBitmap(
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_L_SHIFT).x, T1_KEYPOS(T1K_L_SHIFT).y,
                       pT1->cxWidth51or52, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth51or52 / 2 + T1_KEYPOS(T1K_L_SHIFT).x - 11,
-                  pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_L_SHIFT).y - 4,
-                  23, 9, IDB_T1_SHIFT);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth51or52 / 2 + T1_KEYPOS(T1K_L_SHIFT).x - 11,
+                    pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_L_SHIFT).y - 4,
+                    23, 9, IDB_T1_SHIFT);
     /* 52 --> Right [Shift] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_R_SHIFT).x, T1_KEYPOS(T1K_R_SHIFT).y,
                       pT1->cxWidth51or52, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth51or52 / 2 + T1_KEYPOS(T1K_R_SHIFT).x - 11,
-                  pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_R_SHIFT).y - 4,
-                  23, 9, IDB_T1_SHIFT);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth51or52 / 2 + T1_KEYPOS(T1K_R_SHIFT).x - 11,
+                    pT1->cyDefHeight   / 2 + T1_KEYPOS(T1K_R_SHIFT).y - 4,
+                    23, 9, IDB_T1_SHIFT);
     /* 49 --> [Caps] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_CAPS).x, T1_KEYPOS(T1K_CAPS).y,
                       pT1->cxWidth49, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth49   / 2 + T1_KEYPOS(T1K_CAPS).x - 11,
-                  pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_CAPS).y - 4,
-                  22, 9, IDB_T1_CAPS);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth49   / 2 + T1_KEYPOS(T1K_CAPS).x - 11,
+                    pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_CAPS).y - 4,
+                    22, 9, IDB_T1_CAPS);
     /* 48 --> [Tab] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_TAB).x, T1_KEYPOS(T1K_TAB).y,
                       pT1->cxWidth48, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth48   / 2 + T1_KEYPOS(T1K_TAB).x - 8,
-                  pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_TAB).y - 4,
-                  16, 9, IDB_T1_TAB);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth48   / 2 + T1_KEYPOS(T1K_TAB).x - 8,
+                    pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_TAB).y - 4,
+                    16, 9, IDB_T1_TAB);
     /* 50 --> [Enter] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_ENTER).x, T1_KEYPOS(T1K_ENTER).y,
                       pT1->cxWidth50, pT1->cyHeight50);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth50  / 2 + T1_KEYPOS(T1K_ENTER).x - 13,
-                  pT1->cyHeight50 / 2 + T1_KEYPOS(T1K_ENTER).y - 4,
-                  26, 9, IDB_T1_ENTER);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth50  / 2 + T1_KEYPOS(T1K_ENTER).x - 13,
+                    pT1->cyHeight50 / 2 + T1_KEYPOS(T1K_ENTER).y - 4,
+                    26, 9, IDB_T1_ENTER);
     /* 47 --> [BackSpace] */
     T1_DrawConvexRect(hMemDC,
                       T1_KEYPOS(T1K_BACKSPACE).x, T1_KEYPOS(T1K_BACKSPACE).y,
                       pT1->cxWidth47, pT1->cyDefHeight);
-    T1_DrawBitmap(hMemDC,
-                  pT1->cxWidth47   / 2 + T1_KEYPOS(T1K_BACKSPACE).x - 8,
-                  pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_BACKSPACE).y - 4,
-                  16, 9, IDB_T1_BACKSPACE);
+    Imm32DrawBitmap(hMemDC,
+                    pT1->cxWidth47   / 2 + T1_KEYPOS(T1K_BACKSPACE).x - 8,
+                    pT1->cyDefHeight / 2 + T1_KEYPOS(T1K_BACKSPACE).y - 4,
+                    16, 9, IDB_T1_BACKSPACE);
     /* Regular keys */
     for (iKey = 0; iKey < T1K_BACKSPACE; ++iKey)
@@ -842,7 +841,7 @@ T1_OnButtonUp(
     iPressed = pT1->PressedKey;
     if (iPressed >= T1K_NONE)
     {
-        if (pT1->pt1.x != -1 && pT1->pt1.y != -1 )
+        if (pT1->pt1.x != -1 && pT1->pt1.y != -1)
         {
             T1_DrawDragBorder(hWnd, &pT1->pt0, &pT1->pt1);
             x = pT1->pt0.x - pT1->pt1.x;
@@ -1123,6 +1122,865 @@ T1_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 #define C1_CLASSNAMEW L"SoftKBDClsC1"
+#define C1K_MAX 56
+
+#undef DEFINE_C1K
+#define DEFINE_C1K(c1k_code, virtual_key_code, c1k_code_name, virtual_key_name,
is_special) \
+    c1k_code_name = c1k_code,
+
+/* Define C1 internal codes (C1K_...) */
+typedef enum C1KEY
+{
+#include "c1keys.h"
+} C1KEY;
+
+#undef DEFINE_C1K
+#define DEFINE_C1K(c1k_code, virtual_key_code, c1k_code_name, virtual_key_name,
is_special) \
+    virtual_key_code,
+
+/* Mapping: C1K --> Virtual Key */
+const BYTE gC1K2VK[C1K_MAX] =
+{
+#include "c1keys.h"
+};
+
+typedef struct C1WINDOW
+{
+    WCHAR Data[2][47];
+    DWORD dwFlags;
+    HBITMAP hbmKeyboard;
+    LPARAM SubType;
+    INT iPressedKey;
+    POINT pt1, pt2;
+    DWORD CharSet;
+} C1WINDOW, *PC1WINDOW;
+
+/* The flags for C1WINDOW.dwFlags */
+#define FLAG_SHIFT_PRESSED 1
+#define FLAG_DRAGGING 2
+#define FLAG_PRESSED 4
+
+static BOOL gbC1ButtonInit = FALSE;
+static POINT gptC1ButtonPos[C1K_MAX];
+
+static void C1_InitButtonPos(void)
+{
+    LONG x = 0, y = 0;
+    INT iKey;
+
+    /* 1st row */
+    for (iKey = C1K_OEM_3; iKey < C1K_Q; ++iKey)
+    {
+        gptC1ButtonPos[iKey].x = x;
+        gptC1ButtonPos[iKey].y = y;
+        x += 24;
+    }
+    gptC1ButtonPos[C1K_BACKSPACE].x = x;
+    gptC1ButtonPos[C1K_BACKSPACE].y = y;
+
+    /* 2nd row */
+    y = 28;
+    gptC1ButtonPos[C1K_TAB].x = 0;
+    gptC1ButtonPos[C1K_TAB].y = y;
+    x = 36;
+    for (; iKey < C1K_A; ++iKey)
+    {
+        gptC1ButtonPos[iKey].x = x;
+        gptC1ButtonPos[iKey].y = y;
+        x += 24;
+    }
+
+    /* 3rd row */
+    y = 56;
+    gptC1ButtonPos[C1K_CAPS].x = 0;
+    gptC1ButtonPos[C1K_CAPS].y = y;
+    x = 42;
+    for (; iKey < C1K_Z; ++iKey)
+    {
+        gptC1ButtonPos[iKey].x = x;
+        gptC1ButtonPos[iKey].y = y;
+        x += 24;
+    }
+    gptC1ButtonPos[C1K_ENTER].x = x;
+    gptC1ButtonPos[C1K_ENTER].y = y;
+
+    /* 4th row */
+    y = 84;
+    gptC1ButtonPos[C1K_SHIFT].x = 0;
+    gptC1ButtonPos[C1K_SHIFT].y = y;
+    x = 60;
+    for (; iKey < C1K_BACKSPACE; ++iKey)
+    {
+        gptC1ButtonPos[iKey].x = x;
+        gptC1ButtonPos[iKey].y = y;
+        x += 24;
+    }
+
+    /* 5th row */
+    y = 112;
+    gptC1ButtonPos[C1K_INSERT].x = 0;
+    gptC1ButtonPos[C1K_INSERT].y = y;
+    gptC1ButtonPos[C1K_DELETE].x = 58;
+    gptC1ButtonPos[C1K_DELETE].y = y;
+    gptC1ButtonPos[C1K_SPACE].x = 96;
+    gptC1ButtonPos[C1K_SPACE].y = y;
+    gptC1ButtonPos[C1K_ESCAPE].x = 310;
+    gptC1ButtonPos[C1K_ESCAPE].y = y;
+}
+
+static void
+C1_DrawConvexRect(
+    _In_ HDC hDC,
+    _In_ INT x,
+    _In_ INT y,
+    _In_ INT width,
+    _In_ INT height)
+{
+    HGDIOBJ hLtGrayBrush = GetStockObject(LTGRAY_BRUSH);
+    HGDIOBJ hBlackPen = GetStockObject(BLACK_PEN);
+    HGDIOBJ hWhiteBrush = GetStockObject(WHITE_BRUSH);
+    HGDIOBJ hGrayBrush = GetStockObject(GRAY_BRUSH);
+    INT y2 = y + height - 1;
+
+    /* Draw face */
+    SelectObject(hDC, hLtGrayBrush);
+    SelectObject(hDC, hBlackPen);
+    Rectangle(hDC, x, y, x + width, y + height);
+
+    /* Draw light edge */
+    SelectObject(hDC, hWhiteBrush);
+    PatBlt(hDC, x, y2, 2, 1 - height, PATCOPY);
+    PatBlt(hDC, x, y, width - 1, 2, PATCOPY);
+
+    /* Draw dark edge */
+    SelectObject(hDC, hGrayBrush);
+    PatBlt(hDC, x + 1, y2, width - 2, -1, PATCOPY);
+    PatBlt(hDC, x + width - 1, y2, -1, 2 - height, PATCOPY);
+}
+
+static void
+C1_InvertButton(
+    _In_ HDC hDC,
+    _In_ INT iKey)
+{
+    INT width = 24, height = 28;
+
+    if (iKey < 0)
+        return;
+
+    switch (iKey)
+    {
+        case C1K_BACKSPACE: case C1K_TAB:
+            width = 36;
+            break;
+        case C1K_CAPS: case C1K_ENTER:
+            width = 42;
+            break;
+        case C1K_SHIFT:
+            width = 60;
+            break;
+        case C1K_INSERT: case C1K_DELETE: case C1K_ESCAPE:
+            width = 38;
+            height = 24;
+            break;
+        case C1K_SPACE:
+            width = 172;
+            height = 24;
+            break;
+        default:
+            break;
+    }
+
+    BitBlt(hDC, gptC1ButtonPos[iKey].x, gptC1ButtonPos[iKey].y, width, height,
+           hDC, gptC1ButtonPos[iKey].x, gptC1ButtonPos[iKey].y, DSTINVERT);
+}
+
+static void
+C1_DrawLabel(
+    _In_ HDC hDC,
+    _In_ INT nBitmapID)
+{
+    HBITMAP hBitmap;
+    HGDIOBJ hbmOld;
+    HDC hMemDC;
+    INT iKey;
+
+    hBitmap = LoadBitmapW(ghImm32Inst, MAKEINTRESOURCEW(nBitmapID));
+    hMemDC = CreateCompatibleDC(hDC);
+    hbmOld = SelectObject(hMemDC, hBitmap);
+    for (iKey = C1K_OEM_3; iKey < C1K_BACKSPACE; ++iKey)
+    {
+        BitBlt(hDC, gptC1ButtonPos[iKey].x + 2, gptC1ButtonPos[iKey].y + 2, 8, 8,
+               hMemDC, iKey * 8, 0, SRCCOPY);
+    }
+    DeleteObject(SelectObject(hMemDC, hbmOld));
+    DeleteDC(hMemDC);
+}
+
+static void
+C1_InitBitmap(
+    _In_ HDC hDC,
+    _In_ INT x,
+    _In_ INT y,
+    _In_ INT width,
+    _In_ INT height)
+{
+    HGDIOBJ hLtGrayBrush = GetStockObject(LTGRAY_BRUSH);
+    HGDIOBJ hNullPen = GetStockObject(NULL_PEN);
+    INT iKey;
+
+    /* Draw keyboard frame */
+    SelectObject(hDC, hLtGrayBrush);
+    SelectObject(hDC, hNullPen);
+    Rectangle(hDC, x, y, width + 1, height + 1);
+
+    for (iKey = C1K_OEM_3; iKey < C1K_BACKSPACE; ++iKey)
+    {
+        C1_DrawConvexRect(hDC, gptC1ButtonPos[iKey].x, gptC1ButtonPos[iKey].y, 24, 28);
+    }
+
+    C1_DrawLabel(hDC, IDB_C1_CHARS);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_BACKSPACE].x,
gptC1ButtonPos[C1K_BACKSPACE].y, 36, 28);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_BACKSPACE].x + 2,
gptC1ButtonPos[C1K_BACKSPACE].y + 2, 32, 24, IDB_C1_BACKSPACE);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_TAB].x, gptC1ButtonPos[C1K_TAB].y, 36, 28);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_TAB].x + 2, gptC1ButtonPos[C1K_TAB].y + 2,
32, 24, IDB_C1_TAB);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_CAPS].x, gptC1ButtonPos[C1K_CAPS].y, 42,
28);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_CAPS].x + 2, gptC1ButtonPos[C1K_CAPS].y + 2,
38, 24, IDB_C1_CAPS);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_ENTER].x, gptC1ButtonPos[C1K_ENTER].y, 42,
28);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_ENTER].x + 2, gptC1ButtonPos[C1K_ENTER].y +
2, 38, 24, IDB_C1_ENTER);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_SHIFT].x, gptC1ButtonPos[C1K_SHIFT].y, 60,
28);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_SHIFT].x + 2, gptC1ButtonPos[C1K_SHIFT].y +
2, 56, 24, IDB_C1_SHIFT);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_INSERT].x, gptC1ButtonPos[C1K_INSERT].y,
38, 24);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_INSERT].x + 2, gptC1ButtonPos[C1K_INSERT].y +
2, 34, 20, IDB_C1_INS);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_DELETE].x, gptC1ButtonPos[C1K_DELETE].y,
38, 24);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_DELETE].x + 2, gptC1ButtonPos[C1K_DELETE].y +
2, 34, 20, IDB_C1_DEL);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_SPACE].x, gptC1ButtonPos[C1K_SPACE].y, 172,
24);
+
+    C1_DrawConvexRect(hDC, gptC1ButtonPos[C1K_ESCAPE].x, gptC1ButtonPos[C1K_ESCAPE].y ,
38, 24);
+    Imm32DrawBitmap(hDC, gptC1ButtonPos[C1K_ESCAPE].x + 2, gptC1ButtonPos[C1K_ESCAPE].y +
2, 34, 20, IDB_C1_ESCAPE);
+}
+
+static INT
+C1_OnCreate(
+    _In_ HWND hWnd)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    HDC hDC, hMemDC;
+    RECT rc;
+    HGDIOBJ hbmOld;
+    HBITMAP hbmKeyboard;
+
+    hGlobal = GlobalAlloc(GHND, sizeof(C1WINDOW));
+    if (!hGlobal)
+        return -1;
+
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!pC1)
+    {
+        GlobalFree(hGlobal);
+        return -1;
+    }
+    SetWindowLongPtrW(hWnd, 0, (LONG_PTR)hGlobal);
+
+    if (!gbC1ButtonInit)
+    {
+        C1_InitButtonPos();
+        gbC1ButtonInit = TRUE;
+    }
+
+    pC1->iPressedKey = -1;
+    pC1->CharSet = GB2312_CHARSET;
+
+    GetClientRect(hWnd, &rc);
+
+    hDC = GetDC(hWnd);
+    hMemDC = CreateCompatibleDC(hDC);
+    hbmKeyboard = CreateCompatibleBitmap(hDC, rc.right - rc.left, rc.bottom - rc.top);
+    ReleaseDC(hWnd, hDC);
+
+    hbmOld = SelectObject(hMemDC, hbmKeyboard);
+    C1_InitBitmap(hMemDC, rc.left, rc.top, rc.right, rc.bottom);
+    SelectObject(hMemDC, hbmOld);
+    pC1->hbmKeyboard = hbmKeyboard;
+    DeleteDC(hMemDC);
+
+    GlobalUnlock(hGlobal);
+    return 0;
+}
+
+static void
+C1_OnDraw(
+    _In_ HDC hDC,
+    _In_ HWND hWnd)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    HDC hMemDC;
+    RECT rc;
+    HGDIOBJ hbmOld;
+
+    hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!hGlobal || !pC1)
+        return;
+
+    GetClientRect(hWnd, &rc);
+
+    hMemDC = CreateCompatibleDC(hDC);
+    hbmOld = SelectObject(hMemDC, pC1->hbmKeyboard);
+    BitBlt(hDC, 0, 0, rc.right - rc.left, rc.bottom - rc.top, hMemDC, 0, 0, SRCCOPY);
+    SelectObject(hMemDC, hbmOld);
+    DeleteDC(hMemDC);
+
+    GlobalUnlock(hGlobal);
+}
+
+static BOOL
+C1_SetData(
+    _In_ HWND hWnd,
+    _In_ const SOFTKBDDATA *pData)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    HDC hDC, hMemDC;
+    INT iKey;
+    BOOL bDisabled;
+    HBITMAP hbmKeyboard;
+    HGDIOBJ hbmOld, hFontOld;
+    HFONT hFont;
+    RECT rc;
+    LOGFONTW lf;
+
+    if (pData->uCount != 2)
+        return 0;
+
+    hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!hGlobal || !pC1)
+        return FALSE;
+
+    hDC = GetDC(hWnd);
+    hMemDC = CreateCompatibleDC(hDC);
+
+    hbmKeyboard = pC1->hbmKeyboard;
+    hbmOld = SelectObject(hMemDC, hbmKeyboard);
+
+    GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(lf), &lf);
+    lf.lfHeight = -12;
+    if (pC1->CharSet != DEFAULT_CHARSET)
+        lf.lfCharSet = (BYTE)pC1->CharSet;
+
+    hFont = CreateFontIndirectW(&lf);
+    hFontOld = SelectObject(hMemDC, hFont);
+    for (iKey = C1K_OEM_3; iKey < C1K_BACKSPACE; ++iKey)
+    {
+        pC1->Data[1][iKey] = pData->wCode[0][(BYTE)gC1K2VK[iKey]];
+        pC1->Data[0][iKey] = pData->wCode[1][(BYTE)gC1K2VK[iKey]];
+    }
+
+    SetBkColor(hMemDC, RGB(191, 191, 191));
+    for (iKey = C1K_OEM_3; iKey < C1K_BACKSPACE; ++iKey)
+    {
+        /* Upper right */
+        rc.right = gptC1ButtonPos[iKey].x + 24 - 2;
+        rc.top = gptC1ButtonPos[iKey].y + 2;
+        rc.left = rc.right - 14;
+        rc.bottom = rc.top + 14;
+        bDisabled = (pC1->Data[0][iKey] == 0);
+        DrawTextW(hMemDC, &pC1->Data[0][iKey], !bDisabled, &rc,
+                  DT_RIGHT | DT_TOP | DT_SINGLELINE);
+
+        /* Lower left */
+        rc.left = gptC1ButtonPos[iKey].x + 2;
+        rc.bottom = gptC1ButtonPos[iKey].y + 28 - 2;
+        rc.right = rc.left + 14;
+        rc.top = rc.bottom - 14;
+        bDisabled = (pC1->Data[1][iKey] == 0);
+        DrawTextW(hMemDC, &pC1->Data[1][iKey], !bDisabled, &rc,
+                  DT_LEFT | DT_BOTTOM | DT_SINGLELINE);
+    }
+
+    if (pC1->dwFlags & FLAG_SHIFT_PRESSED)
+        C1_InvertButton(hMemDC, C1K_SHIFT);
+
+    pC1->dwFlags = 0;
+
+    SelectObject(hMemDC, hbmOld);
+    DeleteObject(SelectObject(hMemDC, hFontOld));
+
+    DeleteDC(hMemDC);
+    ReleaseDC(hWnd, hDC);
+
+    GlobalUnlock(hGlobal);
+    return TRUE;
+}
+
+static void
+C1_DrawDragBorder(
+    _In_ HWND hWnd,
+    _In_ LPPOINT ppt1,
+    _Inout_ LPPOINT ppt2)
+{
+    HGDIOBJ hGrayBrush = GetStockObject(GRAY_BRUSH);
+    INT x, y;
+    RECT rc, rcWork;
+    INT cxBorder = GetSystemMetrics(SM_CXBORDER), cyBorder =
GetSystemMetrics(SM_CYBORDER);
+    HDC hDisplayDC;
+
+    Imm32GetAllMonitorSize(&rcWork);
+    hDisplayDC = CreateDCW(L"DISPLAY", NULL, NULL, NULL);
+
+    SelectObject(hDisplayDC, hGrayBrush);
+    x = ppt1->x - ppt2->x;
+    y = ppt1->y - ppt2->y;
+    if (x < rcWork.left)
+        x = rcWork.left;
+    if (y < rcWork.top)
+        y = rcWork.top;
+
+    GetWindowRect(hWnd, &rc);
+
+    if (rc.right - rc.left + x > rcWork.right)
+        x = rc.left + rcWork.right - rc.right;
+    if (y + rc.bottom - rc.top > rcWork.bottom)
+        y = rc.top + rcWork.bottom - rc.bottom;
+
+    ppt2->x = ppt1->x - x;
+    ppt2->y = ppt1->y - y;
+
+    PatBlt(hDisplayDC, x, y, rc.right - rc.left - cxBorder, cyBorder, PATINVERT);
+    PatBlt(hDisplayDC, x, y + cyBorder, cxBorder, rc.bottom - rc.top - cyBorder,
PATINVERT);
+    PatBlt(hDisplayDC, x + cxBorder, y + rc.bottom - rc.top, rc.right - rc.left -
cxBorder, -cyBorder, PATINVERT);
+    PatBlt(hDisplayDC, x + rc.right - rc.left, y, -cxBorder, rc.bottom - rc.top -
cyBorder, PATINVERT);
+
+    DeleteDC(hDisplayDC);
+}
+
+static INT
+C1_HitTest(
+    _In_ const POINT *ppt)
+{
+    INT iKey;
+
+    for (iKey = C1K_OEM_3; iKey < C1K_BACKSPACE; ++iKey)
+    {
+        if (Imm32PtInRect(ppt, gptC1ButtonPos[iKey].x, gptC1ButtonPos[iKey].y, 24, 28))
+            return iKey;
+    }
+
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_BACKSPACE].x,
gptC1ButtonPos[C1K_BACKSPACE].y, 36, 28))
+        return C1K_BACKSPACE;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_TAB].x, gptC1ButtonPos[C1K_TAB].y, 36, 28))
+        return C1K_TAB;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_CAPS].x, gptC1ButtonPos[C1K_CAPS].y, 42,
28))
+        return C1K_CAPS;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_ENTER].x, gptC1ButtonPos[C1K_ENTER].y, 42,
28))
+        return C1K_ENTER;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_SHIFT].x, gptC1ButtonPos[C1K_SHIFT].y, 60,
28))
+        return C1K_SHIFT;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_ESCAPE].x, gptC1ButtonPos[C1K_ESCAPE].y,
38, 24))
+        return C1K_ESCAPE;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_SPACE].x, gptC1ButtonPos[C1K_SPACE].y, 172,
24))
+        return C1K_SPACE;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_INSERT].x, gptC1ButtonPos[C1K_INSERT].y,
38, 24))
+        return C1K_INSERT;
+    if (Imm32PtInRect(ppt, gptC1ButtonPos[C1K_DELETE].x, gptC1ButtonPos[C1K_DELETE].y,
38, 24))
+        return C1K_DELETE;
+
+    return -1;
+}
+
+static void
+C1_OnButtonDown(
+    _In_ HWND hWnd,
+    _Inout_ PC1WINDOW pC1)
+{
+    INT iPressedKey;
+    HDC hMemDC;
+    WCHAR wch = 0xFF;
+    HGDIOBJ hbmOld;
+    HDC hDC;
+
+    SetCapture(hWnd);
+
+    iPressedKey = pC1->iPressedKey;
+    if (iPressedKey == -1)
+    {
+        pC1->dwFlags |= FLAG_DRAGGING;
+        C1_DrawDragBorder(hWnd, &pC1->pt1, &pC1->pt2);
+        return;
+    }
+
+    if (iPressedKey < C1K_BACKSPACE)
+    {
+        wch = pC1->Data[!(pC1->dwFlags & 1)][iPressedKey];
+        if (!wch)
+        {
+            MessageBeep(0xFFFFFFFF);
+            pC1->iPressedKey = -1;
+            return;
+        }
+    }
+
+    if ((iPressedKey != C1K_SHIFT) || !(pC1->dwFlags & FLAG_SHIFT_PRESSED))
+    {
+        hDC = GetDC(hWnd);
+        hMemDC = CreateCompatibleDC(hDC);
+        hbmOld = SelectObject(hMemDC, pC1->hbmKeyboard);
+        C1_InvertButton(hDC, pC1->iPressedKey);
+        C1_InvertButton(hMemDC, pC1->iPressedKey);
+        SelectObject(hMemDC, hbmOld);
+        DeleteDC(hMemDC);
+        ReleaseDC(hWnd, hDC);
+    }
+
+    pC1->dwFlags |= FLAG_PRESSED;
+}
+
+static BOOL
+C1_OnSetCursor(
+    _In_ HWND hWnd,
+    _In_ LPARAM lParam)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    HCURSOR hCursor;
+    INT iKey;
+    POINT pt1, pt2;
+
+    hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!hGlobal || !pC1)
+        return FALSE;
+
+    if (pC1->dwFlags & FLAG_DRAGGING)
+    {
+        hCursor = LoadCursorW(0, (LPCWSTR)IDC_SIZEALL);
+        SetCursor(hCursor);
+        GlobalUnlock(hGlobal);
+        return TRUE;
+    }
+
+    GetCursorPos(&pt1);
+    pt2 = pt1;
+    ScreenToClient(hWnd, &pt2);
+
+    iKey = C1_HitTest(&pt2);
+    if (iKey == -1)
+        hCursor = LoadCursorW(0, (LPCWSTR)IDC_SIZEALL);
+    else
+        hCursor = LoadCursorW(0, (LPCWSTR)IDC_HAND);
+    SetCursor(hCursor);
+
+    if (HIWORD(lParam) == WM_LBUTTONDOWN)
+    {
+        pC1->pt1 = pt1;
+        pC1->pt2 = pt2;
+        pC1->iPressedKey = iKey;
+        C1_OnButtonDown(hWnd, pC1);
+    }
+
+    GlobalUnlock(hGlobal);
+    return TRUE;
+}
+
+static BOOL
+C1_OnMouseMove(
+    _In_ HWND hWnd,
+    _In_ WPARAM wParam,
+    _In_ LPARAM lParam)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    HDC hMemDC;
+    DWORD dwFlags;
+    INT iPressedKey;
+    POINT pt;
+    HGDIOBJ hbmOld;
+    HDC hDC;
+    INT iKey;
+
+    hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!hGlobal || !pC1)
+        return FALSE;
+
+    if (pC1->dwFlags & FLAG_DRAGGING)
+    {
+        C1_DrawDragBorder(hWnd, &pC1->pt1, &pC1->pt2);
+        GetCursorPos(&pC1->pt1);
+        C1_DrawDragBorder(hWnd, &pC1->pt1, &pC1->pt2);
+        GlobalUnlock(hGlobal);
+        return TRUE;
+    }
+
+    if (pC1->iPressedKey != -1)
+    {
+        GetCursorPos(&pt);
+        ScreenToClient(hWnd, &pt);
+        iKey = C1_HitTest(&pt);
+
+        hDC = GetDC(hWnd);
+        hMemDC = CreateCompatibleDC(hDC);
+        hbmOld = SelectObject(hMemDC, pC1->hbmKeyboard);
+        dwFlags = pC1->dwFlags;
+
+        iPressedKey = pC1->iPressedKey;
+        if (!!(dwFlags & FLAG_PRESSED) == (iKey != iPressedKey))
+        {
+            if (iPressedKey != C1K_SHIFT || !(dwFlags & FLAG_SHIFT_PRESSED))
+            {
+                C1_InvertButton(hDC, iPressedKey);
+                C1_InvertButton(hMemDC, pC1->iPressedKey);
+            }
+
+            pC1->dwFlags ^= FLAG_PRESSED;
+        }
+
+        SelectObject(hMemDC, hbmOld);
+        DeleteDC(hMemDC);
+        ReleaseDC(hWnd, hDC);
+    }
+
+    GlobalUnlock(hGlobal);
+    return TRUE;
+}
+
+static BOOL
+C1_OnButtonUp(
+    _In_ HWND hWnd,
+    _In_ WPARAM wParam,
+    _In_ LPARAM lParam)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    BOOL ret = FALSE;
+    INT x, y, iKey;
+    HDC hDC, hMemDC;
+    HGDIOBJ hbmOld;
+    HIMC hIMC;
+    HWND hwndOwner;
+    LPINPUTCONTEXT pIC;
+
+    hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!hGlobal || !pC1)
+        return FALSE;
+
+    ReleaseCapture();
+
+    if (pC1->dwFlags & FLAG_DRAGGING)
+    {
+        pC1->dwFlags &= ~FLAG_DRAGGING;
+        C1_DrawDragBorder(hWnd, &pC1->pt1, &pC1->pt2);
+        x = pC1->pt1.x - pC1->pt2.x;
+        y = pC1->pt1.y - pC1->pt2.y;
+        SetWindowPos(hWnd, 0, x, y, 0, 0, 0x15u);
+        ret = TRUE;
+
+        hwndOwner = GetWindow(hWnd, GW_OWNER);
+        hIMC = (HIMC)GetWindowLongPtrW(hwndOwner, 0);
+        if (hIMC)
+        {
+            pIC = ImmLockIMC(hIMC);
+            if (pIC)
+            {
+                pIC->fdwInit |= INIT_SOFTKBDPOS;
+                pIC->ptSoftKbdPos.x = x;
+                pIC->ptSoftKbdPos.y = y;
+                ImmUnlockIMC(hIMC);
+            }
+        }
+
+        GlobalUnlock(hGlobal);
+        return ret;
+    }
+
+    iKey = pC1->iPressedKey;
+    if (iKey == -1)
+        return FALSE;
+
+    if (!(pC1->dwFlags & FLAG_PRESSED))
+    {
+        pC1->iPressedKey = -1;
+        GlobalUnlock(hGlobal);
+        return ret;
+    }
+
+    if (iKey == C1K_SHIFT)
+    {
+        if (!(pC1->dwFlags & FLAG_SHIFT_PRESSED))
+        {
+            pC1->dwFlags |= FLAG_SHIFT_PRESSED;
+            pC1->dwFlags &= ~FLAG_PRESSED;
+            pC1->iPressedKey = -1;
+            GlobalUnlock(hGlobal);
+            return ret;
+        }
+    }
+    else if (iKey < C1K_BACKSPACE && (pC1->dwFlags &
FLAG_SHIFT_PRESSED))
+    {
+        INT iVK = gC1K2VK[pC1->iPressedKey];
+        keybd_event(VK_SHIFT, guScanCode[C1K_SHIFT], 0, 0);
+        keybd_event(iVK, guScanCode[(BYTE)iVK], 0, 0);
+        keybd_event(iVK, guScanCode[(BYTE)iVK], KEYEVENTF_KEYUP, 0);
+        keybd_event(VK_SHIFT, guScanCode[C1K_SHIFT], KEYEVENTF_KEYUP, 0);
+    }
+    else
+    {
+        INT iVK = gC1K2VK[iKey];
+        keybd_event(iVK, guScanCode[iVK], 0, 0);
+        keybd_event(iVK, guScanCode[iVK], KEYEVENTF_KEYUP, 0);
+    }
+
+    ret = TRUE;
+
+    hDC = GetDC(hWnd);
+    hMemDC = CreateCompatibleDC(hDC);
+    hbmOld = SelectObject(hMemDC, pC1->hbmKeyboard);
+
+    C1_InvertButton(hDC, pC1->iPressedKey);
+    C1_InvertButton(hMemDC, pC1->iPressedKey);
+
+    if (pC1->iPressedKey < C1K_BACKSPACE && (pC1->dwFlags &
FLAG_SHIFT_PRESSED))
+    {
+        C1_InvertButton(hDC, C1K_SHIFT);
+        C1_InvertButton(hMemDC, C1K_SHIFT);
+    }
+
+    if (pC1->iPressedKey < C1K_BACKSPACE || pC1->iPressedKey == C1K_SHIFT)
+        pC1->dwFlags &= ~FLAG_SHIFT_PRESSED;
+
+    SelectObject(hMemDC, hbmOld);
+    DeleteDC(hMemDC);
+    ReleaseDC(hWnd, hDC);
+
+    pC1->dwFlags &= ~FLAG_PRESSED;
+    pC1->iPressedKey = -1;
+    GlobalUnlock(hGlobal);
+    return ret;
+}
+
+static void
+C1_OnDestroy(
+    _In_ HWND hWnd)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    HWND hwndOwner;
+
+    hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+    pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+    if (!hGlobal || !pC1)
+        return;
+
+    if (pC1->dwFlags & FLAG_DRAGGING)
+        C1_DrawDragBorder(hWnd, &pC1->pt1, &pC1->pt2);
+
+    DeleteObject(pC1->hbmKeyboard);
+    GlobalUnlock(hGlobal);
+    GlobalFree(hGlobal);
+
+    hwndOwner = GetWindow(hWnd, GW_OWNER);
+    if (hwndOwner)
+        SendMessageW(hwndOwner, WM_IME_NOTIFY, IMN_SOFTKBDDESTROYED, 0);
+}
+
+static LRESULT
+C1_OnImeControl(
+    _In_ HWND hWnd,
+    _In_ WPARAM wParam,
+    _In_ LPARAM lParam)
+{
+    HGLOBAL hGlobal;
+    PC1WINDOW pC1;
+    LOGFONTW lf;
+    RECT rc;
+    LRESULT ret = 0;
+    HDC hDC;
+
+    switch (wParam)
+    {
+        case IMC_GETSOFTKBDFONT:
+        {
+            TRACE("IMC_GETSOFTKBDFONT: %p\n", lParam);
+            hDC = GetDC(hWnd);
+            GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), &lf);
+            ReleaseDC(hWnd, hDC);
+            *(LPLOGFONTW)lParam = lf;
+            break;
+        }
+        case IMC_SETSOFTKBDFONT:
+        {
+            LPLOGFONTW plf = (LPLOGFONTW)lParam;
+            LOGFONTW lf;
+            TRACE("IMC_SETSOFTKBDFONT: %p\n", lParam);
+            GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), &lf);
+            if (lf.lfCharSet == plf->lfCharSet)
+                return 0;
+
+            hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+            pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+            if (!hGlobal || !pC1)
+                return 1;
+
+            pC1->CharSet = plf->lfCharSet;
+            GlobalUnlock(hGlobal);
+            break;
+        }
+        case IMC_GETSOFTKBDPOS:
+        {
+            TRACE("IMC_GETSOFTKBDPOS\n");
+            GetWindowRect(hWnd, &rc);
+            return MAKELRESULT(rc.left, rc.top);
+        }
+        case IMC_SETSOFTKBDPOS:
+        {
+            POINT pt;
+            POINTSTOPOINT(pt, lParam);
+            TRACE("IMC_SETSOFTKBDPOS: %d, %d\n", pt.x, pt.y);
+            SetWindowPos(hWnd, NULL, pt.x, pt.y, 0, 0,
+                         (SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE));
+            break;
+        }
+        case IMC_GETSOFTKBDSUBTYPE:
+        case IMC_SETSOFTKBDSUBTYPE:
+        {
+            TRACE("IMC_GETSOFTKBDSUBTYPE/IMC_SETSOFTKBDSUBTYPE: %p, %p\n",
wParam, lParam);
+            hGlobal = (HGLOBAL)GetWindowLongPtrW(hWnd, 0);
+            pC1 = (PC1WINDOW)GlobalLock(hGlobal);
+            if (!hGlobal || !pC1)
+                return -1;
+            ret = pC1->SubType;
+            if (wParam == IMC_SETSOFTKBDSUBTYPE)
+                pC1->SubType = lParam;
+            GlobalUnlock(hGlobal);
+            break;
+        }
+        case IMC_SETSOFTKBDDATA:
+        {
+            TRACE("IMC_SETSOFTKBDDATA: %p\n", lParam);
+            if (C1_SetData(hWnd, (SOFTKBDDATA*)lParam))
+                return -1;
+
+            InvalidateRect(hWnd, 0, 0);
+        }
+        default:
+            break;
+    }
+
+    return ret;
+}
+
 static LRESULT CALLBACK
 C1_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
@@ -1130,10 +1988,47 @@ C1_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     {
         case WM_CREATE:
         {
-            FIXME("stub\n");
-            return -1;
+            return C1_OnCreate(hWnd);
+        }
+        case WM_DESTROY:
+        {
+            C1_OnDestroy(hWnd);
+            break;
+        }
+        case WM_SETCURSOR:
+        {
+            if (C1_OnSetCursor(hWnd, lParam))
+                break;
+            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+        }
+        case WM_MOUSEMOVE:
+        {
+            if (C1_OnMouseMove(hWnd, wParam, lParam))
+                break;
+            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+        }
+        case WM_LBUTTONUP:
+        {
+            if (C1_OnButtonUp(hWnd, wParam, lParam))
+                break;
+            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+        }
+        case WM_PAINT:
+        {
+            PAINTSTRUCT ps;
+            HDC hDC = BeginPaint(hWnd, &ps);
+            C1_OnDraw(hDC, hWnd);
+            EndPaint(hWnd, &ps);
+            break;
+        }
+        case WM_IME_CONTROL:
+        {
+            return C1_OnImeControl(hWnd, wParam, lParam);
+        }
+        case WM_MOUSEACTIVATE:
+        {
+            return MA_NOACTIVATE;
         }
-
         default:
         {
             return DefWindowProcW(hWnd, uMsg, wParam, lParam);
@@ -1218,6 +2113,8 @@ ImmCreateSoftKeyboard(
     LPCWSTR pszClass;
     RECT rcWorkArea;
+    TRACE("(%u, %p, %d, %d)\n", uType, hwndParent, x, y);
+
     if ((uType != SOFTKEYBOARD_TYPE_T1) && (uType != SOFTKEYBOARD_TYPE_C1))
     {
         ERR("uType: %u\n", uType);