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 return USER_Driver->pGetMonitorInfo( hMonitor, lpMonitorInfo );
481 }
482
483 /***********************************************************************
484 * EnumDisplayMonitors (USER32.@)
485 */
486 BOOL WINAPI EnumDisplayMonitors( HDC hdc, LPRECT rect, MONITORENUMPROC proc, LPARAM lp )
487 {
488 return USER_Driver->pEnumDisplayMonitors( hdc, rect, proc, lp );
489 }
490
491 /***********************************************************************
492 * RegisterSystemThread (USER32.@)
493 */
494 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
495 {
496 FIXME("(%08x, %08x)\n", flags, reserved);
497 }
498
499 /***********************************************************************
500 * RegisterShellHookWindow [USER32.@]
501 */
502 BOOL WINAPI RegisterShellHookWindow ( HWND hWnd )
503 {
504 FIXME("(%p): stub\n", hWnd);
505 return 0;
506 }
507
508
509 /***********************************************************************
510 * DeregisterShellHookWindow [USER32.@]
511 */
512 HRESULT WINAPI DeregisterShellHookWindow ( DWORD u )
513 {
514 FIXME("0x%08x stub\n",u);
515 return 0;
516
517 }
518
519
520 /***********************************************************************
521 * RegisterTasklist [USER32.@]
522 */
523 DWORD WINAPI RegisterTasklist (DWORD x)
524 {
525 FIXME("0x%08x\n",x);
526 return TRUE;
527 }
528
529
530 /***********************************************************************
531 * RegisterDeviceNotificationA (USER32.@)
532 *
533 * See RegisterDeviceNotificationW.
534 */
535 HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE hnd, LPVOID notifyfilter, DWORD flags)
536 {
537 FIXME("(hwnd=%p, filter=%p,flags=0x%08x),\n"
538 "\treturns a fake device notification handle!\n", hnd,notifyfilter,flags );
539 return (HDEVNOTIFY) 0xcafecafe;
540 }
541
542 /***********************************************************************
543 * RegisterDeviceNotificationW (USER32.@)
544 *
545 * Registers a window with the system so that it will receive
546 * notifications about a device.
547 *
548 * PARAMS
549 * hRecepient [I] Window or service status handle that
550 * will receive notifications.
551 * pNotificationFilter [I] DEV_BROADCAST_HDR followed by some
552 * type-specific data.
553 * dwFlags [I] See notes
554 *
555 * RETURNS
556 *
557 * A handle to the device notification.
558 *
559 * NOTES
560 *
561 * The dwFlags parameter can be one of two values:
562 *| DEVICE_NOTIFY_WINDOW_HANDLE - hRecepient is a window handle
563 *| DEVICE_NOTIFY_SERVICE_HANDLE - hRecepient is a service status handle
564 */
565 HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE hRecepient, LPVOID pNotificationFilter, DWORD dwFlags)
566 {
567 FIXME("(hwnd=%p, filter=%p,flags=0x%08x), STUB!\n", hRecepient,pNotificationFilter,dwFlags );
568 return 0;
569 }
570
571 /***********************************************************************
572 * UnregisterDeviceNotification (USER32.@)
573 *
574 */
575 BOOL WINAPI UnregisterDeviceNotification(HDEVNOTIFY hnd)
576 {
577 FIXME("(handle=%p), STUB!\n", hnd);
578 return TRUE;
579 }
580
581 /***********************************************************************
582 * GetAppCompatFlags (USER32.@)
583 */
584 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
585 {
586 FIXME("(%p) stub\n", hTask);
587 return 0;
588 }
589
590 /***********************************************************************
591 * GetAppCompatFlags2 (USER32.@)
592 */
593 DWORD WINAPI GetAppCompatFlags2( HTASK hTask )
594 {
595 FIXME("(%p) stub\n", hTask);
596 return 0;
597 }
598
599
600 /***********************************************************************
601 * AlignRects (USER32.@)
602 */
603 BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
604 {
605 FIXME("(%p, %d, %d, %d): stub\n", rect, b, c, d);
606 if (rect)
607 FIXME("rect: [[%d, %d], [%d, %d]]\n", rect->left, rect->top, rect->right, rect->bottom);
608 /* Calls OffsetRect */
609 return FALSE;
610 }
611
612
613 /***********************************************************************
614 * LoadLocalFonts (USER32.@)
615 */
616 VOID WINAPI LoadLocalFonts(VOID)
617 {
618 /* are loaded. */
619 return;
620 }
621
622
623 /***********************************************************************
624 * USER_489 (USER.489)
625 */
626 LONG WINAPI stub_USER_489(void) { FIXME("stub\n"); return 0; }
627
628 /***********************************************************************
629 * USER_490 (USER.490)
630 */
631 LONG WINAPI stub_USER_490(void) { FIXME("stub\n"); return 0; }
632
633 /***********************************************************************
634 * USER_492 (USER.492)
635 */
636 LONG WINAPI stub_USER_492(void) { FIXME("stub\n"); return 0; }
637
638 /***********************************************************************
639 * USER_496 (USER.496)
640 */
641 LONG WINAPI stub_USER_496(void) { FIXME("stub\n"); return 0; }
642
643 /***********************************************************************
644 * User32InitializeImmEntryTable
645 */
646 BOOL WINAPI User32InitializeImmEntryTable(LPVOID ptr)
647 {
648 FIXME("(%p): stub\n", ptr);
649 return TRUE;
650 }
651
652 /**********************************************************************
653 * WINNLSGetIMEHotkey [USER32.@]
654 *
655 */
656 UINT WINAPI WINNLSGetIMEHotkey(HWND hUnknown1)
657 {
658 FIXME("hUnknown1 %p: stub!\n", hUnknown1);
659 return 0; /* unknown */
660 }
661
662 /**********************************************************************
663 * WINNLSEnableIME [USER32.@]
664 *
665 */
666 BOOL WINAPI WINNLSEnableIME(HWND hUnknown1, BOOL bUnknown2)
667 {
668 FIXME("hUnknown1 %p bUnknown2 %d: stub!\n", hUnknown1, bUnknown2);
669 return TRUE; /* success (?) */
670 }
671
672 /**********************************************************************
673 * WINNLSGetEnableStatus [USER32.@]
674 *
675 */
676 BOOL WINAPI WINNLSGetEnableStatus(HWND hUnknown1)
677 {
678 FIXME("hUnknown1 %p: stub!\n", hUnknown1);
679 return TRUE; /* success (?) */
680 }
681
682 /**********************************************************************
683 * SendIMEMessageExA [USER32.@]
684 *
685 */
686 LRESULT WINAPI SendIMEMessageExA(HWND p1, LPARAM p2)
687 {
688 FIXME("(%p,%lx): stub\n", p1, p2);
689 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
690 return 0;
691 }
692
693 /**********************************************************************
694 * SendIMEMessageExW [USER32.@]
695 *
696 */
697 LRESULT WINAPI SendIMEMessageExW(HWND p1, LPARAM p2)
698 {
699 FIXME("(%p,%lx): stub\n", p1, p2);
700 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
701 return 0;
702 }
703
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.