dlls/user32/misc.c

   1 /*
   2  * Misc USER functions
   3  *
   4  * Copyright 1995 Thomas Sandford
   5  * Copyright 1997 Marcus Meissner
   6  * Copyright 1998 Turchanov Sergey
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26
  27 #include "windef.h"
  28 #include "wine/windef16.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "controls.h"
  32 #include "user_private.h"
  33
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(win);
  38
  39 #define IMM_INIT_MAGIC 0x19650412
  40 static HWND (WINAPI *imm_get_ui_window)(HKL);
  41 BOOL (WINAPI *imm_register_window)(HWND) = NULL;
  42 void (WINAPI *imm_unregister_window)(HWND) = NULL;
  43
  44 /* MSIME messages */
  45 static UINT WM_MSIME_SERVICE;
  46 static UINT WM_MSIME_RECONVERTOPTIONS;
  47 static UINT WM_MSIME_MOUSE;
  48 static UINT WM_MSIME_RECONVERTREQUEST;
  49 static UINT WM_MSIME_RECONVERT;
  50 static UINT WM_MSIME_QUERYPOSITION;
  51 static UINT WM_MSIME_DOCUMENTFEED;
  52
  53 /* USER signal proc flags and codes */
  54 /* See UserSignalProc for comments */
  55 #define USIG_FLAGS_WIN32          0x0001
  56 #define USIG_FLAGS_GUI            0x0002
  57 #define USIG_FLAGS_FEEDBACK       0x0004
  58 #define USIG_FLAGS_FAULT          0x0008
  59
  60 #define USIG_DLL_UNLOAD_WIN16     0x0001
  61 #define USIG_DLL_UNLOAD_WIN32     0x0002
  62 #define USIG_FAULT_DIALOG_PUSH    0x0003
  63 #define USIG_FAULT_DIALOG_POP     0x0004
  64 #define USIG_DLL_UNLOAD_ORPHANS   0x0005
  65 #define USIG_THREAD_INIT          0x0010
  66 #define USIG_THREAD_EXIT          0x0020
  67 #define USIG_PROCESS_CREATE       0x0100
  68 #define USIG_PROCESS_INIT         0x0200
  69 #define USIG_PROCESS_EXIT         0x0300
  70 #define USIG_PROCESS_DESTROY      0x0400
  71 #define USIG_PROCESS_RUNNING      0x0500
  72 #define USIG_PROCESS_LOADED       0x0600
  73
  74 /***********************************************************************
  75  *              SignalProc32 (USER.391)
  76  *              UserSignalProc (USER32.@)
  77  *
  78  * The exact meaning of the USER signals is undocumented, but this
  79  * should cover the basic idea:
  80  *
  81  * USIG_DLL_UNLOAD_WIN16
  82  *     This is sent when a 16-bit module is unloaded.
  83  *
  84  * USIG_DLL_UNLOAD_WIN32
  85  *     This is sent when a 32-bit module is unloaded.
  86  *
  87  * USIG_DLL_UNLOAD_ORPHANS
  88  *     This is sent after the last Win3.1 module is unloaded,
  89  *     to allow removal of orphaned menus.
  90  *
  91  * USIG_FAULT_DIALOG_PUSH
  92  * USIG_FAULT_DIALOG_POP
  93  *     These are called to allow USER to prepare for displaying a
  94  *     fault dialog, even though the fault might have happened while
  95  *     inside a USER critical section.
  96  *
  97  * USIG_THREAD_INIT
  98  *     This is called from the context of a new thread, as soon as it
  99  *     has started to run.
 100  *
 101  * USIG_THREAD_EXIT
 102  *     This is called, still in its context, just before a thread is
 103  *     about to terminate.
 104  *
 105  * USIG_PROCESS_CREATE
 106  *     This is called, in the parent process context, after a new process
 107  *     has been created.
 108  *
 109  * USIG_PROCESS_INIT
 110  *     This is called in the new process context, just after the main thread
 111  *     has started execution (after the main thread's USIG_THREAD_INIT has
 112  *     been sent).
 113  *
 114  * USIG_PROCESS_LOADED
 115  *     This is called after the executable file has been loaded into the
 116  *     new process context.
 117  *
 118  * USIG_PROCESS_RUNNING
 119  *     This is called immediately before the main entry point is called.
 120  *
 121  * USIG_PROCESS_EXIT
 122  *     This is called in the context of a process that is about to
 123  *     terminate (but before the last thread's USIG_THREAD_EXIT has
 124  *     been sent).
 125  *
 126  * USIG_PROCESS_DESTROY
 127  *     This is called after a process has terminated.
 128  *
 129  *
 130  * The meaning of the dwFlags bits is as follows:
 131  *
 132  * USIG_FLAGS_WIN32
 133  *     Current process is 32-bit.
 134  *
 135  * USIG_FLAGS_GUI
 136  *     Current process is a (Win32) GUI process.
 137  *
 138  * USIG_FLAGS_FEEDBACK
 139  *     Current process needs 'feedback' (determined from the STARTUPINFO
 140  *     flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
 141  *
 142  * USIG_FLAGS_FAULT
 143  *     The signal is being sent due to a fault.
 144  */
 145 WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
 146                             DWORD dwFlags, HMODULE16 hModule )
 147 {
 148     FIXME("(%04x, %08x, %04x, %04x)\n",
 149           uCode, dwThreadOrProcessID, dwFlags, hModule );
 150     /* FIXME: Should chain to GdiSignalProc now. */
 151     return 0;
 152 }
 153
 154
 155 /**********************************************************************
 156  * SetLastErrorEx [USER32.@]
 157  *
 158  * Sets the last-error code.
 159  *
 160  * RETURNS
 161  *    None.
 162  */
 163 void WINAPI SetLastErrorEx(
 164     DWORD error, /* [in] Per-thread error code */
 165     DWORD type)  /* [in] Error type */
 166 {
 167     TRACE("(0x%08x, 0x%08x)\n", error,type);
 168     switch(type) {
 169         case 0:
 170             break;
 171         case SLE_ERROR:
 172         case SLE_MINORERROR:
 173         case SLE_WARNING:
 174             /* Fall through for now */
 175         default:
 176             FIXME("(error=%08x, type=%08x): Unhandled type\n", error,type);
 177             break;
 178     }
 179     SetLastError( error );
 180 }
 181
 182 /******************************************************************************
 183  * GetAltTabInfoA [USER32.@]
 184  */
 185 BOOL WINAPI GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText)
 186 {
 187     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 188     return FALSE;
 189 }
 190
 191 /******************************************************************************
 192  * GetAltTabInfoW [USER32.@]
 193  */
 194 BOOL WINAPI GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText)
 195 {
 196     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 197     return FALSE;
 198 }
 199
 200 /******************************************************************************
 201  * SetDebugErrorLevel [USER32.@]
 202  * Sets the minimum error level for generating debugging events
 203  *
 204  * PARAMS
 205  *    dwLevel [I] Debugging error level
 206  *
 207  * RETURNS
 208  *    Nothing.
 209  */
 210 VOID WINAPI SetDebugErrorLevel( DWORD dwLevel )
 211 {
 212     FIXME("(%d): stub\n", dwLevel);
 213 }
 214
 215
 216 /***********************************************************************
 217  *              SetWindowStationUser (USER32.@)
 218  */
 219 DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2)
 220 {
 221     FIXME("(0x%08x,0x%08x),stub!\n",x1,x2);
 222     return 1;
 223 }
 224
 225 /***********************************************************************
 226  *              RegisterLogonProcess (USER32.@)
 227  */
 228 DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x)
 229 {
 230     FIXME("(%p,%d),stub!\n",hprocess,x);
 231     return 1;
 232 }
 233
 234 /***********************************************************************
 235  *              SetLogonNotifyWindow (USER32.@)
 236  */
 237 DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
 238 {
 239     FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
 240     return 1;
 241 }
 242
 243 /***********************************************************************
 244  *              QueryDisplayConfig (USER32.@)
 245  */
 246 LONG WINAPI QueryDisplayConfig(UINT32 flags, UINT32 *numpathelements, DISPLAYCONFIG_PATH_INFO *pathinfo,
 247                                UINT32 *numinfoelements, DISPLAYCONFIG_MODE_INFO *modeinfo,
 248                                DISPLAYCONFIG_TOPOLOGY_ID *topologyid)
 249 {
 250    FIXME("(%08x %p %p %p %p %p)\n", flags, numpathelements, pathinfo, numinfoelements, modeinfo, topologyid);
 251    return ERROR_CALL_NOT_IMPLEMENTED;
 252 }
 253
 254 /***********************************************************************
 255  *              RegisterSystemThread (USER32.@)
 256  */
 257 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
 258 {
 259     FIXME("(%08x, %08x)\n", flags, reserved);
 260 }
 261
 262 /***********************************************************************
 263  *           RegisterShellHookWindow                    [USER32.@]
 264  */
 265 BOOL WINAPI RegisterShellHookWindow(HWND hWnd)
 266 {
 267     FIXME("(%p): stub\n", hWnd);
 268     return FALSE;
 269 }
 270
 271
 272 /***********************************************************************
 273  *           DeregisterShellHookWindow                  [USER32.@]
 274  */
 275 BOOL WINAPI DeregisterShellHookWindow(HWND hWnd)
 276 {
 277     FIXME("(%p): stub\n", hWnd);
 278     return FALSE;
 279 }
 280
 281
 282 /***********************************************************************
 283  *           RegisterTasklist                           [USER32.@]
 284  */
 285 DWORD WINAPI RegisterTasklist (DWORD x)
 286 {
 287     FIXME("0x%08x\n",x);
 288     return TRUE;
 289 }
 290
 291
 292 /***********************************************************************
 293  *              RegisterDeviceNotificationA (USER32.@)
 294  *
 295  * See RegisterDeviceNotificationW.
 296  */
 297 HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE hnd, LPVOID notifyfilter, DWORD flags)
 298 {
 299     FIXME("(hwnd=%p, filter=%p,flags=0x%08x) returns a fake device notification handle!\n",
 300           hnd,notifyfilter,flags );
 301     return (HDEVNOTIFY) 0xcafecafe;
 302 }
 303
 304 /***********************************************************************
 305  *              RegisterDeviceNotificationW (USER32.@)
 306  *
 307  * Registers a window with the system so that it will receive
 308  * notifications about a device.
 309  *
 310  * PARAMS
 311  *     hRecipient           [I] Window or service status handle that
 312  *                              will receive notifications.
 313  *     pNotificationFilter  [I] DEV_BROADCAST_HDR followed by some
 314  *                              type-specific data.
 315  *     dwFlags              [I] See notes
 316  *
 317  * RETURNS
 318  *
 319  * A handle to the device notification.
 320  *
 321  * NOTES
 322  *
 323  * The dwFlags parameter can be one of two values:
 324  *| DEVICE_NOTIFY_WINDOW_HANDLE  - hRecipient is a window handle
 325  *| DEVICE_NOTIFY_SERVICE_HANDLE - hRecipient is a service status handle
 326  */
 327 HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE hRecipient, LPVOID pNotificationFilter, DWORD dwFlags)
 328 {
 329     FIXME("(hwnd=%p, filter=%p,flags=0x%08x) returns a fake device notification handle!\n",
 330           hRecipient,pNotificationFilter,dwFlags );
 331     return (HDEVNOTIFY) 0xcafeaffe;
 332 }
 333
 334 /***********************************************************************
 335  *              UnregisterDeviceNotification (USER32.@)
 336  *
 337  */
 338 BOOL  WINAPI UnregisterDeviceNotification(HDEVNOTIFY hnd)
 339 {
 340     FIXME("(handle=%p), STUB!\n", hnd);
 341     return TRUE;
 342 }
 343
 344 /***********************************************************************
 345  *           GetAppCompatFlags   (USER32.@)
 346  */
 347 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
 348 {
 349     FIXME("(%p) stub\n", hTask);
 350     return 0;
 351 }
 352
 353 /***********************************************************************
 354  *           GetAppCompatFlags2   (USER32.@)
 355  */
 356 DWORD WINAPI GetAppCompatFlags2( HTASK hTask )
 357 {
 358     FIXME("(%p) stub\n", hTask);
 359     return 0;
 360 }
 361
 362
 363 /***********************************************************************
 364  *           AlignRects   (USER32.@)
 365  */
 366 BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 367 {
 368     FIXME("(%p, %d, %d, %d): stub\n", rect, b, c, d);
 369     if (rect)
 370         FIXME("rect: %s\n", wine_dbgstr_rect(rect));
 371     /* Calls OffsetRect */
 372     return FALSE;
 373 }
 374
 375
 376 /***********************************************************************
 377  *              LoadLocalFonts (USER32.@)
 378  */
 379 VOID WINAPI LoadLocalFonts(VOID)
 380 {
 381     /* are loaded. */
 382     return;
 383 }
 384
 385
 386 /***********************************************************************
 387  *              User32InitializeImmEntryTable
 388  */
 389 BOOL WINAPI User32InitializeImmEntryTable(DWORD magic)
 390 {
 391     static const WCHAR imm32_dllW[] = {'i','m','m','3','2','.','d','l','l',0};
 392     HMODULE imm32 = GetModuleHandleW(imm32_dllW);
 393
 394     TRACE("(%x)\n", magic);
 395
 396     if (!imm32 || magic != IMM_INIT_MAGIC)
 397         return FALSE;
 398
 399     if (imm_get_ui_window)
 400         return TRUE;
 401
 402     WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
 403     WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
 404     WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
 405     WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
 406     WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
 407     WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
 408     WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
 409
 410     /* this part is not compatible with native imm32.dll */
 411     imm_get_ui_window = (void*)GetProcAddress(imm32, "__wine_get_ui_window");
 412     imm_register_window = (void*)GetProcAddress(imm32, "__wine_register_window");
 413     imm_unregister_window = (void*)GetProcAddress(imm32, "__wine_unregister_window");
 414     if (!imm_get_ui_window)
 415         FIXME("native imm32.dll not supported\n");
 416     return TRUE;
 417 }
 418
 419 /**********************************************************************
 420  * WINNLSGetIMEHotkey [USER32.@]
 421  *
 422  */
 423 UINT WINAPI WINNLSGetIMEHotkey(HWND hwnd)
 424 {
 425     FIXME("hwnd %p: stub!\n", hwnd);
 426     return 0; /* unknown */
 427 }
 428
 429 /**********************************************************************
 430  * WINNLSEnableIME [USER32.@]
 431  *
 432  */
 433 BOOL WINAPI WINNLSEnableIME(HWND hwnd, BOOL enable)
 434 {
 435     FIXME("hwnd %p enable %d: stub!\n", hwnd, enable);
 436     return TRUE; /* success (?) */
 437 }
 438
 439 /**********************************************************************
 440  * WINNLSGetEnableStatus [USER32.@]
 441  *
 442  */
 443 BOOL WINAPI WINNLSGetEnableStatus(HWND hwnd)
 444 {
 445     FIXME("hwnd %p: stub!\n", hwnd);
 446     return TRUE; /* success (?) */
 447 }
 448
 449 /**********************************************************************
 450  * SendIMEMessageExA [USER32.@]
 451  *
 452  */
 453 LRESULT WINAPI SendIMEMessageExA(HWND hwnd, LPARAM lparam)
 454 {
 455   FIXME("(%p,%lx): stub\n", hwnd, lparam);
 456   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 457   return 0;
 458 }
 459
 460 /**********************************************************************
 461  * SendIMEMessageExW [USER32.@]
 462  *
 463  */
 464 LRESULT WINAPI SendIMEMessageExW(HWND hwnd, LPARAM lparam)
 465 {
 466   FIXME("(%p,%lx): stub\n", hwnd, lparam);
 467   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 468   return 0;
 469 }
 470
 471 /**********************************************************************
 472  * DisableProcessWindowsGhosting [USER32.@]
 473  *
 474  */
 475 VOID WINAPI DisableProcessWindowsGhosting(VOID)
 476 {
 477   FIXME(": stub\n");
 478   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 479   return;
 480 }
 481
 482 /**********************************************************************
 483  * UserHandleGrantAccess [USER32.@]
 484  *
 485  */
 486 BOOL WINAPI UserHandleGrantAccess(HANDLE handle, HANDLE job, BOOL grant)
 487 {
 488     FIXME("(%p,%p,%d): stub\n", handle, job, grant);
 489     return TRUE;
 490 }
 491
 492 /**********************************************************************
 493  * RegisterPowerSettingNotification [USER32.@]
 494  */
 495 HPOWERNOTIFY WINAPI RegisterPowerSettingNotification(HANDLE recipient, const GUID *guid, DWORD flags)
 496 {
 497     FIXME("(%p,%s,%x): stub\n", recipient, debugstr_guid(guid), flags);
 498     return (HPOWERNOTIFY)0xdeadbeef;
 499 }
 500
 501 /**********************************************************************
 502  * UnregisterPowerSettingNotification [USER32.@]
 503  */
 504 BOOL WINAPI UnregisterPowerSettingNotification(HPOWERNOTIFY handle)
 505 {
 506     FIXME("(%p): stub\n", handle);
 507     return TRUE;
 508 }
 509
 510 /*****************************************************************************
 511  * GetGestureConfig (USER32.@)
 512  */
 513 BOOL WINAPI GetGestureConfig( HWND hwnd, DWORD reserved, DWORD flags, UINT *count, GESTURECONFIG *config, UINT size )
 514 {
 515     FIXME("(%p %08x %08x %p %p %u): stub\n", hwnd, reserved, flags, count, config, size);
 516     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 517     return FALSE;
 518 }
 519
 520 /**********************************************************************
 521  * SetGestureConfig [USER32.@]
 522  */
 523 BOOL WINAPI SetGestureConfig( HWND hwnd, DWORD reserved, UINT id, PGESTURECONFIG config, UINT size )
 524 {
 525     FIXME("(%p %08x %u %p %u): stub\n", hwnd, reserved, id, config, size);
 526     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 527     return FALSE;
 528 }
 529
 530 /**********************************************************************
 531  * IsTouchWindow [USER32.@]
 532  */
 533 BOOL WINAPI IsTouchWindow( HWND hwnd, PULONG flags )
 534 {
 535     FIXME("(%p %p): stub\n", hwnd, flags);
 536     return FALSE;
 537 }
 538
 539 /**********************************************************************
 540  * IsWindowRedirectedForPrint [USER32.@]
 541  */
 542 BOOL WINAPI IsWindowRedirectedForPrint( HWND hwnd )
 543 {
 544     FIXME("(%p): stub\n", hwnd);
 545     return FALSE;
 546 }
 547
 548 /**********************************************************************
 549  * GetDisplayConfigBufferSizes [USER32.@]
 550  */
 551 LONG WINAPI GetDisplayConfigBufferSizes(UINT32 flags, UINT32 *num_path_info, UINT32 *num_mode_info)
 552 {
 553     FIXME("(0x%x %p %p): stub\n", flags, num_path_info, num_mode_info);
 554
 555     if (!num_path_info || !num_mode_info)
 556         return ERROR_INVALID_PARAMETER;
 557
 558     *num_path_info = 0;
 559     *num_mode_info = 0;
 560     return ERROR_NOT_SUPPORTED;
 561 }
 562
 563 /**********************************************************************
 564  * RegisterPointerDeviceNotifications [USER32.@]
 565  */
 566 BOOL WINAPI RegisterPointerDeviceNotifications(HWND hwnd, BOOL notifyrange)
 567 {
 568     FIXME("(%p %d): stub\n", hwnd, notifyrange);
 569     return TRUE;
 570 }
 571
 572 /**********************************************************************
 573  * GetPointerDevices [USER32.@]
 574  */
 575 BOOL WINAPI GetPointerDevices(UINT32 *device_count, POINTER_DEVICE_INFO *devices)
 576 {
 577     FIXME("(%p %p): partial stub\n", device_count, devices);
 578
 579     if (!device_count)
 580         return FALSE;
 581
 582     if (devices)
 583         return FALSE;
 584
 585     *device_count = 0;
 586     return TRUE;
 587 }
 588
 589 /**********************************************************************
 590  * RegisterTouchHitTestingWindow [USER32.@]
 591  */
 592 BOOL WINAPI RegisterTouchHitTestingWindow(HWND hwnd, ULONG value)
 593 {
 594     FIXME("(%p %d): stub\n", hwnd, value);
 595     return TRUE;
 596 }
 597
 598 /**********************************************************************
 599  * GetPointerType [USER32.@]
 600  */
 601 BOOL WINAPI GetPointerType(UINT32 id, POINTER_INPUT_TYPE *type)
 602 {
 603     FIXME("(%d %p): stub\n", id, type);
 604
 605     if(!id || !type)
 606     {
 607         SetLastError(ERROR_INVALID_PARAMETER);
 608         return FALSE;
 609     }
 610
 611     *type = PT_MOUSE;
 612     return TRUE;
 613 }
 614
 615 static const WCHAR imeW[] = {'I','M','E',0};
 616 const struct builtin_class_descr IME_builtin_class =
 617 {
 618     imeW,               /* name */
 619     0,                  /* style  */
 620     WINPROC_IME,        /* proc */
 621     2*sizeof(LONG_PTR), /* extra */
 622     IDC_ARROW,          /* cursor */
 623     0                   /* brush */
 624 };
 625
 626 static BOOL is_ime_ui_msg( UINT msg )
 627 {
 628     switch(msg) {
 629     case WM_IME_STARTCOMPOSITION:
 630     case WM_IME_ENDCOMPOSITION:
 631     case WM_IME_COMPOSITION:
 632     case WM_IME_SETCONTEXT:
 633     case WM_IME_NOTIFY:
 634     case WM_IME_CONTROL:
 635     case WM_IME_COMPOSITIONFULL:
 636     case WM_IME_SELECT:
 637     case WM_IME_CHAR:
 638     case WM_IME_REQUEST:
 639     case WM_IME_KEYDOWN:
 640     case WM_IME_KEYUP:
 641         return TRUE;
 642     default:
 643         if ((msg == WM_MSIME_RECONVERTOPTIONS) ||
 644                 (msg == WM_MSIME_SERVICE) ||
 645                 (msg == WM_MSIME_MOUSE) ||
 646                 (msg == WM_MSIME_RECONVERTREQUEST) ||
 647                 (msg == WM_MSIME_RECONVERT) ||
 648                 (msg == WM_MSIME_QUERYPOSITION) ||
 649                 (msg == WM_MSIME_DOCUMENTFEED))
 650             return TRUE;
 651
 652         return FALSE;
 653     }
 654 }
 655
 656 LRESULT WINAPI ImeWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 657 {
 658     HWND uiwnd;
 659
 660     if (msg==WM_CREATE)
 661         return TRUE;
 662
 663     if (imm_get_ui_window && is_ime_ui_msg(msg))
 664     {
 665         if ((uiwnd = imm_get_ui_window(GetKeyboardLayout(0))))
 666             return SendMessageA(uiwnd, msg, wParam, lParam);
 667         return FALSE;
 668     }
 669
 670     return DefWindowProcA(hwnd, msg, wParam, lParam);
 671 }
 672
 673 LRESULT WINAPI ImeWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 674 {
 675     HWND uiwnd;
 676
 677     if (msg==WM_CREATE)
 678         return TRUE;
 679
 680     if (imm_get_ui_window && is_ime_ui_msg(msg))
 681     {
 682         if ((uiwnd = imm_get_ui_window(GetKeyboardLayout(0))))
 683             return SendMessageW(uiwnd, msg, wParam, lParam);
 684         return FALSE;
 685     }
 686
 687     return DefWindowProcW(hwnd, msg, wParam, lParam);
 688 }