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