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