dlls/imm32/ime.c

   1 /*
   2  * Copyright 2023 Rémi Bernon for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <stddef.h>
  21
  22 #include "imm_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(imm);
  25
  26 struct ime_private
  27 {
  28     BOOL in_composition;
  29     HFONT hfont;
  30 };
  31
  32 static const char *debugstr_imn( WPARAM wparam )
  33 {
  34     switch (wparam)
  35     {
  36     case IMN_OPENSTATUSWINDOW: return "IMN_OPENSTATUSWINDOW";
  37     case IMN_CLOSESTATUSWINDOW: return "IMN_CLOSESTATUSWINDOW";
  38     case IMN_OPENCANDIDATE: return "IMN_OPENCANDIDATE";
  39     case IMN_CHANGECANDIDATE: return "IMN_CHANGECANDIDATE";
  40     case IMN_CLOSECANDIDATE: return "IMN_CLOSECANDIDATE";
  41     case IMN_SETCONVERSIONMODE: return "IMN_SETCONVERSIONMODE";
  42     case IMN_SETSENTENCEMODE: return "IMN_SETSENTENCEMODE";
  43     case IMN_SETOPENSTATUS: return "IMN_SETOPENSTATUS";
  44     case IMN_SETCANDIDATEPOS: return "IMN_SETCANDIDATEPOS";
  45     case IMN_SETCOMPOSITIONFONT: return "IMN_SETCOMPOSITIONFONT";
  46     case IMN_SETCOMPOSITIONWINDOW: return "IMN_SETCOMPOSITIONWINDOW";
  47     case IMN_GUIDELINE: return "IMN_GUIDELINE";
  48     case IMN_SETSTATUSWINDOWPOS: return "IMN_SETSTATUSWINDOWPOS";
  49     case IMN_WINE_SET_OPEN_STATUS: return "IMN_WINE_SET_OPEN_STATUS";
  50     case IMN_WINE_SET_COMP_STRING: return "IMN_WINE_SET_COMP_STRING";
  51     default: return wine_dbg_sprintf( "%#Ix", wparam );
  52     }
  53 }
  54
  55 static const char *debugstr_imc( WPARAM wparam )
  56 {
  57     switch (wparam)
  58     {
  59     case IMC_GETCANDIDATEPOS: return "IMC_GETCANDIDATEPOS";
  60     case IMC_SETCANDIDATEPOS: return "IMC_SETCANDIDATEPOS";
  61     case IMC_GETCOMPOSITIONFONT: return "IMC_GETCOMPOSITIONFONT";
  62     case IMC_SETCOMPOSITIONFONT: return "IMC_SETCOMPOSITIONFONT";
  63     case IMC_GETCOMPOSITIONWINDOW: return "IMC_GETCOMPOSITIONWINDOW";
  64     case IMC_SETCOMPOSITIONWINDOW: return "IMC_SETCOMPOSITIONWINDOW";
  65     case IMC_GETSTATUSWINDOWPOS: return "IMC_GETSTATUSWINDOWPOS";
  66     case IMC_SETSTATUSWINDOWPOS: return "IMC_SETSTATUSWINDOWPOS";
  67     case IMC_CLOSESTATUSWINDOW: return "IMC_CLOSESTATUSWINDOW";
  68     case IMC_OPENSTATUSWINDOW: return "IMC_OPENSTATUSWINDOW";
  69     default: return wine_dbg_sprintf( "%#Ix", wparam );
  70     }
  71 }
  72
  73 static WCHAR *input_context_get_comp_str( INPUTCONTEXT *ctx, BOOL result, UINT *length )
  74 {
  75     COMPOSITIONSTRING *string;
  76     WCHAR *text = NULL;
  77     UINT len, off;
  78
  79     if (!(string = ImmLockIMCC( ctx->hCompStr ))) return NULL;
  80     len = result ? string->dwResultStrLen : string->dwCompStrLen;
  81     off = result ? string->dwResultStrOffset : string->dwCompStrOffset;
  82
  83     if (len && off && (text = malloc( (len + 1) * sizeof(WCHAR) )))
  84     {
  85         memcpy( text, (BYTE *)string + off, len * sizeof(WCHAR) );
  86         text[len] = 0;
  87         *length = len;
  88     }
  89
  90     ImmUnlockIMCC( ctx->hCompStr );
  91     return text;
  92 }
  93
  94 static void input_context_set_comp_str( INPUTCONTEXT *ctx, const WCHAR *str, UINT len )
  95 {
  96     COMPOSITIONSTRING *compstr;
  97     HIMCC himcc;
  98     UINT size;
  99     BYTE *dst;
 100
 101     size = sizeof(*compstr);
 102     size += len * sizeof(WCHAR); /* GCS_COMPSTR */
 103     size += len; /* GCS_COMPSTRATTR */
 104     size += 2 * sizeof(DWORD); /* GCS_COMPSTRCLAUSE */
 105
 106     if (!(himcc = ImmReSizeIMCC( ctx->hCompStr, size )))
 107         WARN( "Failed to resize input context composition string\n" );
 108     else if (!(compstr = ImmLockIMCC( (ctx->hCompStr = himcc) )))
 109         WARN( "Failed to lock input context composition string\n" );
 110     else
 111     {
 112         memset( compstr, 0, sizeof(*compstr) );
 113         compstr->dwSize = sizeof(*compstr);
 114
 115         if (len)
 116         {
 117             compstr->dwCursorPos = len;
 118
 119             compstr->dwCompStrLen = len;
 120             compstr->dwCompStrOffset = compstr->dwSize;
 121             dst = (BYTE *)compstr + compstr->dwCompStrOffset;
 122             memcpy( dst, str, compstr->dwCompStrLen * sizeof(WCHAR) );
 123             compstr->dwSize += compstr->dwCompStrLen * sizeof(WCHAR);
 124
 125             compstr->dwCompClauseLen = 2 * sizeof(DWORD);
 126             compstr->dwCompClauseOffset = compstr->dwSize;
 127             dst = (BYTE *)compstr + compstr->dwCompClauseOffset;
 128             *((DWORD *)dst + 0) = 0;
 129             *((DWORD *)dst + 1) = compstr->dwCompStrLen;
 130             compstr->dwSize += compstr->dwCompClauseLen;
 131
 132             compstr->dwCompAttrLen = compstr->dwCompStrLen;
 133             compstr->dwCompAttrOffset = compstr->dwSize;
 134             dst = (BYTE *)compstr + compstr->dwCompAttrOffset;
 135             memset( dst, ATTR_INPUT, compstr->dwCompAttrLen );
 136             compstr->dwSize += compstr->dwCompAttrLen;
 137         }
 138
 139         ImmUnlockIMCC( ctx->hCompStr );
 140     }
 141 }
 142
 143 static HFONT input_context_select_ui_font( INPUTCONTEXT *ctx, HDC hdc )
 144 {
 145     struct ime_private *priv;
 146     HFONT font = NULL;
 147     if (!(priv = ImmLockIMCC( ctx->hPrivate ))) return NULL;
 148     if (priv->hfont) font = SelectObject( hdc, priv->hfont );
 149     ImmUnlockIMCC( ctx->hPrivate );
 150     return font;
 151 }
 152
 153 static void ime_send_message( HIMC himc, UINT message, WPARAM wparam, LPARAM lparam )
 154 {
 155     INPUTCONTEXT *ctx;
 156     TRANSMSG *msgs;
 157     HIMCC himcc;
 158
 159     if (!(ctx = ImmLockIMC( himc ))) return;
 160     if (!(himcc = ImmReSizeIMCC( ctx->hMsgBuf, (ctx->dwNumMsgBuf + 1) * sizeof(*msgs) )))
 161         WARN( "Failed to resize input context message buffer\n" );
 162     else if (!(msgs = ImmLockIMCC( (ctx->hMsgBuf = himcc) )))
 163         WARN( "Failed to lock input context message buffer\n" );
 164     else
 165     {
 166         TRANSMSG msg = {.message = message, .wParam = wparam, .lParam = lparam};
 167         msgs[ctx->dwNumMsgBuf++] = msg;
 168         ImmUnlockIMCC( ctx->hMsgBuf );
 169     }
 170
 171     ImmUnlockIMC( himc );
 172     ImmGenerateMessage( himc );
 173 }
 174
 175 static UINT ime_set_composition_status( HIMC himc, BOOL composition )
 176 {
 177     struct ime_private *priv;
 178     INPUTCONTEXT *ctx;
 179     UINT msg = 0;
 180
 181     if (!(ctx = ImmLockIMC( himc ))) return 0;
 182     if ((priv = ImmLockIMCC( ctx->hPrivate )))
 183     {
 184         if (!priv->in_composition && composition) msg = WM_IME_STARTCOMPOSITION;
 185         else if (priv->in_composition && !composition) msg = WM_IME_ENDCOMPOSITION;
 186         priv->in_composition = composition;
 187         ImmUnlockIMCC( ctx->hPrivate );
 188     }
 189     ImmUnlockIMC( himc );
 190
 191     return msg;
 192 }
 193
 194 static void ime_ui_paint( HIMC himc, HWND hwnd )
 195 {
 196     PAINTSTRUCT ps;
 197     RECT rect, new_rect;
 198     HDC hdc;
 199     HMONITOR monitor;
 200     MONITORINFO mon_info;
 201     INPUTCONTEXT *ctx;
 202     POINT offset;
 203     WCHAR *str;
 204     UINT len;
 205
 206     if (!(ctx = ImmLockIMC( himc ))) return;
 207
 208     hdc = BeginPaint( hwnd, &ps );
 209
 210     GetClientRect( hwnd, &rect );
 211     FillRect( hdc, &rect, (HBRUSH)(COLOR_WINDOW + 1) );
 212     new_rect = rect;
 213
 214     if ((str = input_context_get_comp_str( ctx, FALSE, &len )))
 215     {
 216         HFONT font = input_context_select_ui_font( ctx, hdc );
 217         SIZE size;
 218         POINT pt;
 219
 220         GetTextExtentPoint32W( hdc, str, len, &size );
 221         pt.x = size.cx;
 222         pt.y = size.cy;
 223         LPtoDP( hdc, &pt, 1 );
 224
 225         /*
 226          * How this works based on tests on windows:
 227          * CFS_POINT: then we start our window at the point and grow it as large
 228          *    as it needs to be for the string.
 229          * CFS_RECT:  we still use the ptCurrentPos as a starting point and our
 230          *    window is only as large as we need for the string, but we do not
 231          *    grow such that our window exceeds the given rect.  Wrapping if
 232          *    needed and possible.   If our ptCurrentPos is outside of our rect
 233          *    then no window is displayed.
 234          * CFS_FORCE_POSITION: appears to behave just like CFS_POINT
 235          *    maybe because the default MSIME does not do any IME adjusting.
 236          */
 237         if (ctx->cfCompForm.dwStyle != CFS_DEFAULT)
 238         {
 239             POINT cpt = ctx->cfCompForm.ptCurrentPos;
 240             ClientToScreen( ctx->hWnd, &cpt );
 241             rect.left = cpt.x;
 242             rect.top = cpt.y;
 243             rect.right = rect.left + pt.x;
 244             rect.bottom = rect.top + pt.y;
 245             offset.x = offset.y = 0;
 246             monitor = MonitorFromPoint( cpt, MONITOR_DEFAULTTOPRIMARY );
 247         }
 248         else /* CFS_DEFAULT */
 249         {
 250             /* Windows places the default IME window in the bottom left */
 251             HWND target = ctx->hWnd;
 252             if (!target) target = GetFocus();
 253
 254             GetWindowRect( target, &rect );
 255             rect.top = rect.bottom;
 256             rect.right = rect.left + pt.x + 20;
 257             rect.bottom = rect.top + pt.y + 20;
 258             offset.x = offset.y = 10;
 259             monitor = MonitorFromWindow( target, MONITOR_DEFAULTTOPRIMARY );
 260         }
 261
 262         if (ctx->cfCompForm.dwStyle == CFS_RECT)
 263         {
 264             RECT client = ctx->cfCompForm.rcArea;
 265             MapWindowPoints( ctx->hWnd, 0, (POINT *)&client, 2 );
 266             IntersectRect( &rect, &rect, &client );
 267             DrawTextW( hdc, str, len, &rect, DT_WORDBREAK | DT_CALCRECT );
 268         }
 269
 270         if (ctx->cfCompForm.dwStyle == CFS_DEFAULT)
 271         {
 272             /* make sure we are on the desktop */
 273             mon_info.cbSize = sizeof(mon_info);
 274             GetMonitorInfoW( monitor, &mon_info );
 275
 276             if (rect.bottom > mon_info.rcWork.bottom)
 277             {
 278                 int shift = rect.bottom - mon_info.rcWork.bottom;
 279                 rect.top -= shift;
 280                 rect.bottom -= shift;
 281             }
 282             if (rect.left < 0)
 283             {
 284                 rect.right -= rect.left;
 285                 rect.left = 0;
 286             }
 287             if (rect.right > mon_info.rcWork.right)
 288             {
 289                 int shift = rect.right - mon_info.rcWork.right;
 290                 rect.left -= shift;
 291                 rect.right -= shift;
 292             }
 293         }
 294
 295         new_rect = rect;
 296         OffsetRect( &rect, offset.x - rect.left, offset.y - rect.top );
 297         DrawTextW( hdc, str, len, &rect, DT_WORDBREAK );
 298
 299         if (font) SelectObject( hdc, font );
 300         free( str );
 301     }
 302
 303     EndPaint( hwnd, &ps );
 304     ImmUnlockIMC( himc );
 305
 306     if (!EqualRect( &rect, &new_rect ))
 307         SetWindowPos( hwnd, HWND_TOPMOST, new_rect.left, new_rect.top, new_rect.right - new_rect.left,
 308                       new_rect.bottom - new_rect.top, SWP_NOACTIVATE );
 309 }
 310
 311 static void ime_ui_update_window( INPUTCONTEXT *ctx, HWND hwnd )
 312 {
 313     COMPOSITIONSTRING *string;
 314
 315     if (ctx->hCompStr) string = ImmLockIMCC( ctx->hCompStr );
 316     else string = NULL;
 317
 318     if (!string || string->dwCompStrLen == 0)
 319         ShowWindow( hwnd, SW_HIDE );
 320     else
 321     {
 322         ShowWindow( hwnd, SW_SHOWNOACTIVATE );
 323         RedrawWindow( hwnd, NULL, NULL, RDW_ERASENOW | RDW_INVALIDATE );
 324     }
 325
 326     if (string) ImmUnlockIMCC( ctx->hCompStr );
 327
 328     ctx->hWnd = GetFocus();
 329 }
 330
 331 static void ime_ui_composition( HIMC himc, HWND hwnd, LPARAM lparam )
 332 {
 333     INPUTCONTEXT *ctx;
 334     if (lparam & GCS_RESULTSTR) return;
 335     if (!(ctx = ImmLockIMC( himc ))) return;
 336     ime_ui_update_window( ctx, hwnd );
 337     ImmUnlockIMC( himc );
 338 }
 339
 340 static void ime_ui_start_composition( HIMC himc, HWND hwnd )
 341 {
 342     INPUTCONTEXT *ctx;
 343     if (!(ctx = ImmLockIMC( himc ))) return;
 344     ime_ui_update_window( ctx, hwnd );
 345     ImmUnlockIMC( himc );
 346 }
 347
 348 static UINT ime_set_comp_string( HIMC himc, LPARAM lparam )
 349 {
 350     union
 351     {
 352         struct
 353         {
 354             UINT uMsgCount;
 355             TRANSMSG TransMsg[10];
 356         };
 357         TRANSMSGLIST list;
 358     } buffer = {.uMsgCount = ARRAY_SIZE(buffer.TransMsg)};
 359     INPUTCONTEXT *ctx;
 360     TRANSMSG *msgs;
 361     HIMCC himcc;
 362     UINT count;
 363
 364     TRACE( "himc %p\n", himc );
 365
 366     if (!(ctx = ImmLockIMC( himc ))) return 0;
 367
 368     count = ImeToAsciiEx( VK_PROCESSKEY, lparam, NULL, &buffer.list, 0, himc );
 369     if (!count)
 370         TRACE( "ImeToAsciiEx returned no messages\n" );
 371     else if (count >= buffer.uMsgCount)
 372         WARN( "ImeToAsciiEx returned %#x messages\n", count );
 373     else if (!(himcc = ImmReSizeIMCC( ctx->hMsgBuf, (ctx->dwNumMsgBuf + count) * sizeof(*msgs) )))
 374         WARN( "Failed to resize input context message buffer\n" );
 375     else if (!(msgs = ImmLockIMCC( (ctx->hMsgBuf = himcc) )))
 376         WARN( "Failed to lock input context message buffer\n" );
 377     else
 378     {
 379         memcpy( msgs + ctx->dwNumMsgBuf, buffer.TransMsg, count * sizeof(*msgs) );
 380         ImmUnlockIMCC( ctx->hMsgBuf );
 381         ctx->dwNumMsgBuf += count;
 382     }
 383
 384     ImmUnlockIMC( himc );
 385     ImmGenerateMessage( himc );
 386
 387     return count;
 388 }
 389
 390 static LRESULT ime_ui_notify( HIMC himc, HWND hwnd, WPARAM wparam, LPARAM lparam )
 391 {
 392     TRACE( "himc %p, hwnd %p, wparam %s, lparam %#Ix\n", hwnd, himc, debugstr_imn(wparam), lparam );
 393
 394     switch (wparam)
 395     {
 396     case IMN_WINE_SET_OPEN_STATUS:
 397         return ImmSetOpenStatus( himc, lparam );
 398     case IMN_WINE_SET_COMP_STRING:
 399         return ime_set_comp_string( himc, lparam );
 400     default:
 401         return 0;
 402     }
 403 }
 404
 405 static LRESULT WINAPI ime_ui_window_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 406 {
 407     HIMC himc = (HIMC)GetWindowLongPtrW( hwnd, IMMGWL_IMC );
 408
 409     TRACE( "hwnd %p, himc %p, msg %s, wparam %#Ix, lparam %#Ix\n",
 410            hwnd, himc, debugstr_wm_ime(msg), wparam, lparam );
 411
 412     switch (msg)
 413     {
 414     case WM_CREATE:
 415         return TRUE;
 416     case WM_PAINT:
 417         ime_ui_paint( himc, hwnd );
 418         return FALSE;
 419     case WM_SETFOCUS:
 420         if (wparam) SetFocus( (HWND)wparam );
 421         else FIXME( "Received focus, should never have focus\n" );
 422         break;
 423     case WM_IME_COMPOSITION:
 424         ime_ui_composition( himc, hwnd, lparam );
 425         break;
 426     case WM_IME_STARTCOMPOSITION:
 427         ime_ui_start_composition( himc, hwnd );
 428         break;
 429     case WM_IME_ENDCOMPOSITION:
 430         ShowWindow( hwnd, SW_HIDE );
 431         break;
 432     case WM_IME_NOTIFY:
 433         return ime_ui_notify( himc, hwnd, wparam, lparam );
 434     case WM_IME_CONTROL:
 435         FIXME( "hwnd %p, himc %p, msg %s, wparam %s, lparam %#Ix stub!\n", hwnd, himc,
 436                debugstr_wm_ime(msg), debugstr_imc(wparam), lparam );
 437         return 1;
 438     }
 439
 440     return DefWindowProcW( hwnd, msg, wparam, lparam );
 441 }
 442
 443 static WNDCLASSEXW ime_ui_class =
 444 {
 445     .cbSize = sizeof(WNDCLASSEXW),
 446     .style = CS_GLOBALCLASS | CS_IME | CS_HREDRAW | CS_VREDRAW,
 447     .lpfnWndProc = ime_ui_window_proc,
 448     .cbWndExtra = 2 * sizeof(LONG_PTR),
 449     .lpszClassName = L"Wine IME",
 450     .hbrBackground = (HBRUSH)(COLOR_WINDOW + 1),
 451 };
 452
 453 BOOL WINAPI ImeInquire( IMEINFO *info, WCHAR *ui_class, DWORD flags )
 454 {
 455     TRACE( "info %p, ui_class %p, flags %#lx\n", info, ui_class, flags );
 456
 457     ime_ui_class.hInstance = imm32_module;
 458     ime_ui_class.hCursor = LoadCursorW( NULL, (LPWSTR)IDC_ARROW );
 459     ime_ui_class.hIcon = LoadIconW( NULL, (LPWSTR)IDI_APPLICATION );
 460     RegisterClassExW( &ime_ui_class );
 461
 462     wcscpy( ui_class, ime_ui_class.lpszClassName );
 463     memset( info, 0, sizeof(*info) );
 464     info->dwPrivateDataSize = sizeof(struct ime_private);
 465     info->fdwProperty = IME_PROP_UNICODE | IME_PROP_AT_CARET;
 466     info->fdwConversionCaps = IME_CMODE_NATIVE | IME_CMODE_FULLSHAPE;
 467     info->fdwSentenceCaps = IME_SMODE_AUTOMATIC;
 468     info->fdwUICaps = UI_CAP_2700;
 469     /* Tell App we cannot accept ImeSetCompositionString calls */
 470     info->fdwSCSCaps = 0;
 471     info->fdwSelectCaps = SELECT_CAP_CONVERSION;
 472
 473     return TRUE;
 474 }
 475
 476 BOOL WINAPI ImeDestroy( UINT force )
 477 {
 478     TRACE( "force %u\n", force );
 479     UnregisterClassW( ime_ui_class.lpszClassName, imm32_module );
 480     return TRUE;
 481 }
 482
 483 BOOL WINAPI ImeSelect( HIMC himc, BOOL select )
 484 {
 485     struct ime_private *priv;
 486     INPUTCONTEXT *ctx;
 487
 488     TRACE( "himc %p, select %u\n", himc, select );
 489
 490     if (!himc || !select) return TRUE;
 491     if (!(ctx = ImmLockIMC( himc ))) return FALSE;
 492
 493     ImmSetOpenStatus( himc, FALSE );
 494
 495     if ((priv = ImmLockIMCC( ctx->hPrivate )))
 496     {
 497         memset( priv, 0, sizeof(*priv) );
 498         ImmUnlockIMCC( ctx->hPrivate );
 499     }
 500
 501     ImmUnlockIMC( himc );
 502     return TRUE;
 503 }
 504
 505 BOOL WINAPI ImeSetActiveContext( HIMC himc, BOOL flag )
 506 {
 507     TRACE( "himc %p, flag %#x stub!\n", himc, flag );
 508     return TRUE;
 509 }
 510
 511 BOOL WINAPI ImeProcessKey( HIMC himc, UINT vkey, LPARAM lparam, BYTE *state )
 512 {
 513     struct ime_driver_call_params params = {.himc = himc, .state = state};
 514     INPUTCONTEXT *ctx;
 515     LRESULT ret;
 516
 517     TRACE( "himc %p, vkey %#x, lparam %#Ix, state %p\n", himc, vkey, lparam, state );
 518
 519     if (!(ctx = ImmLockIMC( himc ))) return FALSE;
 520     ret = NtUserMessageCall( ctx->hWnd, WINE_IME_PROCESS_KEY, vkey, lparam, &params,
 521                              NtUserImeDriverCall, FALSE );
 522     ImmUnlockIMC( himc );
 523
 524     return ret;
 525 }
 526
 527 UINT WINAPI ImeToAsciiEx( UINT vkey, UINT vsc, BYTE *state, TRANSMSGLIST *msgs, UINT flags, HIMC himc )
 528 {
 529     COMPOSITIONSTRING *compstr;
 530     UINT size, count = 0;
 531     INPUTCONTEXT *ctx;
 532     NTSTATUS status;
 533
 534     TRACE( "vkey %#x, vsc %#x, state %p, msgs %p, flags %#x, himc %p\n",
 535            vkey, vsc, state, msgs, flags, himc );
 536
 537     if (!(ctx = ImmLockIMC( himc ))) return 0;
 538     if (!(compstr = ImmLockIMCC( ctx->hCompStr ))) goto done;
 539     size = max( compstr->dwSize, sizeof(COMPOSITIONSTRING) );
 540
 541     do
 542     {
 543         struct ime_driver_call_params params = {.himc = himc, .state = state};
 544         HIMCC himcc;
 545
 546         ImmUnlockIMCC( ctx->hCompStr );
 547         if (!(himcc = ImmReSizeIMCC( ctx->hCompStr, size ))) goto done;
 548         if (!(compstr = ImmLockIMCC( (ctx->hCompStr = himcc) ))) goto done;
 549
 550         params.compstr = compstr;
 551         status = NtUserMessageCall( ctx->hWnd, WINE_IME_TO_ASCII_EX, vkey, vsc, &params,
 552                                     NtUserImeDriverCall, FALSE );
 553         size = compstr->dwSize;
 554     } while (status == STATUS_BUFFER_TOO_SMALL);
 555
 556     if (status) WARN( "WINE_IME_TO_ASCII_EX returned status %#lx\n", status );
 557     else
 558     {
 559         TRANSMSG status_msg = {.message = ime_set_composition_status( himc, !!compstr->dwCompStrOffset )};
 560         if (status_msg.message) msgs->TransMsg[count++] = status_msg;
 561
 562         if (compstr->dwResultStrOffset)
 563         {
 564             const WCHAR *result = (WCHAR *)((BYTE *)compstr + compstr->dwResultStrOffset);
 565             TRANSMSG msg = {.message = WM_IME_COMPOSITION, .wParam = result[0], .lParam = GCS_RESULTSTR};
 566             if (compstr->dwResultClauseOffset) msg.lParam |= GCS_RESULTCLAUSE;
 567             msgs->TransMsg[count++] = msg;
 568         }
 569
 570         if (compstr->dwCompStrOffset)
 571         {
 572             const WCHAR *comp = (WCHAR *)((BYTE *)compstr + compstr->dwCompStrOffset);
 573             TRANSMSG msg = {.message = WM_IME_COMPOSITION, .wParam = comp[0], .lParam = GCS_COMPSTR | GCS_CURSORPOS | GCS_DELTASTART};
 574             if (compstr->dwCompAttrOffset) msg.lParam |= GCS_COMPATTR;
 575             if (compstr->dwCompClauseOffset) msg.lParam |= GCS_COMPCLAUSE;
 576             else msg.lParam |= CS_INSERTCHAR|CS_NOMOVECARET;
 577             msgs->TransMsg[count++] = msg;
 578         }
 579     }
 580
 581     ImmUnlockIMCC( ctx->hCompStr );
 582
 583 done:
 584     if (count >= msgs->uMsgCount) FIXME( "More than %u messages queued, messages possibly lost\n", msgs->uMsgCount );
 585     else TRACE( "Returning %u messages queued\n", count );
 586     ImmUnlockIMC( himc );
 587     return count;
 588 }
 589
 590 BOOL WINAPI ImeConfigure( HKL hkl, HWND hwnd, DWORD mode, void *data )
 591 {
 592     FIXME( "hkl %p, hwnd %p, mode %lu, data %p stub!\n", hkl, hwnd, mode, data );
 593     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 594     return FALSE;
 595 }
 596
 597 DWORD WINAPI ImeConversionList( HIMC himc, const WCHAR *source, CANDIDATELIST *dest, DWORD dest_len, UINT flag )
 598 {
 599     FIXME( "himc %p, source %s, dest %p, dest_len %lu, flag %#x stub!\n",
 600            himc, debugstr_w(source), dest, dest_len, flag );
 601     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 602     return 0;
 603 }
 604
 605 BOOL WINAPI ImeSetCompositionString( HIMC himc, DWORD index, const void *comp, DWORD comp_len,
 606                                      const void *read, DWORD read_len )
 607 {
 608     INPUTCONTEXT *ctx;
 609
 610     FIXME( "himc %p, index %lu, comp %p, comp_len %lu, read %p, read_len %lu semi-stub!\n",
 611             himc, index, comp, comp_len, read, read_len );
 612     if (read && read_len) FIXME( "Read string unimplemented\n" );
 613     if (index != SCS_SETSTR && index != SCS_CHANGECLAUSE && index != SCS_CHANGEATTR) return FALSE;
 614
 615     if (!(ctx = ImmLockIMC( himc ))) return FALSE;
 616
 617     if (index != SCS_SETSTR)
 618         FIXME( "index %#lx not implemented\n", index );
 619     else
 620     {
 621         UINT msg, flags = GCS_COMPSTR | GCS_COMPCLAUSE | GCS_COMPATTR | GCS_DELTASTART | GCS_CURSORPOS;
 622         WCHAR wparam = comp && comp_len >= sizeof(WCHAR) ? *(WCHAR *)comp : 0;
 623         input_context_set_comp_str( ctx, comp, comp_len / sizeof(WCHAR) );
 624         if ((msg = ime_set_composition_status( himc, TRUE ))) ime_send_message( himc, msg, 0, 0 );
 625         ime_send_message( himc, WM_IME_COMPOSITION, wparam, flags );
 626     }
 627
 628     ImmUnlockIMC( himc );
 629
 630     return TRUE;
 631 }
 632
 633 BOOL WINAPI NotifyIME( HIMC himc, DWORD action, DWORD index, DWORD value )
 634 {
 635     struct ime_private *priv;
 636     INPUTCONTEXT *ctx;
 637     UINT msg;
 638
 639     TRACE( "himc %p, action %#lx, index %#lx, value %#lx stub!\n", himc, action, index, value );
 640
 641     if (!(ctx = ImmLockIMC( himc ))) return FALSE;
 642
 643     switch (action)
 644     {
 645     case NI_CONTEXTUPDATED:
 646         switch (value)
 647         {
 648         case IMC_SETCOMPOSITIONFONT:
 649             if ((priv = ImmLockIMCC( ctx->hPrivate )))
 650             {
 651                 if (priv->hfont) DeleteObject( priv->hfont );
 652                 priv->hfont = CreateFontIndirectW( &ctx->lfFont.W );
 653                 ImmUnlockIMCC( ctx->hPrivate );
 654             }
 655             break;
 656         case IMC_SETOPENSTATUS:
 657             if (!ctx->fOpen)
 658             {
 659                 input_context_set_comp_str( ctx, NULL, 0 );
 660                 if ((msg = ime_set_composition_status( himc, FALSE ))) ime_send_message( himc, msg, 0, 0 );
 661             }
 662             NtUserNotifyIMEStatus( ctx->hWnd, ctx->fOpen );
 663             break;
 664         }
 665         break;
 666
 667     case NI_COMPOSITIONSTR:
 668         switch (index)
 669         {
 670         case CPS_COMPLETE:
 671         {
 672             COMPOSITIONSTRING *compstr;
 673
 674             if (!(compstr = ImmLockIMCC( ctx->hCompStr )))
 675                 WARN( "Failed to lock input context composition string\n" );
 676             else
 677             {
 678                 WCHAR wchr = *(WCHAR *)((BYTE *)compstr + compstr->dwCompStrOffset);
 679                 COMPOSITIONSTRING tmp = *compstr;
 680                 UINT flags = 0;
 681
 682                 memset( compstr, 0, sizeof(*compstr) );
 683                 compstr->dwSize = tmp.dwSize;
 684                 compstr->dwResultStrLen = tmp.dwCompStrLen;
 685                 compstr->dwResultStrOffset = tmp.dwCompStrOffset;
 686                 compstr->dwResultClauseLen = tmp.dwCompClauseLen;
 687                 compstr->dwResultClauseOffset = tmp.dwCompClauseOffset;
 688                 ImmUnlockIMCC( ctx->hCompStr );
 689
 690                 if (tmp.dwCompStrLen) flags |= GCS_RESULTSTR;
 691                 if (tmp.dwCompClauseLen) flags |= GCS_RESULTCLAUSE;
 692                 if (flags) ime_send_message( himc, WM_IME_COMPOSITION, wchr, flags );
 693             }
 694
 695             ImmSetOpenStatus( himc, FALSE );
 696             break;
 697         }
 698         case CPS_CANCEL:
 699             input_context_set_comp_str( ctx, NULL, 0 );
 700             ImmSetOpenStatus( himc, FALSE );
 701             break;
 702         default:
 703             FIXME( "himc %p, action %#lx, index %#lx, value %#lx stub!\n", himc, action, index, value );
 704             break;
 705         }
 706         break;
 707
 708     default:
 709         FIXME( "himc %p, action %#lx, index %#lx, value %#lx stub!\n", himc, action, index, value );
 710         break;
 711     }
 712
 713     ImmUnlockIMC( himc );
 714     return TRUE;
 715 }
 716
 717 LRESULT WINAPI ImeEscape( HIMC himc, UINT escape, void *data )
 718 {
 719     FIXME( "himc %p, escape %#x, data %p stub!\n", himc, escape, data );
 720     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 721     return 0;
 722 }
 723
 724 DWORD WINAPI ImeGetImeMenuItems( HIMC himc, DWORD flags, DWORD type, IMEMENUITEMINFOW *parent,
 725                                  IMEMENUITEMINFOW *menu, DWORD size )
 726 {
 727     FIXME( "himc %p, flags %#lx, type %lu, parent %p, menu %p, size %#lx stub!\n",
 728            himc, flags, type, parent, menu, size );
 729     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 730     return 0;
 731 }
 732
 733 BOOL WINAPI ImeRegisterWord( const WCHAR *reading, DWORD style, const WCHAR *string )
 734 {
 735     FIXME( "reading %s, style %lu, string %s stub!\n", debugstr_w(reading), style, debugstr_w(string) );
 736     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 737     return FALSE;
 738 }
 739
 740 UINT WINAPI ImeGetRegisterWordStyle( UINT item, STYLEBUFW *style )
 741 {
 742     FIXME( "item %u, style %p stub!\n", item, style );
 743     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 744     return 0;
 745 }
 746
 747 BOOL WINAPI ImeUnregisterWord( const WCHAR *reading, DWORD style, const WCHAR *string )
 748 {
 749     FIXME( "reading %s, style %lu, string %s stub!\n", debugstr_w(reading), style, debugstr_w(string) );
 750     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 751     return FALSE;
 752 }
 753
 754 UINT WINAPI ImeEnumRegisterWord( REGISTERWORDENUMPROCW proc, const WCHAR *reading, DWORD style,
 755                                  const WCHAR *string, void *data )
 756 {
 757     FIXME( "proc %p, reading %s, style %lu, string %s, data %p stub!\n",
 758            proc, debugstr_w(reading), style, debugstr_w(string), data );
 759     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 760     return 0;
 761 }