comctl32/monthcal: Cache window GWL_STYLE.
[wine] / 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  *                    GetProcessDefaultLayout [USER32.@]
204  *
205  * Gets the default layout for parentless windows.
206  * Right now, just returns 0 (left-to-right).
207  *
208  * RETURNS
209  *    Success: Nonzero
210  *    Failure: Zero
211  *
212  * BUGS
213  *    No RTL
214  */
215 BOOL WINAPI GetProcessDefaultLayout( DWORD *pdwDefaultLayout )
216 {
217     if ( !pdwDefaultLayout ) {
218         SetLastError( ERROR_INVALID_PARAMETER );
219         return FALSE;
220      }
221     FIXME( "( %p ): No BiDi\n", pdwDefaultLayout );
222     *pdwDefaultLayout = 0;
223     return TRUE;
224 }
225
226
227 /******************************************************************************
228  *                    SetProcessDefaultLayout [USER32.@]
229  *
230  * Sets the default layout for parentless windows.
231  * Right now, only accepts 0 (left-to-right).
232  *
233  * RETURNS
234  *    Success: Nonzero
235  *    Failure: Zero
236  *
237  * BUGS
238  *    No RTL
239  */
240 BOOL WINAPI SetProcessDefaultLayout( DWORD dwDefaultLayout )
241 {
242     if ( dwDefaultLayout == 0 )
243         return TRUE;
244     FIXME( "( %08x ): No BiDi\n", dwDefaultLayout );
245     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
246     return FALSE;
247 }
248
249
250 /***********************************************************************
251  *              SetWindowStationUser (USER32.@)
252  */
253 DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2)
254 {
255     FIXME("(0x%08x,0x%08x),stub!\n",x1,x2);
256     return 1;
257 }
258
259 /***********************************************************************
260  *              RegisterLogonProcess (USER32.@)
261  */
262 DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x)
263 {
264     FIXME("(%p,%d),stub!\n",hprocess,x);
265     return 1;
266 }
267
268 /***********************************************************************
269  *              SetLogonNotifyWindow (USER32.@)
270  */
271 DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
272 {
273     FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
274     return 1;
275 }
276
277 static const WCHAR primary_device_name[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0};
278 static const WCHAR primary_device_string[] = {'X','1','1',' ','W','i','n','d','o','w','i','n','g',' ',
279                                               'S','y','s','t','e','m',0};
280
281 /***********************************************************************
282  *              EnumDisplayDevicesA (USER32.@)
283  */
284 BOOL WINAPI EnumDisplayDevicesA( LPCSTR lpDevice, DWORD i, LPDISPLAY_DEVICEA lpDispDev,
285                                  DWORD dwFlags )
286 {
287     UNICODE_STRING deviceW;
288     DISPLAY_DEVICEW ddW;
289     BOOL ret;
290
291     if(lpDevice)
292         RtlCreateUnicodeStringFromAsciiz(&deviceW, lpDevice); 
293     else
294         deviceW.Buffer = NULL;
295
296     ddW.cb = sizeof(ddW);
297     ret = EnumDisplayDevicesW(deviceW.Buffer, i, &ddW, dwFlags);
298     RtlFreeUnicodeString(&deviceW);
299
300     if(!ret) return ret;
301
302     WideCharToMultiByte(CP_ACP, 0, ddW.DeviceName, -1, lpDispDev->DeviceName, sizeof(lpDispDev->DeviceName), NULL, NULL);
303     WideCharToMultiByte(CP_ACP, 0, ddW.DeviceString, -1, lpDispDev->DeviceString, sizeof(lpDispDev->DeviceString), NULL, NULL);
304     lpDispDev->StateFlags = ddW.StateFlags;
305
306     if(lpDispDev->cb >= offsetof(DISPLAY_DEVICEA, DeviceID) + sizeof(lpDispDev->DeviceID))
307         WideCharToMultiByte(CP_ACP, 0, ddW.DeviceID, -1, lpDispDev->DeviceID, sizeof(lpDispDev->DeviceID), NULL, NULL);
308     if(lpDispDev->cb >= offsetof(DISPLAY_DEVICEA, DeviceKey) + sizeof(lpDispDev->DeviceKey))
309         WideCharToMultiByte(CP_ACP, 0, ddW.DeviceKey, -1, lpDispDev->DeviceKey, sizeof(lpDispDev->DeviceKey), NULL, NULL);
310
311     return TRUE;
312 }
313
314 /***********************************************************************
315  *              EnumDisplayDevicesW (USER32.@)
316  */
317 BOOL WINAPI EnumDisplayDevicesW( LPCWSTR lpDevice, DWORD i, LPDISPLAY_DEVICEW lpDisplayDevice,
318                                  DWORD dwFlags )
319 {
320     FIXME("(%s,%d,%p,0x%08x), stub!\n",debugstr_w(lpDevice),i,lpDisplayDevice,dwFlags);
321
322     if (i)
323         return FALSE;
324
325     memcpy(lpDisplayDevice->DeviceName, primary_device_name, sizeof(primary_device_name));
326     memcpy(lpDisplayDevice->DeviceString, primary_device_string, sizeof(primary_device_string));
327   
328     lpDisplayDevice->StateFlags =
329         DISPLAY_DEVICE_ATTACHED_TO_DESKTOP |
330         DISPLAY_DEVICE_PRIMARY_DEVICE |
331         DISPLAY_DEVICE_VGA_COMPATIBLE;
332
333     if(lpDisplayDevice->cb >= offsetof(DISPLAY_DEVICEW, DeviceID) + sizeof(lpDisplayDevice->DeviceID))
334         lpDisplayDevice->DeviceID[0] = 0;
335     if(lpDisplayDevice->cb >= offsetof(DISPLAY_DEVICEW, DeviceKey) + sizeof(lpDisplayDevice->DeviceKey))
336         lpDisplayDevice->DeviceKey[0] = 0;
337
338     return TRUE;
339 }
340
341 struct monitor_enum_info
342 {
343     RECT     rect;
344     UINT     max_area;
345     UINT     min_distance;
346     HMONITOR primary;
347     HMONITOR nearest;
348     HMONITOR ret;
349 };
350
351 /* helper callback for MonitorFromRect */
352 static BOOL CALLBACK monitor_enum( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
353 {
354     struct monitor_enum_info *info = (struct monitor_enum_info *)lp;
355     RECT intersect;
356
357     if (IntersectRect( &intersect, rect, &info->rect ))
358     {
359         /* check for larger intersecting area */
360         UINT area = (intersect.right - intersect.left) * (intersect.bottom - intersect.top);
361         if (area > info->max_area)
362         {
363             info->max_area = area;
364             info->ret = monitor;
365         }
366     }
367     else if (!info->max_area)  /* if not intersecting, check for min distance */
368     {
369         UINT distance;
370         INT x, y;
371
372         if (rect->left >= info->rect.right) x = info->rect.right - rect->left;
373         else x = rect->right - info->rect.left;
374         if (rect->top >= info->rect.bottom) y = info->rect.bottom - rect->top;
375         else y = rect->bottom - info->rect.top;
376         distance = x * x + y * y;
377         if (distance < info->min_distance)
378         {
379             info->min_distance = distance;
380             info->nearest = monitor;
381         }
382     }
383     if (!info->primary)
384     {
385         MONITORINFO mon_info;
386         mon_info.cbSize = sizeof(mon_info);
387         GetMonitorInfoW( monitor, &mon_info );
388         if (mon_info.dwFlags & MONITORINFOF_PRIMARY) info->primary = monitor;
389     }
390     return TRUE;
391 }
392
393 /***********************************************************************
394  *              MonitorFromRect (USER32.@)
395  */
396 HMONITOR WINAPI MonitorFromRect( LPRECT rect, DWORD flags )
397 {
398     struct monitor_enum_info info;
399
400     /* make sure the desktop window exists */
401     GetDesktopWindow();
402
403     info.rect         = *rect;
404     info.max_area     = 0;
405     info.min_distance = ~0u;
406     info.primary      = 0;
407     info.nearest      = 0;
408     info.ret          = 0;
409     if (!EnumDisplayMonitors( 0, NULL, monitor_enum, (LPARAM)&info )) return 0;
410     if (!info.ret)
411     {
412         if (flags & MONITOR_DEFAULTTOPRIMARY) info.ret = info.primary;
413         else if (flags & MONITOR_DEFAULTTONEAREST) info.ret = info.nearest;
414     }
415
416     TRACE( "%s flags %x returning %p\n", wine_dbgstr_rect(rect), flags, info.ret );
417     return info.ret;
418 }
419
420 /***********************************************************************
421  *              MonitorFromPoint (USER32.@)
422  */
423 HMONITOR WINAPI MonitorFromPoint( POINT pt, DWORD flags )
424 {
425     RECT rect;
426
427     SetRect( &rect, pt.x, pt.y, pt.x + 1, pt.y + 1 );
428     return MonitorFromRect( &rect, flags );
429 }
430
431 /***********************************************************************
432  *              MonitorFromWindow (USER32.@)
433  */
434 HMONITOR WINAPI MonitorFromWindow(HWND hWnd, DWORD dwFlags)
435 {
436     RECT rect;
437     WINDOWPLACEMENT wp;
438
439     TRACE("(%p, 0x%08x)\n", hWnd, dwFlags);
440
441     if (IsIconic(hWnd) && GetWindowPlacement(hWnd, &wp))
442         return MonitorFromRect( &wp.rcNormalPosition, dwFlags );
443
444     if (GetWindowRect( hWnd, &rect ))
445         return MonitorFromRect( &rect, dwFlags );
446
447     if (!(dwFlags & (MONITOR_DEFAULTTOPRIMARY|MONITOR_DEFAULTTONEAREST))) return 0;
448     /* retrieve the primary */
449     SetRect( &rect, 0, 0, 1, 1 );
450     return MonitorFromRect( &rect, dwFlags );
451 }
452
453 /***********************************************************************
454  *              GetMonitorInfoA (USER32.@)
455  */
456 BOOL WINAPI GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
457 {
458     MONITORINFOEXW miW;
459     MONITORINFOEXA *miA = (MONITORINFOEXA*)lpMonitorInfo;
460     BOOL ret;
461
462     miW.cbSize = sizeof(miW);
463
464     ret = GetMonitorInfoW(hMonitor, (MONITORINFO*)&miW);
465     if(!ret) return ret;
466
467     miA->rcMonitor = miW.rcMonitor;
468     miA->rcWork = miW.rcWork;
469     miA->dwFlags = miW.dwFlags;
470     if(miA->cbSize >= offsetof(MONITORINFOEXA, szDevice) + sizeof(miA->szDevice))
471         WideCharToMultiByte(CP_ACP, 0, miW.szDevice, -1, miA->szDevice, sizeof(miA->szDevice), NULL, NULL);
472     return ret;
473 }
474
475 /***********************************************************************
476  *              GetMonitorInfoW (USER32.@)
477  */
478 BOOL WINAPI GetMonitorInfoW(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
479 {
480     BOOL ret = USER_Driver->pGetMonitorInfo( hMonitor, lpMonitorInfo );
481     if (ret)
482         TRACE("flags %04x, monitor %s, work %s\n", lpMonitorInfo->dwFlags,
483               wine_dbgstr_rect(&lpMonitorInfo->rcMonitor),
484               wine_dbgstr_rect(&lpMonitorInfo->rcWork));
485     return ret;
486 }
487
488 /***********************************************************************
489  *              EnumDisplayMonitors (USER32.@)
490  */
491 BOOL WINAPI EnumDisplayMonitors( HDC hdc, LPRECT rect, MONITORENUMPROC proc, LPARAM lp )
492 {
493     return USER_Driver->pEnumDisplayMonitors( hdc, rect, proc, lp );
494 }
495
496 /***********************************************************************
497  *              RegisterSystemThread (USER32.@)
498  */
499 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
500 {
501     FIXME("(%08x, %08x)\n", flags, reserved);
502 }
503
504 /***********************************************************************
505  *           RegisterShellHookWindow                    [USER32.@]
506  */
507 BOOL WINAPI RegisterShellHookWindow ( HWND hWnd )
508 {
509     FIXME("(%p): stub\n", hWnd);
510     return 0;
511 }
512
513
514 /***********************************************************************
515  *           DeregisterShellHookWindow                  [USER32.@]
516  */
517 HRESULT WINAPI DeregisterShellHookWindow ( DWORD u )
518 {
519     FIXME("0x%08x stub\n",u);
520     return 0;
521
522 }
523
524
525 /***********************************************************************
526  *           RegisterTasklist                           [USER32.@]
527  */
528 DWORD WINAPI RegisterTasklist (DWORD x)
529 {
530     FIXME("0x%08x\n",x);
531     return TRUE;
532 }
533
534
535 /***********************************************************************
536  *              RegisterDeviceNotificationA (USER32.@)
537  *
538  * See RegisterDeviceNotificationW.
539  */
540 HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE hnd, LPVOID notifyfilter, DWORD flags)
541 {
542     FIXME("(hwnd=%p, filter=%p,flags=0x%08x),\n"
543           "\treturns a fake device notification handle!\n", hnd,notifyfilter,flags );
544     return (HDEVNOTIFY) 0xcafecafe;
545 }
546
547 /***********************************************************************
548  *              RegisterDeviceNotificationW (USER32.@)
549  *
550  * Registers a window with the system so that it will receive
551  * notifications about a device.
552  *
553  * PARAMS
554  *     hRecepient           [I] Window or service status handle that
555  *                              will receive notifications.
556  *     pNotificationFilter  [I] DEV_BROADCAST_HDR followed by some
557  *                              type-specific data.
558  *     dwFlags              [I] See notes
559  *
560  * RETURNS
561  *
562  * A handle to the device notification.
563  *
564  * NOTES
565  *
566  * The dwFlags parameter can be one of two values:
567  *| DEVICE_NOTIFY_WINDOW_HANDLE  - hRecepient is a window handle
568  *| DEVICE_NOTIFY_SERVICE_HANDLE - hRecepient is a service status handle
569  */
570 HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE hRecepient, LPVOID pNotificationFilter, DWORD dwFlags)
571 {
572     FIXME("(hwnd=%p, filter=%p,flags=0x%08x),\n"
573           "\treturns a fake device notification handle!\n", hRecepient,pNotificationFilter,dwFlags );
574     return (HDEVNOTIFY) 0xcafeaffe;
575 }
576
577 /***********************************************************************
578  *              UnregisterDeviceNotification (USER32.@)
579  *
580  */
581 BOOL  WINAPI UnregisterDeviceNotification(HDEVNOTIFY hnd)
582 {
583     FIXME("(handle=%p), STUB!\n", hnd);
584     return TRUE;
585 }
586
587 /***********************************************************************
588  *           GetAppCompatFlags   (USER32.@)
589  */
590 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
591 {
592     FIXME("(%p) stub\n", hTask);
593     return 0;
594 }
595
596 /***********************************************************************
597  *           GetAppCompatFlags2   (USER32.@)
598  */
599 DWORD WINAPI GetAppCompatFlags2( HTASK hTask )
600 {
601     FIXME("(%p) stub\n", hTask);
602     return 0;
603 }
604
605
606 /***********************************************************************
607  *           AlignRects   (USER32.@)
608  */
609 BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
610 {
611     FIXME("(%p, %d, %d, %d): stub\n", rect, b, c, d);
612     if (rect)
613         FIXME("rect: [[%d, %d], [%d, %d]]\n", rect->left, rect->top, rect->right, rect->bottom);
614     /* Calls OffsetRect */
615     return FALSE;
616 }
617
618
619 /***********************************************************************
620  *              LoadLocalFonts (USER32.@)
621  */
622 VOID WINAPI LoadLocalFonts(VOID)
623 {
624     /* are loaded. */
625     return;
626 }
627
628
629 /***********************************************************************
630  *              USER_489 (USER.489)
631  */
632 LONG WINAPI stub_USER_489(void) { FIXME("stub\n"); return 0; }
633
634 /***********************************************************************
635  *              USER_490 (USER.490)
636  */
637 LONG WINAPI stub_USER_490(void) { FIXME("stub\n"); return 0; }
638
639 /***********************************************************************
640  *              USER_492 (USER.492)
641  */
642 LONG WINAPI stub_USER_492(void) { FIXME("stub\n"); return 0; }
643
644 /***********************************************************************
645  *              USER_496 (USER.496)
646  */
647 LONG WINAPI stub_USER_496(void) { FIXME("stub\n"); return 0; }
648
649 /***********************************************************************
650  *              User32InitializeImmEntryTable
651  */
652 BOOL WINAPI User32InitializeImmEntryTable(LPVOID ptr)
653 {
654   FIXME("(%p): stub\n", ptr);
655   return TRUE;
656 }
657
658 /**********************************************************************
659  * WINNLSGetIMEHotkey [USER32.@]
660  *
661  */
662 UINT WINAPI WINNLSGetIMEHotkey(HWND hUnknown1)
663 {
664     FIXME("hUnknown1 %p: stub!\n", hUnknown1);
665     return 0; /* unknown */
666 }
667
668 /**********************************************************************
669  * WINNLSEnableIME [USER32.@]
670  *
671  */
672 BOOL WINAPI WINNLSEnableIME(HWND hUnknown1, BOOL bUnknown2)
673 {
674     FIXME("hUnknown1 %p bUnknown2 %d: stub!\n", hUnknown1, bUnknown2);
675     return TRUE; /* success (?) */
676 }
677
678 /**********************************************************************
679  * WINNLSGetEnableStatus [USER32.@]
680  *
681  */
682 BOOL WINAPI WINNLSGetEnableStatus(HWND hUnknown1)
683 {
684     FIXME("hUnknown1 %p: stub!\n", hUnknown1);
685     return TRUE; /* success (?) */
686 }
687
688 /**********************************************************************
689  * SendIMEMessageExA [USER32.@]
690  *
691  */
692 LRESULT WINAPI SendIMEMessageExA(HWND p1, LPARAM p2)
693 {
694   FIXME("(%p,%lx): stub\n", p1, p2);
695   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
696   return 0;
697 }
698
699 /**********************************************************************
700  * SendIMEMessageExW [USER32.@]
701  *
702  */
703 LRESULT WINAPI SendIMEMessageExW(HWND p1, LPARAM p2)
704 {
705   FIXME("(%p,%lx): stub\n", p1, p2);
706   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
707   return 0;
708 }
709
710 /**********************************************************************
711  * DisableProcessWindowsGhosting [USER32.@]
712  *
713  */
714 VOID WINAPI DisableProcessWindowsGhosting(VOID)
715 {
716   FIXME(": stub\n");
717   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
718   return;
719 }