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 <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "wine/windef16.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "winternl.h"
  32 #include "controls.h"
  33 #include "user_private.h"
  34
  35 #include "wine/unicode.h"
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(win);
  39
  40 #define IMM_INIT_MAGIC 0x19650412
  41 static HWND (WINAPI *imm_get_ui_window)(HKL);
  42
  43 /* MSIME messages */
  44 static UINT WM_MSIME_SERVICE;
  45 static UINT WM_MSIME_RECONVERTOPTIONS;
  46 static UINT WM_MSIME_MOUSE;
  47 static UINT WM_MSIME_RECONVERTREQUEST;
  48 static UINT WM_MSIME_RECONVERT;
  49 static UINT WM_MSIME_QUERYPOSITION;
  50 static UINT WM_MSIME_DOCUMENTFEED;
  51
  52 /* USER signal proc flags and codes */
  53 /* See UserSignalProc for comments */
  54 #define USIG_FLAGS_WIN32          0x0001
  55 #define USIG_FLAGS_GUI            0x0002
  56 #define USIG_FLAGS_FEEDBACK       0x0004
  57 #define USIG_FLAGS_FAULT          0x0008
  58
  59 #define USIG_DLL_UNLOAD_WIN16     0x0001
  60 #define USIG_DLL_UNLOAD_WIN32     0x0002
  61 #define USIG_FAULT_DIALOG_PUSH    0x0003
  62 #define USIG_FAULT_DIALOG_POP     0x0004
  63 #define USIG_DLL_UNLOAD_ORPHANS   0x0005
  64 #define USIG_THREAD_INIT          0x0010
  65 #define USIG_THREAD_EXIT          0x0020
  66 #define USIG_PROCESS_CREATE       0x0100
  67 #define USIG_PROCESS_INIT         0x0200
  68 #define USIG_PROCESS_EXIT         0x0300
  69 #define USIG_PROCESS_DESTROY      0x0400
  70 #define USIG_PROCESS_RUNNING      0x0500
  71 #define USIG_PROCESS_LOADED       0x0600
  72
  73 /***********************************************************************
  74  *              SignalProc32 (USER.391)
  75  *              UserSignalProc (USER32.@)
  76  *
  77  * The exact meaning of the USER signals is undocumented, but this
  78  * should cover the basic idea:
  79  *
  80  * USIG_DLL_UNLOAD_WIN16
  81  *     This is sent when a 16-bit module is unloaded.
  82  *
  83  * USIG_DLL_UNLOAD_WIN32
  84  *     This is sent when a 32-bit module is unloaded.
  85  *
  86  * USIG_DLL_UNLOAD_ORPHANS
  87  *     This is sent after the last Win3.1 module is unloaded,
  88  *     to allow removal of orphaned menus.
  89  *
  90  * USIG_FAULT_DIALOG_PUSH
  91  * USIG_FAULT_DIALOG_POP
  92  *     These are called to allow USER to prepare for displaying a
  93  *     fault dialog, even though the fault might have happened while
  94  *     inside a USER critical section.
  95  *
  96  * USIG_THREAD_INIT
  97  *     This is called from the context of a new thread, as soon as it
  98  *     has started to run.
  99  *
 100  * USIG_THREAD_EXIT
 101  *     This is called, still in its context, just before a thread is
 102  *     about to terminate.
 103  *
 104  * USIG_PROCESS_CREATE
 105  *     This is called, in the parent process context, after a new process
 106  *     has been created.
 107  *
 108  * USIG_PROCESS_INIT
 109  *     This is called in the new process context, just after the main thread
 110  *     has started execution (after the main thread's USIG_THREAD_INIT has
 111  *     been sent).
 112  *
 113  * USIG_PROCESS_LOADED
 114  *     This is called after the executable file has been loaded into the
 115  *     new process context.
 116  *
 117  * USIG_PROCESS_RUNNING
 118  *     This is called immediately before the main entry point is called.
 119  *
 120  * USIG_PROCESS_EXIT
 121  *     This is called in the context of a process that is about to
 122  *     terminate (but before the last thread's USIG_THREAD_EXIT has
 123  *     been sent).
 124  *
 125  * USIG_PROCESS_DESTROY
 126  *     This is called after a process has terminated.
 127  *
 128  *
 129  * The meaning of the dwFlags bits is as follows:
 130  *
 131  * USIG_FLAGS_WIN32
 132  *     Current process is 32-bit.
 133  *
 134  * USIG_FLAGS_GUI
 135  *     Current process is a (Win32) GUI process.
 136  *
 137  * USIG_FLAGS_FEEDBACK
 138  *     Current process needs 'feedback' (determined from the STARTUPINFO
 139  *     flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
 140  *
 141  * USIG_FLAGS_FAULT
 142  *     The signal is being sent due to a fault.
 143  */
 144 WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
 145                             DWORD dwFlags, HMODULE16 hModule )
 146 {
 147     FIXME("(%04x, %08x, %04x, %04x)\n",
 148           uCode, dwThreadOrProcessID, dwFlags, hModule );
 149     /* FIXME: Should chain to GdiSignalProc now. */
 150     return 0;
 151 }
 152
 153
 154 /**********************************************************************
 155  * SetLastErrorEx [USER32.@]
 156  *
 157  * Sets the last-error code.
 158  *
 159  * RETURNS
 160  *    None.
 161  */
 162 void WINAPI SetLastErrorEx(
 163     DWORD error, /* [in] Per-thread error code */
 164     DWORD type)  /* [in] Error type */
 165 {
 166     TRACE("(0x%08x, 0x%08x)\n", error,type);
 167     switch(type) {
 168         case 0:
 169             break;
 170         case SLE_ERROR:
 171         case SLE_MINORERROR:
 172         case SLE_WARNING:
 173             /* Fall through for now */
 174         default:
 175             FIXME("(error=%08x, type=%08x): Unhandled type\n", error,type);
 176             break;
 177     }
 178     SetLastError( error );
 179 }
 180
 181 /******************************************************************************
 182  * GetAltTabInfoA [USER32.@]
 183  */
 184 BOOL WINAPI GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText)
 185 {
 186     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 187     return FALSE;
 188 }
 189
 190 /******************************************************************************
 191  * GetAltTabInfoW [USER32.@]
 192  */
 193 BOOL WINAPI GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText)
 194 {
 195     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 196     return FALSE;
 197 }
 198
 199 /******************************************************************************
 200  * SetDebugErrorLevel [USER32.@]
 201  * Sets the minimum error level for generating debugging events
 202  *
 203  * PARAMS
 204  *    dwLevel [I] Debugging error level
 205  *
 206  * RETURNS
 207  *    Nothing.
 208  */
 209 VOID WINAPI SetDebugErrorLevel( DWORD dwLevel )
 210 {
 211     FIXME("(%d): stub\n", dwLevel);
 212 }
 213
 214
 215 /***********************************************************************
 216  *              SetWindowStationUser (USER32.@)
 217  */
 218 DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2)
 219 {
 220     FIXME("(0x%08x,0x%08x),stub!\n",x1,x2);
 221     return 1;
 222 }
 223
 224 /***********************************************************************
 225  *              RegisterLogonProcess (USER32.@)
 226  */
 227 DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x)
 228 {
 229     FIXME("(%p,%d),stub!\n",hprocess,x);
 230     return 1;
 231 }
 232
 233 /***********************************************************************
 234  *              SetLogonNotifyWindow (USER32.@)
 235  */
 236 DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
 237 {
 238     FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
 239     return 1;
 240 }
 241
 242 static const WCHAR primary_device_name[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0};
 243 static const WCHAR primary_device_string[] = {'X','1','1',' ','W','i','n','d','o','w','i','n','g',' ',
 244                                               'S','y','s','t','e','m',0};
 245 static const WCHAR primary_device_deviceid[] = {'P','C','I','\\','V','E','N','_','0','0','0','0','&',
 246                                                 'D','E','V','_','0','0','0','0',0};
 247
 248 /***********************************************************************
 249  *              EnumDisplayDevicesA (USER32.@)
 250  */
 251 BOOL WINAPI EnumDisplayDevicesA( LPCSTR lpDevice, DWORD i, LPDISPLAY_DEVICEA lpDispDev,
 252                                  DWORD dwFlags )
 253 {
 254     UNICODE_STRING deviceW;
 255     DISPLAY_DEVICEW ddW;
 256     BOOL ret;
 257
 258     if(lpDevice)
 259         RtlCreateUnicodeStringFromAsciiz(&deviceW, lpDevice);
 260     else
 261         deviceW.Buffer = NULL;
 262
 263     ddW.cb = sizeof(ddW);
 264     ret = EnumDisplayDevicesW(deviceW.Buffer, i, &ddW, dwFlags);
 265     RtlFreeUnicodeString(&deviceW);
 266
 267     if(!ret) return ret;
 268
 269     WideCharToMultiByte(CP_ACP, 0, ddW.DeviceName, -1, lpDispDev->DeviceName, sizeof(lpDispDev->DeviceName), NULL, NULL);
 270     WideCharToMultiByte(CP_ACP, 0, ddW.DeviceString, -1, lpDispDev->DeviceString, sizeof(lpDispDev->DeviceString), NULL, NULL);
 271     lpDispDev->StateFlags = ddW.StateFlags;
 272
 273     if(lpDispDev->cb >= offsetof(DISPLAY_DEVICEA, DeviceID) + sizeof(lpDispDev->DeviceID))
 274         WideCharToMultiByte(CP_ACP, 0, ddW.DeviceID, -1, lpDispDev->DeviceID, sizeof(lpDispDev->DeviceID), NULL, NULL);
 275     if(lpDispDev->cb >= offsetof(DISPLAY_DEVICEA, DeviceKey) + sizeof(lpDispDev->DeviceKey))
 276         WideCharToMultiByte(CP_ACP, 0, ddW.DeviceKey, -1, lpDispDev->DeviceKey, sizeof(lpDispDev->DeviceKey), NULL, NULL);
 277
 278     return TRUE;
 279 }
 280
 281 /***********************************************************************
 282  *              EnumDisplayDevicesW (USER32.@)
 283  */
 284 BOOL WINAPI EnumDisplayDevicesW( LPCWSTR lpDevice, DWORD i, LPDISPLAY_DEVICEW lpDisplayDevice,
 285                                  DWORD dwFlags )
 286 {
 287     FIXME("(%s,%d,%p,0x%08x), stub!\n",debugstr_w(lpDevice),i,lpDisplayDevice,dwFlags);
 288
 289     if (i)
 290         return FALSE;
 291
 292     memcpy(lpDisplayDevice->DeviceName, primary_device_name, sizeof(primary_device_name));
 293     memcpy(lpDisplayDevice->DeviceString, primary_device_string, sizeof(primary_device_string));
 294
 295     lpDisplayDevice->StateFlags =
 296         DISPLAY_DEVICE_ATTACHED_TO_DESKTOP |
 297         DISPLAY_DEVICE_PRIMARY_DEVICE |
 298         DISPLAY_DEVICE_VGA_COMPATIBLE;
 299
 300     if(lpDisplayDevice->cb >= offsetof(DISPLAY_DEVICEW, DeviceID) + sizeof(lpDisplayDevice->DeviceID))
 301         memcpy(lpDisplayDevice->DeviceID, primary_device_deviceid, sizeof(primary_device_deviceid));
 302     if(lpDisplayDevice->cb >= offsetof(DISPLAY_DEVICEW, DeviceKey) + sizeof(lpDisplayDevice->DeviceKey))
 303         lpDisplayDevice->DeviceKey[0] = 0;
 304
 305     return TRUE;
 306 }
 307
 308 struct monitor_enum_info
 309 {
 310     RECT     rect;
 311     UINT     max_area;
 312     UINT     min_distance;
 313     HMONITOR primary;
 314     HMONITOR nearest;
 315     HMONITOR ret;
 316 };
 317
 318 /* helper callback for MonitorFromRect */
 319 static BOOL CALLBACK monitor_enum( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
 320 {
 321     struct monitor_enum_info *info = (struct monitor_enum_info *)lp;
 322     RECT intersect;
 323
 324     if (IntersectRect( &intersect, rect, &info->rect ))
 325     {
 326         /* check for larger intersecting area */
 327         UINT area = (intersect.right - intersect.left) * (intersect.bottom - intersect.top);
 328         if (area > info->max_area)
 329         {
 330             info->max_area = area;
 331             info->ret = monitor;
 332         }
 333     }
 334     else if (!info->max_area)  /* if not intersecting, check for min distance */
 335     {
 336         UINT distance;
 337         UINT x, y;
 338
 339         if (info->rect.right <= rect->left) x = rect->left - info->rect.right;
 340         else if (rect->right <= info->rect.left) x = info->rect.left - rect->right;
 341         else x = 0;
 342         if (info->rect.bottom <= rect->top) y = rect->top - info->rect.bottom;
 343         else if (rect->bottom <= info->rect.top) y = info->rect.top - rect->bottom;
 344         else y = 0;
 345         distance = x * x + y * y;
 346         if (distance < info->min_distance)
 347         {
 348             info->min_distance = distance;
 349             info->nearest = monitor;
 350         }
 351     }
 352     if (!info->primary)
 353     {
 354         MONITORINFO mon_info;
 355         mon_info.cbSize = sizeof(mon_info);
 356         GetMonitorInfoW( monitor, &mon_info );
 357         if (mon_info.dwFlags & MONITORINFOF_PRIMARY) info->primary = monitor;
 358     }
 359     return TRUE;
 360 }
 361
 362 /***********************************************************************
 363  *              MonitorFromRect (USER32.@)
 364  */
 365 HMONITOR WINAPI MonitorFromRect( LPRECT rect, DWORD flags )
 366 {
 367     struct monitor_enum_info info;
 368
 369     info.rect         = *rect;
 370     info.max_area     = 0;
 371     info.min_distance = ~0u;
 372     info.primary      = 0;
 373     info.nearest      = 0;
 374     info.ret          = 0;
 375
 376     if (IsRectEmpty(&info.rect))
 377     {
 378         info.rect.right = info.rect.left + 1;
 379         info.rect.bottom = info.rect.top + 1;
 380     }
 381
 382     if (!EnumDisplayMonitors( 0, NULL, monitor_enum, (LPARAM)&info )) return 0;
 383     if (!info.ret)
 384     {
 385         if (flags & MONITOR_DEFAULTTOPRIMARY) info.ret = info.primary;
 386         else if (flags & MONITOR_DEFAULTTONEAREST) info.ret = info.nearest;
 387     }
 388
 389     TRACE( "%s flags %x returning %p\n", wine_dbgstr_rect(rect), flags, info.ret );
 390     return info.ret;
 391 }
 392
 393 /***********************************************************************
 394  *              MonitorFromPoint (USER32.@)
 395  */
 396 HMONITOR WINAPI MonitorFromPoint( POINT pt, DWORD flags )
 397 {
 398     RECT rect;
 399
 400     SetRect( &rect, pt.x, pt.y, pt.x + 1, pt.y + 1 );
 401     return MonitorFromRect( &rect, flags );
 402 }
 403
 404 /***********************************************************************
 405  *              MonitorFromWindow (USER32.@)
 406  */
 407 HMONITOR WINAPI MonitorFromWindow(HWND hWnd, DWORD dwFlags)
 408 {
 409     RECT rect;
 410     WINDOWPLACEMENT wp;
 411
 412     TRACE("(%p, 0x%08x)\n", hWnd, dwFlags);
 413
 414     if (IsIconic(hWnd) && GetWindowPlacement(hWnd, &wp))
 415         return MonitorFromRect( &wp.rcNormalPosition, dwFlags );
 416
 417     if (GetWindowRect( hWnd, &rect ))
 418         return MonitorFromRect( &rect, dwFlags );
 419
 420     if (!(dwFlags & (MONITOR_DEFAULTTOPRIMARY|MONITOR_DEFAULTTONEAREST))) return 0;
 421     /* retrieve the primary */
 422     SetRect( &rect, 0, 0, 1, 1 );
 423     return MonitorFromRect( &rect, dwFlags );
 424 }
 425
 426 /***********************************************************************
 427  *              GetMonitorInfoA (USER32.@)
 428  */
 429 BOOL WINAPI GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
 430 {
 431     MONITORINFOEXW miW;
 432     MONITORINFOEXA *miA = (MONITORINFOEXA*)lpMonitorInfo;
 433     BOOL ret;
 434
 435     if((miA->cbSize != sizeof(MONITORINFOEXA)) && (miA->cbSize != sizeof(MONITORINFO)))
 436         return FALSE;
 437
 438     miW.cbSize = sizeof(miW);
 439
 440     ret = GetMonitorInfoW(hMonitor, (MONITORINFO*)&miW);
 441     if(!ret) return ret;
 442
 443     miA->rcMonitor = miW.rcMonitor;
 444     miA->rcWork = miW.rcWork;
 445     miA->dwFlags = miW.dwFlags;
 446     if(miA->cbSize == sizeof(MONITORINFOEXA))
 447         WideCharToMultiByte(CP_ACP, 0, miW.szDevice, -1, miA->szDevice, sizeof(miA->szDevice), NULL, NULL);
 448     return ret;
 449 }
 450
 451 /***********************************************************************
 452  *              GetMonitorInfoW (USER32.@)
 453  */
 454 BOOL WINAPI GetMonitorInfoW(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
 455 {
 456     BOOL ret;
 457
 458     if (lpMonitorInfo->cbSize != sizeof(MONITORINFOEXW) && lpMonitorInfo->cbSize != sizeof(MONITORINFO))
 459         return FALSE;
 460
 461     ret = USER_Driver->pGetMonitorInfo( hMonitor, lpMonitorInfo );
 462     if (ret)
 463         TRACE("flags %04x, monitor %s, work %s\n", lpMonitorInfo->dwFlags,
 464               wine_dbgstr_rect(&lpMonitorInfo->rcMonitor),
 465               wine_dbgstr_rect(&lpMonitorInfo->rcWork));
 466     return ret;
 467 }
 468
 469 /***********************************************************************
 470  *              EnumDisplayMonitors (USER32.@)
 471  */
 472 BOOL WINAPI EnumDisplayMonitors( HDC hdc, LPRECT rect, MONITORENUMPROC proc, LPARAM lp )
 473 {
 474     return USER_Driver->pEnumDisplayMonitors( hdc, rect, proc, lp );
 475 }
 476
 477 /***********************************************************************
 478  *              RegisterSystemThread (USER32.@)
 479  */
 480 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
 481 {
 482     FIXME("(%08x, %08x)\n", flags, reserved);
 483 }
 484
 485 /***********************************************************************
 486  *           RegisterShellHookWindow                    [USER32.@]
 487  */
 488 BOOL WINAPI RegisterShellHookWindow ( HWND hWnd )
 489 {
 490     FIXME("(%p): stub\n", hWnd);
 491     return FALSE;
 492 }
 493
 494
 495 /***********************************************************************
 496  *           DeregisterShellHookWindow                  [USER32.@]
 497  */
 498 HRESULT WINAPI DeregisterShellHookWindow ( DWORD u )
 499 {
 500     FIXME("0x%08x stub\n",u);
 501     return 0;
 502
 503 }
 504
 505
 506 /***********************************************************************
 507  *           RegisterTasklist                           [USER32.@]
 508  */
 509 DWORD WINAPI RegisterTasklist (DWORD x)
 510 {
 511     FIXME("0x%08x\n",x);
 512     return TRUE;
 513 }
 514
 515
 516 /***********************************************************************
 517  *              RegisterDeviceNotificationA (USER32.@)
 518  *
 519  * See RegisterDeviceNotificationW.
 520  */
 521 HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE hnd, LPVOID notifyfilter, DWORD flags)
 522 {
 523     FIXME("(hwnd=%p, filter=%p,flags=0x%08x) returns a fake device notification handle!\n",
 524           hnd,notifyfilter,flags );
 525     return (HDEVNOTIFY) 0xcafecafe;
 526 }
 527
 528 /***********************************************************************
 529  *              RegisterDeviceNotificationW (USER32.@)
 530  *
 531  * Registers a window with the system so that it will receive
 532  * notifications about a device.
 533  *
 534  * PARAMS
 535  *     hRecipient           [I] Window or service status handle that
 536  *                              will receive notifications.
 537  *     pNotificationFilter  [I] DEV_BROADCAST_HDR followed by some
 538  *                              type-specific data.
 539  *     dwFlags              [I] See notes
 540  *
 541  * RETURNS
 542  *
 543  * A handle to the device notification.
 544  *
 545  * NOTES
 546  *
 547  * The dwFlags parameter can be one of two values:
 548  *| DEVICE_NOTIFY_WINDOW_HANDLE  - hRecipient is a window handle
 549  *| DEVICE_NOTIFY_SERVICE_HANDLE - hRecipient is a service status handle
 550  */
 551 HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE hRecipient, LPVOID pNotificationFilter, DWORD dwFlags)
 552 {
 553     FIXME("(hwnd=%p, filter=%p,flags=0x%08x) returns a fake device notification handle!\n",
 554           hRecipient,pNotificationFilter,dwFlags );
 555     return (HDEVNOTIFY) 0xcafeaffe;
 556 }
 557
 558 /***********************************************************************
 559  *              UnregisterDeviceNotification (USER32.@)
 560  *
 561  */
 562 BOOL  WINAPI UnregisterDeviceNotification(HDEVNOTIFY hnd)
 563 {
 564     FIXME("(handle=%p), STUB!\n", hnd);
 565     return TRUE;
 566 }
 567
 568 /***********************************************************************
 569  *           GetAppCompatFlags   (USER32.@)
 570  */
 571 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
 572 {
 573     FIXME("(%p) stub\n", hTask);
 574     return 0;
 575 }
 576
 577 /***********************************************************************
 578  *           GetAppCompatFlags2   (USER32.@)
 579  */
 580 DWORD WINAPI GetAppCompatFlags2( HTASK hTask )
 581 {
 582     FIXME("(%p) stub\n", hTask);
 583     return 0;
 584 }
 585
 586
 587 /***********************************************************************
 588  *           AlignRects   (USER32.@)
 589  */
 590 BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 591 {
 592     FIXME("(%p, %d, %d, %d): stub\n", rect, b, c, d);
 593     if (rect)
 594         FIXME("rect: [[%d, %d], [%d, %d]]\n", rect->left, rect->top, rect->right, rect->bottom);
 595     /* Calls OffsetRect */
 596     return FALSE;
 597 }
 598
 599
 600 /***********************************************************************
 601  *              LoadLocalFonts (USER32.@)
 602  */
 603 VOID WINAPI LoadLocalFonts(VOID)
 604 {
 605     /* are loaded. */
 606     return;
 607 }
 608
 609
 610 /***********************************************************************
 611  *              User32InitializeImmEntryTable
 612  */
 613 BOOL WINAPI User32InitializeImmEntryTable(DWORD magic)
 614 {
 615     static const WCHAR imm32_dllW[] = {'i','m','m','3','2','.','d','l','l',0};
 616     HMODULE imm32 = GetModuleHandleW(imm32_dllW);
 617
 618     TRACE("(%x)\n", magic);
 619
 620     if (!imm32 || magic != IMM_INIT_MAGIC)
 621         return FALSE;
 622
 623     if (imm_get_ui_window)
 624         return TRUE;
 625
 626     WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
 627     WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
 628     WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
 629     WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
 630     WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
 631     WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
 632     WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
 633
 634     /* this part is not compatible with native imm32.dll */
 635     imm_get_ui_window = (void*)GetProcAddress(imm32, "__wine_get_ui_window");
 636     if (!imm_get_ui_window)
 637         FIXME("native imm32.dll not supported\n");
 638     return TRUE;
 639 }
 640
 641 /**********************************************************************
 642  * WINNLSGetIMEHotkey [USER32.@]
 643  *
 644  */
 645 UINT WINAPI WINNLSGetIMEHotkey(HWND hwnd)
 646 {
 647     FIXME("hwnd %p: stub!\n", hwnd);
 648     return 0; /* unknown */
 649 }
 650
 651 /**********************************************************************
 652  * WINNLSEnableIME [USER32.@]
 653  *
 654  */
 655 BOOL WINAPI WINNLSEnableIME(HWND hwnd, BOOL enable)
 656 {
 657     FIXME("hwnd %p enable %d: stub!\n", hwnd, enable);
 658     return TRUE; /* success (?) */
 659 }
 660
 661 /**********************************************************************
 662  * WINNLSGetEnableStatus [USER32.@]
 663  *
 664  */
 665 BOOL WINAPI WINNLSGetEnableStatus(HWND hwnd)
 666 {
 667     FIXME("hwnd %p: stub!\n", hwnd);
 668     return TRUE; /* success (?) */
 669 }
 670
 671 /**********************************************************************
 672  * SendIMEMessageExA [USER32.@]
 673  *
 674  */
 675 LRESULT WINAPI SendIMEMessageExA(HWND hwnd, LPARAM lparam)
 676 {
 677   FIXME("(%p,%lx): stub\n", hwnd, lparam);
 678   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 679   return 0;
 680 }
 681
 682 /**********************************************************************
 683  * SendIMEMessageExW [USER32.@]
 684  *
 685  */
 686 LRESULT WINAPI SendIMEMessageExW(HWND hwnd, LPARAM lparam)
 687 {
 688   FIXME("(%p,%lx): stub\n", hwnd, lparam);
 689   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 690   return 0;
 691 }
 692
 693 /**********************************************************************
 694  * DisableProcessWindowsGhosting [USER32.@]
 695  *
 696  */
 697 VOID WINAPI DisableProcessWindowsGhosting(VOID)
 698 {
 699   FIXME(": stub\n");
 700   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 701   return;
 702 }
 703
 704 /**********************************************************************
 705  * UserHandleGrantAccess [USER32.@]
 706  *
 707  */
 708 BOOL WINAPI UserHandleGrantAccess(HANDLE handle, HANDLE job, BOOL grant)
 709 {
 710     FIXME("(%p,%p,%d): stub\n", handle, job, grant);
 711     return TRUE;
 712 }
 713
 714 /**********************************************************************
 715  * RegisterPowerSettingNotification [USER32.@]
 716  */
 717 HPOWERNOTIFY WINAPI RegisterPowerSettingNotification(HANDLE recipient, const GUID *guid, DWORD flags)
 718 {
 719     FIXME("(%p,%s,%x): stub\n", recipient, debugstr_guid(guid), flags);
 720     return NULL;
 721 }
 722
 723 /**********************************************************************
 724  * SetGestureConfig [USER32.@]
 725  */
 726 BOOL WINAPI SetGestureConfig( HWND hwnd, DWORD reserved, UINT id, PGESTURECONFIG config, UINT size )
 727 {
 728     FIXME("(%p %08x %u %p %u): stub\n", hwnd, reserved, id, config, size);
 729     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 730     return FALSE;
 731 }
 732
 733 /**********************************************************************
 734  * IsTouchWindow [USER32.@]
 735  */
 736 BOOL WINAPI IsTouchWindow( HWND hwnd, PULONG flags )
 737 {
 738     FIXME("(%p %p): stub\n", hwnd, flags);
 739     return FALSE;
 740 }
 741
 742 static const WCHAR imeW[] = {'I','M','E',0};
 743 const struct builtin_class_descr IME_builtin_class =
 744 {
 745     imeW,               /* name */
 746     0,                  /* style  */
 747     WINPROC_IME,        /* proc */
 748     2*sizeof(LONG_PTR), /* extra */
 749     IDC_ARROW,          /* cursor */
 750     0                   /* brush */
 751 };
 752
 753 static BOOL is_ime_ui_msg( UINT msg )
 754 {
 755     switch(msg) {
 756     case WM_IME_STARTCOMPOSITION:
 757     case WM_IME_ENDCOMPOSITION:
 758     case WM_IME_COMPOSITION:
 759     case WM_IME_SETCONTEXT:
 760     case WM_IME_NOTIFY:
 761     case WM_IME_CONTROL:
 762     case WM_IME_COMPOSITIONFULL:
 763     case WM_IME_SELECT:
 764     case WM_IME_CHAR:
 765     case WM_IME_REQUEST:
 766     case WM_IME_KEYDOWN:
 767     case WM_IME_KEYUP:
 768         return TRUE;
 769     default:
 770         if ((msg == WM_MSIME_RECONVERTOPTIONS) ||
 771                 (msg == WM_MSIME_SERVICE) ||
 772                 (msg == WM_MSIME_MOUSE) ||
 773                 (msg == WM_MSIME_RECONVERTREQUEST) ||
 774                 (msg == WM_MSIME_RECONVERT) ||
 775                 (msg == WM_MSIME_QUERYPOSITION) ||
 776                 (msg == WM_MSIME_DOCUMENTFEED))
 777             return TRUE;
 778
 779         return FALSE;
 780     }
 781 }
 782
 783 LRESULT WINAPI ImeWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 784 {
 785     HWND uiwnd;
 786
 787     if (msg==WM_CREATE || msg==WM_NCCREATE)
 788         return TRUE;
 789
 790     if (imm_get_ui_window && is_ime_ui_msg(msg))
 791     {
 792         if ((uiwnd = imm_get_ui_window(GetKeyboardLayout(0))))
 793             return SendMessageA(uiwnd, msg, wParam, lParam);
 794         return FALSE;
 795     }
 796
 797     return DefWindowProcA(hwnd, msg, wParam, lParam);
 798 }
 799
 800 LRESULT WINAPI ImeWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 801 {
 802     HWND uiwnd;
 803
 804     if (msg==WM_CREATE || msg==WM_NCCREATE)
 805         return TRUE;
 806
 807     if (imm_get_ui_window && is_ime_ui_msg(msg))
 808     {
 809         if ((uiwnd = imm_get_ui_window(GetKeyboardLayout(0))))
 810             return SendMessageW(uiwnd, msg, wParam, lParam);
 811         return FALSE;
 812     }
 813
 814     return DefWindowProcW(hwnd, msg, wParam, lParam);
 815 }