2000-08-04 04:21:02 +00:00
|
|
|
/*
|
|
|
|
* Misc USER functions
|
|
|
|
*
|
|
|
|
* Copyright 1995 Thomas Sandford
|
|
|
|
* Copyright 1997 Marcus Meissner
|
2005-06-09 10:07:04 +00:00
|
|
|
* Copyright 1998 Turchanov Sergey
|
2002-03-09 23:29:33 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
2006-05-18 12:49:52 +00:00
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
2000-08-04 04:21:02 +00:00
|
|
|
*/
|
|
|
|
|
2003-09-05 23:08:26 +00:00
|
|
|
#include <stdarg.h>
|
|
|
|
|
2000-08-04 04:21:02 +00:00
|
|
|
#include "windef.h"
|
2005-05-25 18:42:37 +00:00
|
|
|
#include "wine/windef16.h"
|
2000-08-04 04:21:02 +00:00
|
|
|
#include "winbase.h"
|
2005-04-27 11:09:55 +00:00
|
|
|
#include "wingdi.h"
|
2000-08-04 04:21:02 +00:00
|
|
|
#include "winuser.h"
|
2004-03-09 00:41:39 +00:00
|
|
|
#include "winnls.h"
|
2005-09-28 10:17:13 +00:00
|
|
|
#include "winternl.h"
|
2000-08-04 04:21:02 +00:00
|
|
|
|
2005-06-09 10:07:04 +00:00
|
|
|
#include "wine/unicode.h"
|
2002-03-09 23:29:33 +00:00
|
|
|
#include "wine/debug.h"
|
2000-08-04 04:21:02 +00:00
|
|
|
|
2002-03-09 23:29:33 +00:00
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(win);
|
2000-08-04 04:21:02 +00:00
|
|
|
|
2005-05-25 18:42:37 +00:00
|
|
|
/* USER signal proc flags and codes */
|
|
|
|
/* See UserSignalProc for comments */
|
|
|
|
#define USIG_FLAGS_WIN32 0x0001
|
|
|
|
#define USIG_FLAGS_GUI 0x0002
|
|
|
|
#define USIG_FLAGS_FEEDBACK 0x0004
|
|
|
|
#define USIG_FLAGS_FAULT 0x0008
|
|
|
|
|
|
|
|
#define USIG_DLL_UNLOAD_WIN16 0x0001
|
|
|
|
#define USIG_DLL_UNLOAD_WIN32 0x0002
|
|
|
|
#define USIG_FAULT_DIALOG_PUSH 0x0003
|
|
|
|
#define USIG_FAULT_DIALOG_POP 0x0004
|
|
|
|
#define USIG_DLL_UNLOAD_ORPHANS 0x0005
|
|
|
|
#define USIG_THREAD_INIT 0x0010
|
|
|
|
#define USIG_THREAD_EXIT 0x0020
|
|
|
|
#define USIG_PROCESS_CREATE 0x0100
|
|
|
|
#define USIG_PROCESS_INIT 0x0200
|
|
|
|
#define USIG_PROCESS_EXIT 0x0300
|
|
|
|
#define USIG_PROCESS_DESTROY 0x0400
|
|
|
|
#define USIG_PROCESS_RUNNING 0x0500
|
|
|
|
#define USIG_PROCESS_LOADED 0x0600
|
|
|
|
|
2005-06-09 10:07:04 +00:00
|
|
|
#define xPRIMARY_MONITOR ((HMONITOR)0x12340042)
|
2005-05-25 18:42:37 +00:00
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* SignalProc32 (USER.391)
|
|
|
|
* UserSignalProc (USER32.@)
|
|
|
|
*
|
|
|
|
* The exact meaning of the USER signals is undocumented, but this
|
|
|
|
* should cover the basic idea:
|
|
|
|
*
|
|
|
|
* USIG_DLL_UNLOAD_WIN16
|
|
|
|
* This is sent when a 16-bit module is unloaded.
|
|
|
|
*
|
|
|
|
* USIG_DLL_UNLOAD_WIN32
|
|
|
|
* This is sent when a 32-bit module is unloaded.
|
|
|
|
*
|
|
|
|
* USIG_DLL_UNLOAD_ORPHANS
|
|
|
|
* This is sent after the last Win3.1 module is unloaded,
|
|
|
|
* to allow removal of orphaned menus.
|
|
|
|
*
|
|
|
|
* USIG_FAULT_DIALOG_PUSH
|
|
|
|
* USIG_FAULT_DIALOG_POP
|
|
|
|
* These are called to allow USER to prepare for displaying a
|
|
|
|
* fault dialog, even though the fault might have happened while
|
|
|
|
* inside a USER critical section.
|
|
|
|
*
|
|
|
|
* USIG_THREAD_INIT
|
|
|
|
* This is called from the context of a new thread, as soon as it
|
|
|
|
* has started to run.
|
|
|
|
*
|
|
|
|
* USIG_THREAD_EXIT
|
|
|
|
* This is called, still in its context, just before a thread is
|
|
|
|
* about to terminate.
|
|
|
|
*
|
|
|
|
* USIG_PROCESS_CREATE
|
|
|
|
* This is called, in the parent process context, after a new process
|
|
|
|
* has been created.
|
|
|
|
*
|
|
|
|
* USIG_PROCESS_INIT
|
|
|
|
* This is called in the new process context, just after the main thread
|
|
|
|
* has started execution (after the main thread's USIG_THREAD_INIT has
|
|
|
|
* been sent).
|
|
|
|
*
|
|
|
|
* USIG_PROCESS_LOADED
|
|
|
|
* This is called after the executable file has been loaded into the
|
|
|
|
* new process context.
|
|
|
|
*
|
|
|
|
* USIG_PROCESS_RUNNING
|
|
|
|
* This is called immediately before the main entry point is called.
|
|
|
|
*
|
|
|
|
* USIG_PROCESS_EXIT
|
|
|
|
* This is called in the context of a process that is about to
|
|
|
|
* terminate (but before the last thread's USIG_THREAD_EXIT has
|
|
|
|
* been sent).
|
|
|
|
*
|
|
|
|
* USIG_PROCESS_DESTROY
|
|
|
|
* This is called after a process has terminated.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* The meaning of the dwFlags bits is as follows:
|
|
|
|
*
|
|
|
|
* USIG_FLAGS_WIN32
|
|
|
|
* Current process is 32-bit.
|
|
|
|
*
|
|
|
|
* USIG_FLAGS_GUI
|
|
|
|
* Current process is a (Win32) GUI process.
|
|
|
|
*
|
|
|
|
* USIG_FLAGS_FEEDBACK
|
|
|
|
* Current process needs 'feedback' (determined from the STARTUPINFO
|
|
|
|
* flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
|
|
|
|
*
|
|
|
|
* USIG_FLAGS_FAULT
|
|
|
|
* The signal is being sent due to a fault.
|
|
|
|
*/
|
|
|
|
WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
|
|
|
|
DWORD dwFlags, HMODULE16 hModule )
|
|
|
|
{
|
|
|
|
FIXME("(%04x, %08lx, %04lx, %04x)\n",
|
|
|
|
uCode, dwThreadOrProcessID, dwFlags, hModule );
|
|
|
|
/* FIXME: Should chain to GdiSignalProc now. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-08-04 04:21:02 +00:00
|
|
|
/**********************************************************************
|
2005-04-20 15:18:42 +00:00
|
|
|
* SetLastErrorEx [USER32.@]
|
|
|
|
*
|
|
|
|
* Sets the last-error code.
|
2000-08-04 04:21:02 +00:00
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* None.
|
|
|
|
*/
|
|
|
|
void WINAPI SetLastErrorEx(
|
|
|
|
DWORD error, /* [in] Per-thread error code */
|
|
|
|
DWORD type) /* [in] Error type */
|
|
|
|
{
|
|
|
|
TRACE("(0x%08lx, 0x%08lx)\n", error,type);
|
|
|
|
switch(type) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case SLE_ERROR:
|
|
|
|
case SLE_MINORERROR:
|
|
|
|
case SLE_WARNING:
|
|
|
|
/* Fall through for now */
|
|
|
|
default:
|
|
|
|
FIXME("(error=%08lx, type=%08lx): Unhandled type\n", error,type);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
SetLastError( error );
|
|
|
|
}
|
|
|
|
|
2005-04-20 15:18:42 +00:00
|
|
|
/******************************************************************************
|
|
|
|
* GetAltTabInfoA [USER32.@]
|
|
|
|
*/
|
2005-01-03 17:02:34 +00:00
|
|
|
BOOL WINAPI GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText)
|
|
|
|
{
|
|
|
|
FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2005-04-20 15:18:42 +00:00
|
|
|
/******************************************************************************
|
|
|
|
* GetAltTabInfoW [USER32.@]
|
|
|
|
*/
|
2005-01-03 17:02:34 +00:00
|
|
|
BOOL WINAPI GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText)
|
|
|
|
{
|
|
|
|
FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2000-08-04 04:21:02 +00:00
|
|
|
|
|
|
|
/******************************************************************************
|
2001-01-25 22:22:21 +00:00
|
|
|
* SetDebugErrorLevel [USER32.@]
|
2000-08-04 04:21:02 +00:00
|
|
|
* Sets the minimum error level for generating debugging events
|
|
|
|
*
|
|
|
|
* PARAMS
|
|
|
|
* dwLevel [I] Debugging error level
|
2005-11-09 10:33:40 +00:00
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Nothing.
|
2000-08-04 04:21:02 +00:00
|
|
|
*/
|
|
|
|
VOID WINAPI SetDebugErrorLevel( DWORD dwLevel )
|
|
|
|
{
|
|
|
|
FIXME("(%ld): stub\n", dwLevel);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************************************************
|
2001-01-25 22:22:21 +00:00
|
|
|
* GetProcessDefaultLayout [USER32.@]
|
2000-08-04 04:21:02 +00:00
|
|
|
*
|
|
|
|
* Gets the default layout for parentless windows.
|
|
|
|
* Right now, just returns 0 (left-to-right).
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Success: Nonzero
|
|
|
|
* Failure: Zero
|
|
|
|
*
|
|
|
|
* BUGS
|
|
|
|
* No RTL
|
|
|
|
*/
|
|
|
|
BOOL WINAPI GetProcessDefaultLayout( DWORD *pdwDefaultLayout )
|
|
|
|
{
|
|
|
|
if ( !pdwDefaultLayout ) {
|
|
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
FIXME( "( %p ): No BiDi\n", pdwDefaultLayout );
|
|
|
|
*pdwDefaultLayout = 0;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/******************************************************************************
|
2001-01-25 22:22:21 +00:00
|
|
|
* SetProcessDefaultLayout [USER32.@]
|
2000-08-04 04:21:02 +00:00
|
|
|
*
|
|
|
|
* Sets the default layout for parentless windows.
|
|
|
|
* Right now, only accepts 0 (left-to-right).
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Success: Nonzero
|
|
|
|
* Failure: Zero
|
|
|
|
*
|
|
|
|
* BUGS
|
|
|
|
* No RTL
|
|
|
|
*/
|
|
|
|
BOOL WINAPI SetProcessDefaultLayout( DWORD dwDefaultLayout )
|
|
|
|
{
|
|
|
|
if ( dwDefaultLayout == 0 )
|
|
|
|
return TRUE;
|
|
|
|
FIXME( "( %08lx ): No BiDi\n", dwDefaultLayout );
|
|
|
|
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-27 11:09:55 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* SetWindowStationUser (USER32.@)
|
|
|
|
*/
|
|
|
|
DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2)
|
|
|
|
{
|
|
|
|
FIXME("(0x%08lx,0x%08lx),stub!\n",x1,x2);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* RegisterLogonProcess (USER32.@)
|
|
|
|
*/
|
|
|
|
DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x)
|
|
|
|
{
|
|
|
|
FIXME("(%p,%d),stub!\n",hprocess,x);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* SetLogonNotifyWindow (USER32.@)
|
|
|
|
*/
|
|
|
|
DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
|
|
|
|
{
|
|
|
|
FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-09-28 10:17:13 +00:00
|
|
|
static const WCHAR primary_device_name[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0};
|
|
|
|
static const WCHAR primary_device_string[] = {'X','1','1',' ','W','i','n','d','o','w','i','n','g',' ',
|
|
|
|
'S','y','s','t','e','m',0};
|
|
|
|
|
2005-05-25 18:42:37 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* EnumDisplayDevicesA (USER32.@)
|
|
|
|
*/
|
2005-09-28 10:17:13 +00:00
|
|
|
BOOL WINAPI EnumDisplayDevicesA( LPCSTR lpDevice, DWORD i, LPDISPLAY_DEVICEA lpDispDev,
|
2005-05-25 18:42:37 +00:00
|
|
|
DWORD dwFlags )
|
|
|
|
{
|
2005-09-28 10:17:13 +00:00
|
|
|
UNICODE_STRING deviceW;
|
|
|
|
DISPLAY_DEVICEW ddW;
|
|
|
|
BOOL ret;
|
|
|
|
|
|
|
|
if(lpDevice)
|
|
|
|
RtlCreateUnicodeStringFromAsciiz(&deviceW, lpDevice);
|
|
|
|
else
|
|
|
|
deviceW.Buffer = NULL;
|
|
|
|
|
|
|
|
ddW.cb = sizeof(ddW);
|
|
|
|
ret = EnumDisplayDevicesW(deviceW.Buffer, i, &ddW, dwFlags);
|
|
|
|
RtlFreeUnicodeString(&deviceW);
|
|
|
|
|
|
|
|
if(!ret) return ret;
|
|
|
|
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, ddW.DeviceName, -1, lpDispDev->DeviceName, sizeof(lpDispDev->DeviceName), NULL, NULL);
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, ddW.DeviceString, -1, lpDispDev->DeviceString, sizeof(lpDispDev->DeviceString), NULL, NULL);
|
|
|
|
lpDispDev->StateFlags = ddW.StateFlags;
|
|
|
|
|
|
|
|
if(lpDispDev->cb >= offsetof(DISPLAY_DEVICEA, DeviceID) + sizeof(lpDispDev->DeviceID))
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, ddW.DeviceID, -1, lpDispDev->DeviceID, sizeof(lpDispDev->DeviceID), NULL, NULL);
|
|
|
|
if(lpDispDev->cb >= offsetof(DISPLAY_DEVICEA, DeviceKey) + sizeof(lpDispDev->DeviceKey))
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, ddW.DeviceKey, -1, lpDispDev->DeviceKey, sizeof(lpDispDev->DeviceKey), NULL, NULL);
|
|
|
|
|
2005-05-25 18:42:37 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* EnumDisplayDevicesW (USER32.@)
|
|
|
|
*/
|
2005-09-28 10:17:13 +00:00
|
|
|
BOOL WINAPI EnumDisplayDevicesW( LPCWSTR lpDevice, DWORD i, LPDISPLAY_DEVICEW lpDisplayDevice,
|
2005-05-25 18:42:37 +00:00
|
|
|
DWORD dwFlags )
|
|
|
|
{
|
2005-09-28 10:17:13 +00:00
|
|
|
FIXME("(%s,%ld,%p,0x%08lx), stub!\n",debugstr_w(lpDevice),i,lpDisplayDevice,dwFlags);
|
|
|
|
|
2005-05-25 18:42:37 +00:00
|
|
|
if (i)
|
|
|
|
return FALSE;
|
2005-09-28 10:17:13 +00:00
|
|
|
|
|
|
|
memcpy(lpDisplayDevice->DeviceName, primary_device_name, sizeof(primary_device_name));
|
|
|
|
memcpy(lpDisplayDevice->DeviceString, primary_device_string, sizeof(primary_device_string));
|
|
|
|
|
2005-05-25 18:42:37 +00:00
|
|
|
lpDisplayDevice->StateFlags =
|
|
|
|
DISPLAY_DEVICE_ATTACHED_TO_DESKTOP |
|
|
|
|
DISPLAY_DEVICE_PRIMARY_DEVICE |
|
|
|
|
DISPLAY_DEVICE_VGA_COMPATIBLE;
|
2005-09-28 10:17:13 +00:00
|
|
|
|
|
|
|
if(lpDisplayDevice->cb >= offsetof(DISPLAY_DEVICEW, DeviceID) + sizeof(lpDisplayDevice->DeviceID))
|
|
|
|
lpDisplayDevice->DeviceID[0] = 0;
|
|
|
|
if(lpDisplayDevice->cb >= offsetof(DISPLAY_DEVICEW, DeviceKey) + sizeof(lpDisplayDevice->DeviceKey))
|
|
|
|
lpDisplayDevice->DeviceKey[0] = 0;
|
|
|
|
|
2005-05-25 18:42:37 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2005-06-09 10:07:04 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* MonitorFromPoint (USER32.@)
|
|
|
|
*/
|
|
|
|
HMONITOR WINAPI MonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags)
|
|
|
|
{
|
|
|
|
if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
|
|
|
|
((ptScreenCoords.x >= 0) &&
|
|
|
|
(ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
|
|
|
|
(ptScreenCoords.y >= 0) &&
|
|
|
|
(ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))
|
|
|
|
{
|
|
|
|
return xPRIMARY_MONITOR;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* MonitorFromRect (USER32.@)
|
|
|
|
*/
|
|
|
|
HMONITOR WINAPI MonitorFromRect(LPRECT lprcScreenCoords, DWORD dwFlags)
|
|
|
|
{
|
|
|
|
if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
|
|
|
|
((lprcScreenCoords->right > 0) &&
|
|
|
|
(lprcScreenCoords->bottom > 0) &&
|
|
|
|
(lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
|
|
|
|
(lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))
|
|
|
|
{
|
|
|
|
return xPRIMARY_MONITOR;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* MonitorFromWindow (USER32.@)
|
|
|
|
*/
|
|
|
|
HMONITOR WINAPI MonitorFromWindow(HWND hWnd, DWORD dwFlags)
|
|
|
|
{
|
|
|
|
WINDOWPLACEMENT wp;
|
|
|
|
|
|
|
|
if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
|
|
|
|
return xPRIMARY_MONITOR;
|
|
|
|
|
|
|
|
if (IsIconic(hWnd) ?
|
|
|
|
GetWindowPlacement(hWnd, &wp) :
|
|
|
|
GetWindowRect(hWnd, &wp.rcNormalPosition)) {
|
|
|
|
|
|
|
|
return MonitorFromRect(&wp.rcNormalPosition, dwFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* GetMonitorInfoA (USER32.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
|
|
|
|
{
|
2005-09-28 10:17:13 +00:00
|
|
|
MONITORINFOEXW miW;
|
|
|
|
MONITORINFOEXA *miA = (MONITORINFOEXA*)lpMonitorInfo;
|
|
|
|
BOOL ret;
|
2005-06-09 10:07:04 +00:00
|
|
|
|
2005-09-28 10:17:13 +00:00
|
|
|
miW.cbSize = sizeof(miW);
|
2005-06-09 10:07:04 +00:00
|
|
|
|
2005-09-28 10:17:13 +00:00
|
|
|
ret = GetMonitorInfoW(hMonitor, (MONITORINFO*)&miW);
|
|
|
|
if(!ret) return ret;
|
2005-06-09 10:07:04 +00:00
|
|
|
|
2005-09-28 10:17:13 +00:00
|
|
|
miA->rcMonitor = miW.rcMonitor;
|
|
|
|
miA->rcWork = miW.rcWork;
|
|
|
|
miA->dwFlags = miW.dwFlags;
|
|
|
|
if(miA->cbSize >= offsetof(MONITORINFOEXA, szDevice) + sizeof(miA->szDevice))
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, miW.szDevice, -1, miA->szDevice, sizeof(miA->szDevice), NULL, NULL);
|
|
|
|
return ret;
|
2005-06-09 10:07:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* GetMonitorInfoW (USER32.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI GetMonitorInfoW(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
|
|
|
|
{
|
|
|
|
RECT rcWork;
|
|
|
|
|
|
|
|
if ((hMonitor == xPRIMARY_MONITOR) &&
|
|
|
|
lpMonitorInfo &&
|
|
|
|
(lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
|
|
|
|
SystemParametersInfoW(SPI_GETWORKAREA, 0, &rcWork, 0))
|
|
|
|
{
|
|
|
|
SetRect( &lpMonitorInfo->rcMonitor, 0, 0,
|
|
|
|
GetSystemMetrics(SM_CXSCREEN),
|
|
|
|
GetSystemMetrics(SM_CYSCREEN) );
|
|
|
|
lpMonitorInfo->rcWork = rcWork;
|
|
|
|
lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;
|
|
|
|
|
|
|
|
if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEXW))
|
2005-09-28 10:17:13 +00:00
|
|
|
strcpyW(((MONITORINFOEXW*)lpMonitorInfo)->szDevice, primary_device_name);
|
2005-06-09 10:07:04 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* EnumDisplayMonitors (USER32.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI EnumDisplayMonitors(
|
|
|
|
HDC hdcOptionalForPainting,
|
|
|
|
LPRECT lprcEnumMonitorsThatIntersect,
|
|
|
|
MONITORENUMPROC lpfnEnumProc,
|
|
|
|
LPARAM dwData)
|
|
|
|
{
|
|
|
|
RECT rcLimit;
|
|
|
|
SetRect( &rcLimit, 0, 0, GetSystemMetrics(SM_CXSCREEN),
|
|
|
|
GetSystemMetrics(SM_CYSCREEN) );
|
|
|
|
|
|
|
|
if (!lpfnEnumProc)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (hdcOptionalForPainting)
|
|
|
|
{
|
|
|
|
RECT rcClip;
|
|
|
|
POINT ptOrg;
|
|
|
|
|
|
|
|
switch (GetClipBox(hdcOptionalForPainting, &rcClip))
|
|
|
|
{
|
|
|
|
default:
|
|
|
|
if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
|
|
|
|
if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
|
|
|
|
(!lprcEnumMonitorsThatIntersect ||
|
|
|
|
IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through */
|
|
|
|
case NULLREGION:
|
|
|
|
return TRUE;
|
|
|
|
case ERROR:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ( lprcEnumMonitorsThatIntersect &&
|
|
|
|
!IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return lpfnEnumProc(
|
|
|
|
xPRIMARY_MONITOR,
|
|
|
|
hdcOptionalForPainting,
|
|
|
|
&rcLimit,
|
|
|
|
dwData);
|
|
|
|
}
|
|
|
|
|
2005-04-27 11:09:55 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* RegisterSystemThread (USER32.@)
|
|
|
|
*/
|
|
|
|
void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
|
|
|
|
{
|
|
|
|
FIXME("(%08lx, %08lx)\n", flags, reserved);
|
|
|
|
}
|
2000-08-04 04:21:02 +00:00
|
|
|
|
|
|
|
/***********************************************************************
|
2001-01-25 22:22:21 +00:00
|
|
|
* RegisterShellHookWindow [USER32.@]
|
2000-08-04 04:21:02 +00:00
|
|
|
*/
|
2003-01-13 20:36:39 +00:00
|
|
|
BOOL WINAPI RegisterShellHookWindow ( HWND hWnd )
|
2000-08-04 04:21:02 +00:00
|
|
|
{
|
2003-01-13 20:36:39 +00:00
|
|
|
FIXME("(%p): stub\n", hWnd);
|
2000-08-04 04:21:02 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
2001-01-25 22:22:21 +00:00
|
|
|
* DeregisterShellHookWindow [USER32.@]
|
2000-08-04 04:21:02 +00:00
|
|
|
*/
|
|
|
|
HRESULT WINAPI DeregisterShellHookWindow ( DWORD u )
|
|
|
|
{
|
|
|
|
FIXME("0x%08lx stub\n",u);
|
|
|
|
return 0;
|
2002-05-31 23:06:46 +00:00
|
|
|
|
2000-08-04 04:21:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
2001-01-25 22:22:21 +00:00
|
|
|
* RegisterTasklist [USER32.@]
|
2000-08-04 04:21:02 +00:00
|
|
|
*/
|
2000-11-25 21:43:04 +00:00
|
|
|
DWORD WINAPI RegisterTasklist (DWORD x)
|
2000-08-04 04:21:02 +00:00
|
|
|
{
|
|
|
|
FIXME("0x%08lx\n",x);
|
|
|
|
return TRUE;
|
|
|
|
}
|
2000-08-06 02:42:46 +00:00
|
|
|
|
2002-07-28 23:48:27 +00:00
|
|
|
|
2005-04-27 11:09:55 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* RegisterDeviceNotificationA (USER32.@)
|
|
|
|
*
|
|
|
|
* See RegisterDeviceNotificationW.
|
|
|
|
*/
|
|
|
|
HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE hnd, LPVOID notifyfilter, DWORD flags)
|
|
|
|
{
|
|
|
|
FIXME("(hwnd=%p, filter=%p,flags=0x%08lx), STUB!\n", hnd,notifyfilter,flags );
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* RegisterDeviceNotificationW (USER32.@)
|
|
|
|
*
|
|
|
|
* Registers a window with the system so that it will receive
|
|
|
|
* notifications about a device.
|
|
|
|
*
|
|
|
|
* PARAMS
|
|
|
|
* hRecepient [I] Window or service status handle that
|
|
|
|
* will receive notifications.
|
|
|
|
* pNotificationFilter [I] DEV_BROADCAST_HDR followed by some
|
|
|
|
* type-specific data.
|
|
|
|
* dwFlags [I] See notes
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
*
|
|
|
|
* A handle to the device notification.
|
|
|
|
*
|
|
|
|
* NOTES
|
|
|
|
*
|
|
|
|
* The dwFlags parameter can be one of two values:
|
|
|
|
*| DEVICE_NOTIFY_WINDOW_HANDLE - hRecepient is a window handle
|
|
|
|
*| DEVICE_NOTIFY_SERVICE_HANDLE - hRecepient is a service status handle
|
|
|
|
*/
|
|
|
|
HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE hRecepient, LPVOID pNotificationFilter, DWORD dwFlags)
|
|
|
|
{
|
|
|
|
FIXME("(hwnd=%p, filter=%p,flags=0x%08lx), STUB!\n", hRecepient,pNotificationFilter,dwFlags );
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-03 10:17:05 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* UnregisterDeviceNotification (USER32.@)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
BOOL WINAPI UnregisterDeviceNotification(HDEVNOTIFY hnd)
|
|
|
|
{
|
|
|
|
FIXME("(handle=%p), STUB!\n", hnd);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2002-07-28 23:48:27 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* GetAppCompatFlags (USER32.@)
|
|
|
|
*/
|
|
|
|
DWORD WINAPI GetAppCompatFlags( HTASK hTask )
|
|
|
|
{
|
|
|
|
FIXME("stub\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-01-13 20:36:39 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* AlignRects (USER32.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
|
|
|
|
{
|
|
|
|
FIXME("(%p, %ld, %ld, %ld): stub\n", rect, b, c, d);
|
|
|
|
if (rect)
|
|
|
|
FIXME("rect: [[%ld, %ld], [%ld, %ld]]\n", rect->left, rect->top, rect->right, rect->bottom);
|
|
|
|
/* Calls OffsetRect */
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-27 11:09:55 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* LoadLocalFonts (USER32.@)
|
|
|
|
*/
|
|
|
|
VOID WINAPI LoadLocalFonts(VOID)
|
|
|
|
{
|
|
|
|
/* are loaded. */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-08-06 02:42:46 +00:00
|
|
|
/***********************************************************************
|
2001-07-02 19:59:40 +00:00
|
|
|
* USER_489 (USER.489)
|
2000-08-06 02:42:46 +00:00
|
|
|
*/
|
|
|
|
LONG WINAPI stub_USER_489(void) { FIXME("stub\n"); return 0; }
|
|
|
|
|
|
|
|
/***********************************************************************
|
2001-07-02 19:59:40 +00:00
|
|
|
* USER_490 (USER.490)
|
2000-08-06 02:42:46 +00:00
|
|
|
*/
|
|
|
|
LONG WINAPI stub_USER_490(void) { FIXME("stub\n"); return 0; }
|
|
|
|
|
|
|
|
/***********************************************************************
|
2001-07-02 19:59:40 +00:00
|
|
|
* USER_492 (USER.492)
|
2000-08-06 02:42:46 +00:00
|
|
|
*/
|
|
|
|
LONG WINAPI stub_USER_492(void) { FIXME("stub\n"); return 0; }
|
|
|
|
|
|
|
|
/***********************************************************************
|
2001-07-02 19:59:40 +00:00
|
|
|
* USER_496 (USER.496)
|
2000-08-06 02:42:46 +00:00
|
|
|
*/
|
|
|
|
LONG WINAPI stub_USER_496(void) { FIXME("stub\n"); return 0; }
|
2004-04-01 02:12:41 +00:00
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* User32InitializeImmEntryTable
|
|
|
|
*/
|
2005-01-07 17:15:30 +00:00
|
|
|
BOOL WINAPI User32InitializeImmEntryTable(LPVOID ptr)
|
|
|
|
{
|
|
|
|
FIXME("(%p): stub\n", ptr);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
* WINNLSGetIMEHotkey [USER32.@]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
UINT WINAPI WINNLSGetIMEHotkey(HWND hUnknown1)
|
|
|
|
{
|
|
|
|
FIXME("hUnknown1 %p: stub!\n", hUnknown1);
|
|
|
|
return 0; /* unknown */
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
* WINNLSEnableIME [USER32.@]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
BOOL WINAPI WINNLSEnableIME(HWND hUnknown1, BOOL bUnknown2)
|
|
|
|
{
|
|
|
|
FIXME("hUnknown1 %p bUnknown2 %d: stub!\n", hUnknown1, bUnknown2);
|
|
|
|
return TRUE; /* success (?) */
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
* WINNLSGetEnableStatus [USER32.@]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
BOOL WINAPI WINNLSGetEnableStatus(HWND hUnknown1)
|
|
|
|
{
|
|
|
|
FIXME("hUnknown1 %p: stub!\n", hUnknown1);
|
|
|
|
return TRUE; /* success (?) */
|
2004-04-01 02:12:41 +00:00
|
|
|
}
|
2005-01-20 19:57:58 +00:00
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
* SendIMEMessageExA [USER32.@]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
LRESULT WINAPI SendIMEMessageExA(HWND p1, LPARAM p2)
|
|
|
|
{
|
|
|
|
FIXME("(%p,%lx): stub\n", p1, p2);
|
|
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
|
|
* SendIMEMessageExW [USER32.@]
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
LRESULT WINAPI SendIMEMessageExW(HWND p1, LPARAM p2)
|
|
|
|
{
|
|
|
|
FIXME("(%p,%lx): stub\n", p1, p2);
|
|
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
|
|
return 0;
|
|
|
|
}
|