4 * Copyright 1995 Thomas Sandford
5 * Copyright 1997 Marcus Meissner
6 * Copyright 1998 Turchanov Sergey
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.
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.
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
26 #include "wine/windef16.h"
32 #include "user_private.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(win
);
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
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
60 /***********************************************************************
61 * SignalProc32 (USER.391)
62 * UserSignalProc (USER32.@)
64 * The exact meaning of the USER signals is undocumented, but this
65 * should cover the basic idea:
67 * USIG_DLL_UNLOAD_WIN16
68 * This is sent when a 16-bit module is unloaded.
70 * USIG_DLL_UNLOAD_WIN32
71 * This is sent when a 32-bit module is unloaded.
73 * USIG_DLL_UNLOAD_ORPHANS
74 * This is sent after the last Win3.1 module is unloaded,
75 * to allow removal of orphaned menus.
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.
84 * This is called from the context of a new thread, as soon as it
88 * This is called, still in its context, just before a thread is
92 * This is called, in the parent process context, after a new process
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
100 * USIG_PROCESS_LOADED
101 * This is called after the executable file has been loaded into the
102 * new process context.
104 * USIG_PROCESS_RUNNING
105 * This is called immediately before the main entry point is called.
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
112 * USIG_PROCESS_DESTROY
113 * This is called after a process has terminated.
116 * The meaning of the dwFlags bits is as follows:
119 * Current process is 32-bit.
122 * Current process is a (Win32) GUI process.
124 * USIG_FLAGS_FEEDBACK
125 * Current process needs 'feedback' (determined from the STARTUPINFO
126 * flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
129 * The signal is being sent due to a fault.
131 WORD WINAPI
UserSignalProc( UINT uCode
, DWORD dwThreadOrProcessID
,
132 DWORD dwFlags
, HMODULE16 hModule
)
134 FIXME("(%04x, %08x, %04x, %04x)\n",
135 uCode
, dwThreadOrProcessID
, dwFlags
, hModule
);
136 /* FIXME: Should chain to GdiSignalProc now. */
141 /**********************************************************************
142 * SetLastErrorEx [USER32.@]
144 * Sets the last-error code.
149 void WINAPI
SetLastErrorEx(
150 DWORD error
, /* [in] Per-thread error code */
151 DWORD type
) /* [in] Error type */
153 TRACE("(0x%08x, 0x%08x)\n", error
,type
);
160 /* Fall through for now */
162 FIXME("(error=%08x, type=%08x): Unhandled type\n", error
,type
);
165 SetLastError( error
);
168 /******************************************************************************
169 * GetAltTabInfoA [USER32.@]
171 BOOL WINAPI
GetAltTabInfoA(HWND hwnd
, int iItem
, PALTTABINFO pati
, LPSTR pszItemText
, UINT cchItemText
)
173 FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd
, iItem
, pati
, pszItemText
, cchItemText
);
177 /******************************************************************************
178 * GetAltTabInfoW [USER32.@]
180 BOOL WINAPI
GetAltTabInfoW(HWND hwnd
, int iItem
, PALTTABINFO pati
, LPWSTR pszItemText
, UINT cchItemText
)
182 FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd
, iItem
, pati
, pszItemText
, cchItemText
);
186 /******************************************************************************
187 * SetDebugErrorLevel [USER32.@]
188 * Sets the minimum error level for generating debugging events
191 * dwLevel [I] Debugging error level
196 VOID WINAPI
SetDebugErrorLevel( DWORD dwLevel
)
198 FIXME("(%d): stub\n", dwLevel
);
202 /***********************************************************************
203 * SetWindowStationUser (USER32.@)
205 DWORD WINAPI
SetWindowStationUser(DWORD x1
,DWORD x2
)
207 FIXME("(0x%08x,0x%08x),stub!\n",x1
,x2
);
211 /***********************************************************************
212 * RegisterLogonProcess (USER32.@)
214 DWORD WINAPI
RegisterLogonProcess(HANDLE hprocess
,BOOL x
)
216 FIXME("(%p,%d),stub!\n",hprocess
,x
);
220 /***********************************************************************
221 * SetLogonNotifyWindow (USER32.@)
223 DWORD WINAPI
SetLogonNotifyWindow(HWINSTA hwinsta
,HWND hwnd
)
225 FIXME("(%p,%p),stub!\n",hwinsta
,hwnd
);
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};
235 /***********************************************************************
236 * EnumDisplayDevicesA (USER32.@)
238 BOOL WINAPI
EnumDisplayDevicesA( LPCSTR lpDevice
, DWORD i
, LPDISPLAY_DEVICEA lpDispDev
,
241 UNICODE_STRING deviceW
;
246 RtlCreateUnicodeStringFromAsciiz(&deviceW
, lpDevice
);
248 deviceW
.Buffer
= NULL
;
250 ddW
.cb
= sizeof(ddW
);
251 ret
= EnumDisplayDevicesW(deviceW
.Buffer
, i
, &ddW
, dwFlags
);
252 RtlFreeUnicodeString(&deviceW
);
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
;
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
);
268 /***********************************************************************
269 * EnumDisplayDevicesW (USER32.@)
271 BOOL WINAPI
EnumDisplayDevicesW( LPCWSTR lpDevice
, DWORD i
, LPDISPLAY_DEVICEW lpDisplayDevice
,
274 FIXME("(%s,%d,%p,0x%08x), stub!\n",debugstr_w(lpDevice
),i
,lpDisplayDevice
,dwFlags
);
279 memcpy(lpDisplayDevice
->DeviceName
, primary_device_name
, sizeof(primary_device_name
));
280 memcpy(lpDisplayDevice
->DeviceString
, primary_device_string
, sizeof(primary_device_string
));
282 lpDisplayDevice
->StateFlags
=
283 DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
|
284 DISPLAY_DEVICE_PRIMARY_DEVICE
|
285 DISPLAY_DEVICE_VGA_COMPATIBLE
;
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;
295 struct monitor_enum_info
305 /* helper callback for MonitorFromRect */
306 static BOOL CALLBACK
monitor_enum( HMONITOR monitor
, HDC hdc
, LPRECT rect
, LPARAM lp
)
308 struct monitor_enum_info
*info
= (struct monitor_enum_info
*)lp
;
311 if (IntersectRect( &intersect
, rect
, &info
->rect
))
313 /* check for larger intersecting area */
314 UINT area
= (intersect
.right
- intersect
.left
) * (intersect
.bottom
- intersect
.top
);
315 if (area
> info
->max_area
)
317 info
->max_area
= area
;
321 else if (!info
->max_area
) /* if not intersecting, check for min distance */
326 if (rect
->left
>= info
->rect
.right
) x
= info
->rect
.right
- rect
->left
;
327 else x
= rect
->right
- info
->rect
.left
;
328 if (rect
->top
>= info
->rect
.bottom
) y
= info
->rect
.bottom
- rect
->top
;
329 else y
= rect
->bottom
- info
->rect
.top
;
330 distance
= x
* x
+ y
* y
;
331 if (distance
< info
->min_distance
)
333 info
->min_distance
= distance
;
334 info
->nearest
= monitor
;
339 MONITORINFO mon_info
;
340 mon_info
.cbSize
= sizeof(mon_info
);
341 GetMonitorInfoW( monitor
, &mon_info
);
342 if (mon_info
.dwFlags
& MONITORINFOF_PRIMARY
) info
->primary
= monitor
;
347 /***********************************************************************
348 * MonitorFromRect (USER32.@)
350 HMONITOR WINAPI
MonitorFromRect( LPRECT rect
, DWORD flags
)
352 struct monitor_enum_info info
;
354 /* make sure the desktop window exists */
359 info
.min_distance
= ~0u;
363 if (!EnumDisplayMonitors( 0, NULL
, monitor_enum
, (LPARAM
)&info
)) return 0;
366 if (flags
& MONITOR_DEFAULTTOPRIMARY
) info
.ret
= info
.primary
;
367 else if (flags
& MONITOR_DEFAULTTONEAREST
) info
.ret
= info
.nearest
;
370 TRACE( "%s flags %x returning %p\n", wine_dbgstr_rect(rect
), flags
, info
.ret
);
374 /***********************************************************************
375 * MonitorFromPoint (USER32.@)
377 HMONITOR WINAPI
MonitorFromPoint( POINT pt
, DWORD flags
)
381 SetRect( &rect
, pt
.x
, pt
.y
, pt
.x
+ 1, pt
.y
+ 1 );
382 return MonitorFromRect( &rect
, flags
);
385 /***********************************************************************
386 * MonitorFromWindow (USER32.@)
388 HMONITOR WINAPI
MonitorFromWindow(HWND hWnd
, DWORD dwFlags
)
393 TRACE("(%p, 0x%08x)\n", hWnd
, dwFlags
);
395 if (IsIconic(hWnd
) && GetWindowPlacement(hWnd
, &wp
))
396 return MonitorFromRect( &wp
.rcNormalPosition
, dwFlags
);
398 if (GetWindowRect( hWnd
, &rect
))
399 return MonitorFromRect( &rect
, dwFlags
);
401 if (!(dwFlags
& (MONITOR_DEFAULTTOPRIMARY
|MONITOR_DEFAULTTONEAREST
))) return 0;
402 /* retrieve the primary */
403 SetRect( &rect
, 0, 0, 1, 1 );
404 return MonitorFromRect( &rect
, dwFlags
);
407 /***********************************************************************
408 * GetMonitorInfoA (USER32.@)
410 BOOL WINAPI
GetMonitorInfoA(HMONITOR hMonitor
, LPMONITORINFO lpMonitorInfo
)
413 MONITORINFOEXA
*miA
= (MONITORINFOEXA
*)lpMonitorInfo
;
416 miW
.cbSize
= sizeof(miW
);
418 ret
= GetMonitorInfoW(hMonitor
, (MONITORINFO
*)&miW
);
421 miA
->rcMonitor
= miW
.rcMonitor
;
422 miA
->rcWork
= miW
.rcWork
;
423 miA
->dwFlags
= miW
.dwFlags
;
424 if(miA
->cbSize
>= offsetof(MONITORINFOEXA
, szDevice
) + sizeof(miA
->szDevice
))
425 WideCharToMultiByte(CP_ACP
, 0, miW
.szDevice
, -1, miA
->szDevice
, sizeof(miA
->szDevice
), NULL
, NULL
);
429 /***********************************************************************
430 * GetMonitorInfoW (USER32.@)
432 BOOL WINAPI
GetMonitorInfoW(HMONITOR hMonitor
, LPMONITORINFO lpMonitorInfo
)
434 BOOL ret
= USER_Driver
->pGetMonitorInfo( hMonitor
, lpMonitorInfo
);
436 TRACE("flags %04x, monitor %s, work %s\n", lpMonitorInfo
->dwFlags
,
437 wine_dbgstr_rect(&lpMonitorInfo
->rcMonitor
),
438 wine_dbgstr_rect(&lpMonitorInfo
->rcWork
));
442 /***********************************************************************
443 * EnumDisplayMonitors (USER32.@)
445 BOOL WINAPI
EnumDisplayMonitors( HDC hdc
, LPRECT rect
, MONITORENUMPROC proc
, LPARAM lp
)
447 return USER_Driver
->pEnumDisplayMonitors( hdc
, rect
, proc
, lp
);
450 /***********************************************************************
451 * RegisterSystemThread (USER32.@)
453 void WINAPI
RegisterSystemThread(DWORD flags
, DWORD reserved
)
455 FIXME("(%08x, %08x)\n", flags
, reserved
);
458 /***********************************************************************
459 * RegisterShellHookWindow [USER32.@]
461 BOOL WINAPI
RegisterShellHookWindow ( HWND hWnd
)
463 FIXME("(%p): stub\n", hWnd
);
468 /***********************************************************************
469 * DeregisterShellHookWindow [USER32.@]
471 HRESULT WINAPI
DeregisterShellHookWindow ( DWORD u
)
473 FIXME("0x%08x stub\n",u
);
479 /***********************************************************************
480 * RegisterTasklist [USER32.@]
482 DWORD WINAPI
RegisterTasklist (DWORD x
)
489 /***********************************************************************
490 * RegisterDeviceNotificationA (USER32.@)
492 * See RegisterDeviceNotificationW.
494 HDEVNOTIFY WINAPI
RegisterDeviceNotificationA(HANDLE hnd
, LPVOID notifyfilter
, DWORD flags
)
496 FIXME("(hwnd=%p, filter=%p,flags=0x%08x) returns a fake device notification handle!\n",
497 hnd
,notifyfilter
,flags
);
498 return (HDEVNOTIFY
) 0xcafecafe;
501 /***********************************************************************
502 * RegisterDeviceNotificationW (USER32.@)
504 * Registers a window with the system so that it will receive
505 * notifications about a device.
508 * hRecepient [I] Window or service status handle that
509 * will receive notifications.
510 * pNotificationFilter [I] DEV_BROADCAST_HDR followed by some
511 * type-specific data.
512 * dwFlags [I] See notes
516 * A handle to the device notification.
520 * The dwFlags parameter can be one of two values:
521 *| DEVICE_NOTIFY_WINDOW_HANDLE - hRecepient is a window handle
522 *| DEVICE_NOTIFY_SERVICE_HANDLE - hRecepient is a service status handle
524 HDEVNOTIFY WINAPI
RegisterDeviceNotificationW(HANDLE hRecepient
, LPVOID pNotificationFilter
, DWORD dwFlags
)
526 FIXME("(hwnd=%p, filter=%p,flags=0x%08x) returns a fake device notification handle!\n",
527 hRecepient
,pNotificationFilter
,dwFlags
);
528 return (HDEVNOTIFY
) 0xcafeaffe;
531 /***********************************************************************
532 * UnregisterDeviceNotification (USER32.@)
535 BOOL WINAPI
UnregisterDeviceNotification(HDEVNOTIFY hnd
)
537 FIXME("(handle=%p), STUB!\n", hnd
);
541 /***********************************************************************
542 * GetAppCompatFlags (USER32.@)
544 DWORD WINAPI
GetAppCompatFlags( HTASK hTask
)
546 FIXME("(%p) stub\n", hTask
);
550 /***********************************************************************
551 * GetAppCompatFlags2 (USER32.@)
553 DWORD WINAPI
GetAppCompatFlags2( HTASK hTask
)
555 FIXME("(%p) stub\n", hTask
);
560 /***********************************************************************
561 * AlignRects (USER32.@)
563 BOOL WINAPI
AlignRects(LPRECT rect
, DWORD b
, DWORD c
, DWORD d
)
565 FIXME("(%p, %d, %d, %d): stub\n", rect
, b
, c
, d
);
567 FIXME("rect: [[%d, %d], [%d, %d]]\n", rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
568 /* Calls OffsetRect */
573 /***********************************************************************
574 * LoadLocalFonts (USER32.@)
576 VOID WINAPI
LoadLocalFonts(VOID
)
583 /***********************************************************************
584 * User32InitializeImmEntryTable
586 BOOL WINAPI
User32InitializeImmEntryTable(LPVOID ptr
)
588 FIXME("(%p): stub\n", ptr
);
592 /**********************************************************************
593 * WINNLSGetIMEHotkey [USER32.@]
596 UINT WINAPI
WINNLSGetIMEHotkey(HWND hUnknown1
)
598 FIXME("hUnknown1 %p: stub!\n", hUnknown1
);
599 return 0; /* unknown */
602 /**********************************************************************
603 * WINNLSEnableIME [USER32.@]
606 BOOL WINAPI
WINNLSEnableIME(HWND hUnknown1
, BOOL bUnknown2
)
608 FIXME("hUnknown1 %p bUnknown2 %d: stub!\n", hUnknown1
, bUnknown2
);
609 return TRUE
; /* success (?) */
612 /**********************************************************************
613 * WINNLSGetEnableStatus [USER32.@]
616 BOOL WINAPI
WINNLSGetEnableStatus(HWND hUnknown1
)
618 FIXME("hUnknown1 %p: stub!\n", hUnknown1
);
619 return TRUE
; /* success (?) */
622 /**********************************************************************
623 * SendIMEMessageExA [USER32.@]
626 LRESULT WINAPI
SendIMEMessageExA(HWND p1
, LPARAM p2
)
628 FIXME("(%p,%lx): stub\n", p1
, p2
);
629 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
633 /**********************************************************************
634 * SendIMEMessageExW [USER32.@]
637 LRESULT WINAPI
SendIMEMessageExW(HWND p1
, LPARAM p2
)
639 FIXME("(%p,%lx): stub\n", p1
, p2
);
640 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
644 /**********************************************************************
645 * DisableProcessWindowsGhosting [USER32.@]
648 VOID WINAPI
DisableProcessWindowsGhosting(VOID
)
651 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);