2005-01-06 13:58:04 +00:00
|
|
|
/* $Id$
|
2003-05-26 18:52:37 +00:00
|
|
|
*
|
|
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
|
|
* PROJECT: ReactOS kernel
|
|
|
|
* PURPOSE: Misc User funcs
|
|
|
|
* FILE: subsys/win32k/ntuser/misc.c
|
|
|
|
* PROGRAMER: Ge van Geldorp (ge@gse.nl)
|
|
|
|
* REVISION HISTORY:
|
2005-11-25 13:01:44 +00:00
|
|
|
* 2003/05/22 Created
|
2003-05-26 18:52:37 +00:00
|
|
|
*/
|
2004-05-10 17:07:20 +00:00
|
|
|
|
|
|
|
#include <w32k.h>
|
2003-05-26 18:52:37 +00:00
|
|
|
|
2005-12-30 22:02:59 +00:00
|
|
|
//#define NDEBUG
|
|
|
|
#undef NDEBUG
|
2003-05-26 18:52:37 +00:00
|
|
|
#include <debug.h>
|
|
|
|
|
2004-05-01 16:43:15 +00:00
|
|
|
/* registered Logon process */
|
|
|
|
PW32PROCESS LogonProcess = NULL;
|
|
|
|
|
2005-03-17 13:07:28 +00:00
|
|
|
VOID W32kRegisterPrimitiveMessageQueue(VOID)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
extern PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue;
|
|
|
|
if( !pmPrimitiveMessageQueue )
|
|
|
|
{
|
|
|
|
PW32THREAD pThread;
|
|
|
|
pThread = PsGetWin32Thread();
|
|
|
|
if( pThread && pThread->MessageQueue )
|
|
|
|
{
|
|
|
|
pmPrimitiveMessageQueue = pThread->MessageQueue;
|
|
|
|
IntReferenceMessageQueue(pmPrimitiveMessageQueue);
|
|
|
|
DPRINT( "Installed primitive input queue.\n" );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DPRINT1( "Alert! Someone is trying to steal the primitive queue.\n" );
|
|
|
|
}
|
2003-10-09 06:13:05 +00:00
|
|
|
}
|
|
|
|
|
2005-03-17 13:07:28 +00:00
|
|
|
VOID W32kUnregisterPrimitiveMessageQueue(VOID)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
extern PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue;
|
|
|
|
IntDereferenceMessageQueue(pmPrimitiveMessageQueue);
|
|
|
|
pmPrimitiveMessageQueue = NULL;
|
2005-03-17 13:07:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PUSER_MESSAGE_QUEUE W32kGetPrimitiveMessageQueue()
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
extern PUSER_MESSAGE_QUEUE pmPrimitiveMessageQueue;
|
|
|
|
return pmPrimitiveMessageQueue;
|
2003-10-09 06:13:05 +00:00
|
|
|
}
|
2003-05-26 18:52:37 +00:00
|
|
|
|
2004-05-01 16:43:15 +00:00
|
|
|
BOOL FASTCALL
|
2005-09-05 21:19:23 +00:00
|
|
|
co_IntRegisterLogonProcess(HANDLE ProcessId, BOOL Register)
|
2004-05-01 16:43:15 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
PEPROCESS Process;
|
|
|
|
NTSTATUS Status;
|
|
|
|
CSR_API_MESSAGE Request;
|
|
|
|
|
|
|
|
Status = PsLookupProcessByProcessId(ProcessId,
|
|
|
|
&Process);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastWin32Error(RtlNtStatusToDosError(Status));
|
2004-07-08 14:36:18 +00:00
|
|
|
return FALSE;
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Register)
|
|
|
|
{
|
|
|
|
/* Register the logon process */
|
|
|
|
if (LogonProcess != NULL)
|
|
|
|
{
|
|
|
|
ObDereferenceObject(Process);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2004-07-08 14:36:18 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
LogonProcess = (PW32PROCESS)Process->Win32Process;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Deregister the logon process */
|
|
|
|
if (LogonProcess != (PW32PROCESS)Process->Win32Process)
|
|
|
|
{
|
|
|
|
ObDereferenceObject(Process);
|
|
|
|
return FALSE;
|
|
|
|
}
|
2004-07-08 14:36:18 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
LogonProcess = NULL;
|
|
|
|
}
|
2004-07-08 14:36:18 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ObDereferenceObject(Process);
|
2004-07-12 20:09:35 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Request.Type = MAKE_CSR_API(REGISTER_LOGON_PROCESS, CSR_GUI);
|
|
|
|
Request.Data.RegisterLogonProcessRequest.ProcessId = ProcessId;
|
|
|
|
Request.Data.RegisterLogonProcessRequest.Register = Register;
|
2004-07-12 20:09:35 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = co_CsrNotify(&Request);
|
|
|
|
if (! NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
DPRINT1("Failed to register logon process with CSRSS\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return TRUE;
|
2004-05-01 16:43:15 +00:00
|
|
|
}
|
|
|
|
|
2003-08-28 18:04:59 +00:00
|
|
|
/*
|
2003-09-12 12:54:26 +00:00
|
|
|
* @unimplemented
|
2003-08-28 18:04:59 +00:00
|
|
|
*/
|
2003-08-06 11:32:17 +00:00
|
|
|
DWORD
|
|
|
|
STDCALL
|
2003-10-09 06:13:05 +00:00
|
|
|
NtUserCallNoParam(DWORD Routine)
|
2003-08-06 11:32:17 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Result = 0;
|
|
|
|
DECLARE_RETURN(DWORD);
|
|
|
|
|
|
|
|
DPRINT("Enter NtUserCallNoParam\n");
|
|
|
|
UserEnterExclusive();
|
|
|
|
|
|
|
|
switch(Routine)
|
|
|
|
{
|
|
|
|
case NOPARAM_ROUTINE_REGISTER_PRIMITIVE:
|
|
|
|
W32kRegisterPrimitiveMessageQueue();
|
|
|
|
Result = (DWORD)TRUE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_DESTROY_CARET:
|
|
|
|
Result = (DWORD)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_INIT_MESSAGE_PUMP:
|
|
|
|
Result = (DWORD)IntInitMessagePumpHook();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_UNINIT_MESSAGE_PUMP:
|
|
|
|
Result = (DWORD)IntUninitMessagePumpHook();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_GETMESSAGEEXTRAINFO:
|
|
|
|
Result = (DWORD)MsqGetMessageExtraInfo();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_ANYPOPUP:
|
|
|
|
Result = (DWORD)IntAnyPopup();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_CSRSS_INITIALIZED:
|
|
|
|
Result = (DWORD)CsrInit();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case NOPARAM_ROUTINE_MSQCLEARWAKEMASK:
|
|
|
|
RETURN( (DWORD)IntMsqClearWakeMask());
|
|
|
|
|
|
|
|
default:
|
|
|
|
DPRINT1("Calling invalid routine number 0x%x in NtUserCallNoParam\n", Routine);
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
RETURN(Result);
|
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserCallNoParam, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-10-16 22:07:37 +00:00
|
|
|
}
|
2003-08-06 11:32:17 +00:00
|
|
|
|
2005-12-30 22:02:59 +00:00
|
|
|
|
2003-08-28 18:04:59 +00:00
|
|
|
/*
|
|
|
|
* @implemented
|
|
|
|
*/
|
2003-08-06 11:32:17 +00:00
|
|
|
DWORD
|
|
|
|
STDCALL
|
|
|
|
NtUserCallOneParam(
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Param,
|
|
|
|
DWORD Routine)
|
2003-08-06 11:32:17 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
DECLARE_RETURN(DWORD);
|
2006-01-08 23:26:03 +00:00
|
|
|
PDC dc;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Enter NtUserCallOneParam\n");
|
2005-12-30 22:02:59 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (Routine == ONEPARAM_ROUTINE_SHOWCURSOR)
|
|
|
|
{
|
|
|
|
PWINSTATION_OBJECT WinSta = PsGetWin32Thread()->Desktop->WindowStation;
|
|
|
|
PSYSTEM_CURSORINFO CurInfo;
|
|
|
|
|
|
|
|
HDC Screen;
|
|
|
|
HBITMAP dcbmp;
|
|
|
|
SURFOBJ *SurfObj;
|
|
|
|
BITMAPOBJ *BitmapObj;
|
|
|
|
GDIDEVICE *ppdev;
|
|
|
|
GDIPOINTER *pgp;
|
2006-01-01 01:09:08 +00:00
|
|
|
int showpointer=0;
|
2005-12-30 22:02:59 +00:00
|
|
|
|
|
|
|
if(!(Screen = IntGetScreenDC()))
|
|
|
|
{
|
2006-01-01 01:09:08 +00:00
|
|
|
return showpointer; /* No mouse */
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
2006-01-08 23:26:03 +00:00
|
|
|
dc = DC_LockDc(Screen);
|
2005-12-30 22:02:59 +00:00
|
|
|
|
|
|
|
if (!dc)
|
|
|
|
{
|
2006-01-01 01:09:08 +00:00
|
|
|
return showpointer; /* No mouse */
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dcbmp = dc->w.hBitmap;
|
|
|
|
DC_UnlockDc(dc);
|
|
|
|
|
|
|
|
BitmapObj = BITMAPOBJ_LockBitmap(dcbmp);
|
|
|
|
if ( !BitmapObj )
|
|
|
|
{
|
|
|
|
BITMAPOBJ_UnlockBitmap(BitmapObj);
|
2006-01-01 01:09:08 +00:00
|
|
|
return showpointer; /* No Mouse */
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SurfObj = &BitmapObj->SurfObj;
|
|
|
|
if (SurfObj == NULL)
|
|
|
|
{
|
|
|
|
BITMAPOBJ_UnlockBitmap(BitmapObj);
|
2006-01-01 01:09:08 +00:00
|
|
|
return showpointer; /* No mouse */
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ppdev = GDIDEV(SurfObj);
|
|
|
|
|
|
|
|
if(ppdev == NULL)
|
|
|
|
{
|
|
|
|
BITMAPOBJ_UnlockBitmap(BitmapObj);
|
2006-01-01 01:09:08 +00:00
|
|
|
return showpointer; /* No mouse */
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pgp = &ppdev->Pointer;
|
|
|
|
|
|
|
|
CurInfo = IntGetSysCursorInfo(WinSta);
|
|
|
|
|
|
|
|
if (Param == FALSE)
|
|
|
|
{
|
2006-01-01 01:09:08 +00:00
|
|
|
pgp->ShowPointer--;
|
|
|
|
showpointer = pgp->ShowPointer;
|
|
|
|
|
|
|
|
if (showpointer >= 0)
|
|
|
|
{
|
2005-12-30 23:56:27 +00:00
|
|
|
//ppdev->SafetyRemoveCount = 1;
|
|
|
|
//ppdev->SafetyRemoveLevel = 1;
|
2005-12-30 22:02:59 +00:00
|
|
|
EngMovePointer(SurfObj,-1,-1,NULL);
|
|
|
|
CurInfo->ShowingCursor = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-01-01 01:09:08 +00:00
|
|
|
pgp->ShowPointer++;
|
|
|
|
showpointer = pgp->ShowPointer;
|
|
|
|
|
2005-12-30 22:02:59 +00:00
|
|
|
/* Show Cursor */
|
2006-01-01 01:09:08 +00:00
|
|
|
if (showpointer < 0)
|
|
|
|
{
|
|
|
|
//ppdev->SafetyRemoveCount = 0;
|
|
|
|
//ppdev->SafetyRemoveLevel = 0;
|
|
|
|
EngMovePointer(SurfObj,-1,-1,NULL);
|
|
|
|
CurInfo->ShowingCursor = CURSOR_SHOWING;
|
|
|
|
}
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BITMAPOBJ_UnlockBitmap(BitmapObj);
|
2006-01-01 01:09:08 +00:00
|
|
|
return showpointer;
|
2005-12-30 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
UserEnterExclusive();
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
switch(Routine)
|
2005-12-30 22:02:59 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_GETMENU:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Result;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
if(!(Window = UserGetWindowObject((HWND)Param)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Result = (DWORD)Window->IDMenu;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Result);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_ISWINDOWUNICODE:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Result;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Window = UserGetWindowObject((HWND)Param);
|
|
|
|
if(!Window)
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-09-11 14:48:32 +00:00
|
|
|
Result = Window->Unicode;
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Result);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_WINDOWFROMDC:
|
|
|
|
RETURN( (DWORD)IntWindowFromDC((HDC)Param));
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_GETWNDCONTEXTHLPID:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Result;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Window = UserGetWindowObject((HWND)Param);
|
|
|
|
if(!Window)
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Result = Window->ContextHelpId;
|
2003-08-28 14:22:05 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Result);
|
|
|
|
}
|
2003-08-28 14:22:05 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_SWAPMOUSEBUTTON:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINSTATION_OBJECT WinSta;
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
DWORD Result;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
|
|
|
|
KernelMode,
|
|
|
|
0,
|
2005-09-11 14:48:32 +00:00
|
|
|
&WinSta);
|
2005-09-07 21:25:42 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
RETURN( (DWORD)FALSE);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* FIXME
|
|
|
|
Result = (DWORD)IntSwapMouseButton(WinStaObject, (BOOL)Param); */
|
|
|
|
Result = 0;
|
2003-08-06 11:32:17 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
ObDereferenceObject(WinSta);
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Result);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_SWITCHCARETSHOWING:
|
|
|
|
RETURN( (DWORD)IntSwitchCaretShowing((PVOID)Param));
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_SETCARETBLINKTIME:
|
|
|
|
RETURN( (DWORD)IntSetCaretBlinkTime((UINT)Param));
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_ENUMCLIPBOARDFORMATS:
|
|
|
|
RETURN( (DWORD)IntEnumClipboardFormats((UINT)Param));
|
|
|
|
|
|
|
|
case ONEPARAM_ROUTINE_GETWINDOWINSTANCE:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Result;
|
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
if(!(Window = UserGetWindowObject((HWND)Param)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Result = (DWORD)Window->Instance;
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Result);
|
|
|
|
}
|
|
|
|
|
|
|
|
case ONEPARAM_ROUTINE_SETMESSAGEEXTRAINFO:
|
|
|
|
RETURN( (DWORD)MsqSetMessageExtraInfo((LPARAM)Param));
|
|
|
|
|
|
|
|
case ONEPARAM_ROUTINE_GETCURSORPOSITION:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINSTATION_OBJECT WinSta;
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
POINT Pos;
|
|
|
|
|
|
|
|
if(!Param)
|
|
|
|
RETURN( (DWORD)FALSE);
|
|
|
|
Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
|
|
|
|
KernelMode,
|
|
|
|
0,
|
2005-09-11 14:48:32 +00:00
|
|
|
&WinSta);
|
2005-09-07 21:25:42 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
RETURN( (DWORD)FALSE);
|
|
|
|
|
|
|
|
/* FIXME - check if process has WINSTA_READATTRIBUTES */
|
2005-09-11 14:48:32 +00:00
|
|
|
IntGetCursorLocation(WinSta, &Pos);
|
2005-09-07 21:25:42 +00:00
|
|
|
|
|
|
|
Status = MmCopyToCaller((PPOINT)Param, &Pos, sizeof(POINT));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
ObDereferenceObject(WinSta);
|
2005-09-07 21:25:42 +00:00
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
ObDereferenceObject(WinSta);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( (DWORD)TRUE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_ISWINDOWINDESTROY:
|
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Result;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
if(!(Window = UserGetWindowObject((HWND)Param)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Result = (DWORD)IntIsWindowInDestroy(Window);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Result);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case ONEPARAM_ROUTINE_ENABLEPROCWNDGHSTING:
|
|
|
|
{
|
|
|
|
BOOL Enable;
|
|
|
|
PW32PROCESS Process = PsGetWin32Process();
|
|
|
|
|
|
|
|
if(Process != NULL)
|
|
|
|
{
|
|
|
|
Enable = (BOOL)(Param != 0);
|
|
|
|
|
|
|
|
if(Enable)
|
|
|
|
{
|
|
|
|
Process->Flags &= ~W32PF_NOWINDOWGHOSTING;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Process->Flags |= W32PF_NOWINDOWGHOSTING;
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN( TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
case ONEPARAM_ROUTINE_MSQSETWAKEMASK:
|
|
|
|
RETURN( (DWORD)IntMsqSetWakeMask(Param));
|
|
|
|
|
|
|
|
case ONEPARAM_ROUTINE_GETKEYBOARDTYPE:
|
|
|
|
RETURN( UserGetKeyboardType(Param));
|
|
|
|
|
|
|
|
case ONEPARAM_ROUTINE_GETKEYBOARDLAYOUT:
|
|
|
|
RETURN( (DWORD)UserGetKeyboardLayout(Param));
|
|
|
|
}
|
|
|
|
DPRINT1("Calling invalid routine number 0x%x in NtUserCallOneParam(), Param=0x%x\n",
|
|
|
|
Routine, Param);
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
|
|
|
RETURN( 0);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserCallOneParam, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-08-06 11:32:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-08-28 18:04:59 +00:00
|
|
|
/*
|
|
|
|
* @implemented
|
|
|
|
*/
|
2003-05-26 18:52:37 +00:00
|
|
|
DWORD
|
|
|
|
STDCALL
|
|
|
|
NtUserCallTwoParam(
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Param1,
|
|
|
|
DWORD Param2,
|
|
|
|
DWORD Routine)
|
2003-05-26 18:52:37 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DECLARE_RETURN(DWORD);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Enter NtUserCallTwoParam\n");
|
|
|
|
UserEnterExclusive();
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
switch(Routine)
|
|
|
|
{
|
|
|
|
case TWOPARAM_ROUTINE_SETDCPENCOLOR:
|
|
|
|
{
|
|
|
|
RETURN( (DWORD)IntSetDCColor((HDC)Param1, OBJ_PEN, (COLORREF)Param2));
|
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_SETDCBRUSHCOLOR:
|
|
|
|
{
|
|
|
|
RETURN( (DWORD)IntSetDCColor((HDC)Param1, OBJ_BRUSH, (COLORREF)Param2));
|
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_GETDCCOLOR:
|
|
|
|
{
|
|
|
|
RETURN( (DWORD)IntGetDCColor((HDC)Param1, (ULONG)Param2));
|
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_GETWINDOWRGNBOX:
|
|
|
|
{
|
|
|
|
DWORD Ret;
|
|
|
|
RECT rcRect;
|
2005-09-08 16:18:51 +00:00
|
|
|
PWINDOW_OBJECT Window = UserGetWindowObject((HWND)Param1);
|
|
|
|
if (!Window) RETURN(ERROR);
|
|
|
|
|
|
|
|
Ret = (DWORD)IntGetWindowRgnBox(Window, &rcRect);
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyToCaller((PVOID)Param2, &rcRect, sizeof(RECT));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( ERROR);
|
|
|
|
}
|
|
|
|
RETURN( Ret);
|
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_GETWINDOWRGN:
|
|
|
|
{
|
2005-09-08 16:18:51 +00:00
|
|
|
PWINDOW_OBJECT Window = UserGetWindowObject((HWND)Param1);
|
|
|
|
if (!Window) RETURN(ERROR);
|
|
|
|
|
|
|
|
RETURN( (DWORD)IntGetWindowRgn(Window, (HRGN)Param2));
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_SETMENUBARHEIGHT:
|
|
|
|
{
|
|
|
|
DWORD Ret;
|
|
|
|
PMENU_OBJECT MenuObject = IntGetMenuObject((HMENU)Param1);
|
|
|
|
if(!MenuObject)
|
|
|
|
RETURN( 0);
|
|
|
|
|
|
|
|
if(Param2 > 0)
|
|
|
|
{
|
|
|
|
Ret = (MenuObject->MenuInfo.Height == (int)Param2);
|
|
|
|
MenuObject->MenuInfo.Height = (int)Param2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Ret = (DWORD)MenuObject->MenuInfo.Height;
|
|
|
|
IntReleaseMenuObject(MenuObject);
|
|
|
|
RETURN( Ret);
|
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_SETMENUITEMRECT:
|
|
|
|
{
|
|
|
|
BOOL Ret;
|
|
|
|
SETMENUITEMRECT smir;
|
|
|
|
PMENU_OBJECT MenuObject = IntGetMenuObject((HMENU)Param1);
|
|
|
|
if(!MenuObject)
|
|
|
|
RETURN( 0);
|
|
|
|
|
|
|
|
if(!NT_SUCCESS(MmCopyFromCaller(&smir, (PVOID)Param2, sizeof(SETMENUITEMRECT))))
|
|
|
|
{
|
|
|
|
IntReleaseMenuObject(MenuObject);
|
|
|
|
RETURN( 0);
|
|
|
|
}
|
2003-08-06 11:32:17 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Ret = IntSetMenuItemRect(MenuObject, smir.uItem, smir.fByPosition, &smir.rcRect);
|
2003-08-06 11:32:17 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
IntReleaseMenuObject(MenuObject);
|
|
|
|
RETURN( (DWORD)Ret);
|
|
|
|
}
|
2003-08-06 11:32:17 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_SETGUITHRDHANDLE:
|
|
|
|
{
|
2005-11-08 08:56:41 +00:00
|
|
|
PUSER_MESSAGE_QUEUE MsgQueue = ((PW32THREAD)PsGetCurrentThread()->Tcb.Win32Thread)->MessageQueue;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ASSERT(MsgQueue);
|
|
|
|
RETURN( (DWORD)MsqSetStateWindow(MsgQueue, (ULONG)Param1, (HWND)Param2));
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_ENABLEWINDOW:
|
|
|
|
UNIMPLEMENTED
|
|
|
|
RETURN( 0);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_UNKNOWN:
|
|
|
|
UNIMPLEMENTED
|
|
|
|
RETURN( 0);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_SHOWOWNEDPOPUPS:
|
2005-09-08 16:18:51 +00:00
|
|
|
{
|
|
|
|
PWINDOW_OBJECT Window = UserGetWindowObject((HWND)Param1);
|
|
|
|
if (!Window) RETURN(0);
|
|
|
|
|
|
|
|
RETURN( (DWORD)IntShowOwnedPopups(Window, (BOOL) Param2));
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_ROS_SHOWWINDOW:
|
|
|
|
{
|
|
|
|
#define WIN_NEEDS_SHOW_OWNEDPOPUP (0x00000040)
|
2005-09-11 14:48:32 +00:00
|
|
|
PWINDOW_OBJECT Window;
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT1("ROS_SHOWWINDOW\n");
|
2005-09-11 14:48:32 +00:00
|
|
|
|
|
|
|
if (!(Window = UserGetWindowObject((HWND)Param1)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-09-11 14:48:32 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if (Param2)
|
|
|
|
{
|
|
|
|
if (!(Window->Flags & WIN_NEEDS_SHOW_OWNEDPOPUP))
|
|
|
|
{
|
|
|
|
RETURN( TRUE);
|
|
|
|
}
|
|
|
|
Window->Flags &= ~WIN_NEEDS_SHOW_OWNEDPOPUP;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Window->Flags |= WIN_NEEDS_SHOW_OWNEDPOPUP;
|
2005-09-11 14:48:32 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT1("ROS_SHOWWINDOW ---> 0x%x\n",Window->Flags);
|
|
|
|
RETURN( TRUE);
|
|
|
|
}
|
|
|
|
case TWOPARAM_ROUTINE_SWITCHTOTHISWINDOW:
|
|
|
|
UNIMPLEMENTED
|
|
|
|
RETURN( 0);
|
|
|
|
|
|
|
|
case TWOPARAM_ROUTINE_SETWNDCONTEXTHLPID:
|
2005-09-11 14:48:32 +00:00
|
|
|
|
|
|
|
if(!(Window = UserGetWindowObject((HWND)Param1)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( (DWORD)FALSE);
|
|
|
|
}
|
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
Window->ContextHelpId = Param2;
|
2005-09-07 21:25:42 +00:00
|
|
|
|
|
|
|
RETURN( (DWORD)TRUE);
|
|
|
|
|
|
|
|
case TWOPARAM_ROUTINE_SETCARETPOS:
|
|
|
|
RETURN( (DWORD)co_IntSetCaretPos((int)Param1, (int)Param2));
|
|
|
|
|
|
|
|
case TWOPARAM_ROUTINE_GETWINDOWINFO:
|
|
|
|
{
|
|
|
|
WINDOWINFO wi;
|
|
|
|
DWORD Ret;
|
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
if(!(Window = UserGetWindowObject((HWND)Param1)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2004-05-12 15:28:01 +00:00
|
|
|
#if 0
|
2005-09-07 21:25:42 +00:00
|
|
|
/*
|
|
|
|
* According to WINE, Windows' doesn't check the cbSize field
|
|
|
|
*/
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyFromCaller(&wi.cbSize, (PVOID)Param2, sizeof(wi.cbSize));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if(wi.cbSize != sizeof(WINDOWINFO))
|
|
|
|
{
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
2004-05-12 15:28:01 +00:00
|
|
|
#endif
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
if((Ret = (DWORD)IntGetWindowInfo(Window, &wi)))
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
|
|
|
Status = MmCopyToCaller((PVOID)Param2, &wi, sizeof(WINDOWINFO));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Ret);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_REGISTERLOGONPROC:
|
|
|
|
RETURN( (DWORD)co_IntRegisterLogonProcess((HANDLE)Param1, (BOOL)Param2));
|
2004-12-12 01:40:39 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_SETSYSCOLORS:
|
|
|
|
{
|
|
|
|
DWORD Ret = 0;
|
|
|
|
PVOID Buffer;
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
INT *Elements;
|
|
|
|
COLORREF *Colors;
|
|
|
|
}
|
|
|
|
ChangeSysColors;
|
2004-12-12 01:40:39 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* FIXME - we should make use of SEH here... */
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyFromCaller(&ChangeSysColors, (PVOID)Param1, sizeof(ChangeSysColors));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( 0);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Buffer = ExAllocatePool(PagedPool, (Param2 * sizeof(INT)) + (Param2 * sizeof(COLORREF)));
|
|
|
|
if(Buffer != NULL)
|
|
|
|
{
|
|
|
|
INT *Elements = (INT*)Buffer;
|
|
|
|
COLORREF *Colors = (COLORREF*)Buffer + Param2;
|
|
|
|
|
|
|
|
Status = MmCopyFromCaller(Elements, ChangeSysColors.Elements, Param2 * sizeof(INT));
|
|
|
|
if(NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
Status = MmCopyFromCaller(Colors, ChangeSysColors.Colors, Param2 * sizeof(COLORREF));
|
|
|
|
if(NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
Ret = (DWORD)IntSetSysColors((UINT)Param2, Elements, Colors);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
SetLastNtError(Status);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
SetLastNtError(Status);
|
|
|
|
|
|
|
|
ExFreePool(Buffer);
|
|
|
|
}
|
2005-07-18 03:12:01 +00:00
|
|
|
|
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( Ret);
|
|
|
|
}
|
2004-12-12 01:40:39 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
case TWOPARAM_ROUTINE_GETSYSCOLORBRUSHES:
|
|
|
|
case TWOPARAM_ROUTINE_GETSYSCOLORPENS:
|
|
|
|
case TWOPARAM_ROUTINE_GETSYSCOLORS:
|
|
|
|
{
|
|
|
|
DWORD Ret = 0;
|
|
|
|
union
|
|
|
|
{
|
|
|
|
PVOID Pointer;
|
|
|
|
HBRUSH *Brushes;
|
|
|
|
HPEN *Pens;
|
|
|
|
COLORREF *Colors;
|
|
|
|
} Buffer;
|
2004-12-12 01:40:39 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* FIXME - we should make use of SEH here... */
|
|
|
|
|
|
|
|
Buffer.Pointer = ExAllocatePool(PagedPool, Param2 * sizeof(HANDLE));
|
|
|
|
if(Buffer.Pointer != NULL)
|
|
|
|
{
|
|
|
|
switch(Routine)
|
|
|
|
{
|
|
|
|
case TWOPARAM_ROUTINE_GETSYSCOLORBRUSHES:
|
|
|
|
Ret = (DWORD)IntGetSysColorBrushes(Buffer.Brushes, (UINT)Param2);
|
|
|
|
break;
|
|
|
|
case TWOPARAM_ROUTINE_GETSYSCOLORPENS:
|
|
|
|
Ret = (DWORD)IntGetSysColorPens(Buffer.Pens, (UINT)Param2);
|
|
|
|
break;
|
|
|
|
case TWOPARAM_ROUTINE_GETSYSCOLORS:
|
|
|
|
Ret = (DWORD)IntGetSysColors(Buffer.Colors, (UINT)Param2);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(Ret > 0)
|
|
|
|
{
|
|
|
|
Status = MmCopyToCaller((PVOID)Param1, Buffer.Pointer, Param2 * sizeof(HANDLE));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
Ret = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ExFreePool(Buffer.Pointer);
|
|
|
|
}
|
|
|
|
RETURN( Ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
DPRINT1("Calling invalid routine number 0x%x in NtUserCallTwoParam(), Param1=0x%x Parm2=0x%x\n",
|
|
|
|
Routine, Param1, Param2);
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
|
|
|
RETURN( 0);
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserCallTwoParam, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-05-26 18:52:37 +00:00
|
|
|
}
|
2003-08-28 18:04:59 +00:00
|
|
|
|
2005-07-18 03:12:01 +00:00
|
|
|
|
2003-11-30 20:03:47 +00:00
|
|
|
/*
|
|
|
|
* @unimplemented
|
|
|
|
*/
|
|
|
|
BOOL
|
|
|
|
STDCALL
|
|
|
|
NtUserCallHwndLock(
|
2005-09-07 21:25:42 +00:00
|
|
|
HWND hWnd,
|
|
|
|
DWORD Routine)
|
2003-11-30 20:03:47 +00:00
|
|
|
{
|
|
|
|
BOOL Ret = 0;
|
|
|
|
PWINDOW_OBJECT Window;
|
2005-10-15 13:22:13 +00:00
|
|
|
USER_REFERENCE_ENTRY Ref;
|
2005-09-07 21:25:42 +00:00
|
|
|
DECLARE_RETURN(BOOLEAN);
|
2005-09-05 21:19:23 +00:00
|
|
|
|
|
|
|
DPRINT("Enter NtUserCallHwndLock\n");
|
|
|
|
UserEnterExclusive();
|
2003-11-30 20:03:47 +00:00
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
if (!(Window = UserGetWindowObject(hWnd)))
|
2003-11-30 20:03:47 +00:00
|
|
|
{
|
2005-09-05 21:19:23 +00:00
|
|
|
RETURN( FALSE);
|
2003-11-30 20:03:47 +00:00
|
|
|
}
|
2005-10-15 13:22:13 +00:00
|
|
|
UserRefObjectCo(Window, &Ref);
|
2003-11-30 20:03:47 +00:00
|
|
|
|
|
|
|
/* FIXME: Routine can be 0x53 - 0x5E */
|
|
|
|
switch (Routine)
|
|
|
|
{
|
|
|
|
case HWNDLOCK_ROUTINE_ARRANGEICONICWINDOWS:
|
2005-09-05 21:19:23 +00:00
|
|
|
co_WinPosArrangeIconicWindows(Window);
|
2003-11-30 20:03:47 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HWNDLOCK_ROUTINE_DRAWMENUBAR:
|
2005-09-07 21:25:42 +00:00
|
|
|
{
|
2005-09-11 14:48:32 +00:00
|
|
|
PMENU_OBJECT Menu;
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("HWNDLOCK_ROUTINE_DRAWMENUBAR\n");
|
|
|
|
Ret = FALSE;
|
|
|
|
if (!((Window->Style & (WS_CHILD | WS_POPUP)) != WS_CHILD))
|
|
|
|
break;
|
2005-09-11 14:48:32 +00:00
|
|
|
|
|
|
|
if(!(Menu = UserGetMenuObject((HMENU) Window->IDMenu)))
|
2005-09-07 21:25:42 +00:00
|
|
|
break;
|
2005-09-11 14:48:32 +00:00
|
|
|
|
|
|
|
Menu->MenuInfo.WndOwner = hWnd;
|
|
|
|
Menu->MenuInfo.Height = 0;
|
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
co_WinPosSetWindowPos(Window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
|
|
|
|
SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
|
2005-09-11 14:48:32 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Ret = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
2003-11-30 20:03:47 +00:00
|
|
|
|
|
|
|
case HWNDLOCK_ROUTINE_REDRAWFRAME:
|
|
|
|
/* FIXME */
|
|
|
|
break;
|
|
|
|
|
2004-07-08 14:36:18 +00:00
|
|
|
case HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOW:
|
2005-09-05 21:19:23 +00:00
|
|
|
Ret = co_IntSetForegroundWindow(Window);
|
2003-11-30 20:03:47 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HWNDLOCK_ROUTINE_UPDATEWINDOW:
|
|
|
|
/* FIXME */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-09-11 14:48:32 +00:00
|
|
|
UserDerefObjectCo(Window);
|
2003-11-30 20:03:47 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
RETURN( Ret);
|
2005-09-07 21:25:42 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
|
|
|
DPRINT("Leave NtUserCallHwndLock, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
2005-09-07 21:25:42 +00:00
|
|
|
END_CLEANUP;
|
2003-11-30 20:03:47 +00:00
|
|
|
}
|
|
|
|
|
2005-07-31 06:22:05 +00:00
|
|
|
/*
|
|
|
|
* @unimplemented
|
|
|
|
*/
|
2003-11-22 11:01:28 +00:00
|
|
|
HWND
|
|
|
|
STDCALL
|
|
|
|
NtUserCallHwndOpt(
|
2005-09-07 21:25:42 +00:00
|
|
|
HWND Param,
|
|
|
|
DWORD Routine)
|
2003-11-22 11:01:28 +00:00
|
|
|
{
|
|
|
|
switch (Routine)
|
|
|
|
{
|
|
|
|
case HWNDOPT_ROUTINE_SETPROGMANWINDOW:
|
2005-09-07 21:25:42 +00:00
|
|
|
/*
|
2005-07-31 06:22:05 +00:00
|
|
|
* FIXME
|
|
|
|
* Nothing too hard...validate the hWnd and save it in the Desktop Info
|
|
|
|
*/
|
|
|
|
DPRINT1("HWNDOPT_ROUTINE_SETPROGMANWINDOW UNIMPLEMENTED\n");
|
2003-11-22 11:01:28 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HWNDOPT_ROUTINE_SETTASKMANWINDOW:
|
2005-09-07 21:25:42 +00:00
|
|
|
/*
|
2005-07-31 06:22:05 +00:00
|
|
|
* FIXME
|
|
|
|
* Nothing too hard...validate the hWnd and save it in the Desktop Info
|
|
|
|
*/
|
|
|
|
DPRINT1("HWNDOPT_ROUTINE_SETTASKMANWINDOW UNIMPLEMENTED\n");
|
2003-11-22 11:01:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-07-31 06:22:05 +00:00
|
|
|
return Param;
|
2003-11-22 11:01:28 +00:00
|
|
|
}
|
2003-08-28 18:04:59 +00:00
|
|
|
|
2003-11-30 20:03:47 +00:00
|
|
|
/*
|
|
|
|
* @unimplemented
|
|
|
|
*/
|
|
|
|
DWORD STDCALL
|
|
|
|
NtUserGetThreadState(
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD Routine)
|
2003-11-30 20:03:47 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
DECLARE_RETURN(DWORD);
|
2005-09-05 21:19:23 +00:00
|
|
|
|
|
|
|
DPRINT("Enter NtUserGetThreadState\n");
|
|
|
|
UserEnterShared();
|
2005-09-07 21:25:42 +00:00
|
|
|
|
2003-11-30 20:03:47 +00:00
|
|
|
switch (Routine)
|
|
|
|
{
|
|
|
|
case 0:
|
2005-09-05 21:19:23 +00:00
|
|
|
RETURN( (DWORD)IntGetThreadFocusWindow());
|
2003-11-30 20:03:47 +00:00
|
|
|
}
|
2005-09-05 21:19:23 +00:00
|
|
|
RETURN( 0);
|
2005-09-07 21:25:42 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
|
|
|
DPRINT("Leave NtUserGetThreadState, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
2005-09-07 21:25:42 +00:00
|
|
|
END_CLEANUP;
|
2003-11-30 20:03:47 +00:00
|
|
|
}
|
|
|
|
|
2004-03-07 11:59:43 +00:00
|
|
|
VOID FASTCALL
|
2005-05-08 02:11:54 +00:00
|
|
|
IntGetFontMetricSetting(LPWSTR lpValueName, PLOGFONTW font)
|
|
|
|
{
|
2004-03-07 11:59:43 +00:00
|
|
|
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
|
|
|
|
NTSTATUS Status;
|
2005-11-02 23:15:40 +00:00
|
|
|
/* Firefox 1.0.7 depends on the lfHeight value being negative */
|
2004-03-07 11:59:43 +00:00
|
|
|
static LOGFONTW DefaultFont = {
|
2005-11-02 23:15:40 +00:00
|
|
|
-11, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
|
2005-09-07 21:25:42 +00:00
|
|
|
0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS,
|
|
|
|
L"Bitstream Vera Sans"
|
|
|
|
};
|
2004-03-07 11:59:43 +00:00
|
|
|
|
|
|
|
RtlZeroMemory(&QueryTable, sizeof(QueryTable));
|
|
|
|
|
|
|
|
QueryTable[0].Name = lpValueName;
|
|
|
|
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
|
|
|
|
QueryTable[0].EntryContext = font;
|
|
|
|
|
|
|
|
Status = RtlQueryRegistryValues(
|
2005-09-07 21:25:42 +00:00
|
|
|
RTL_REGISTRY_USER,
|
|
|
|
L"Control Panel\\Desktop\\WindowMetrics",
|
|
|
|
QueryTable,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
2004-03-07 11:59:43 +00:00
|
|
|
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
RtlCopyMemory(font, &DefaultFont, sizeof(LOGFONTW));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-01 11:38:28 +00:00
|
|
|
ULONG FASTCALL
|
|
|
|
IntSystemParametersInfo(
|
2005-09-07 21:25:42 +00:00
|
|
|
UINT uiAction,
|
|
|
|
UINT uiParam,
|
|
|
|
PVOID pvParam,
|
|
|
|
UINT fWinIni)
|
2003-08-28 18:04:59 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
PWINSTATION_OBJECT WinStaObject;
|
|
|
|
NTSTATUS Status;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
static BOOL bInitialized = FALSE;
|
|
|
|
static LOGFONTW IconFont;
|
|
|
|
static NONCLIENTMETRICSW pMetrics;
|
|
|
|
static BOOL GradientCaptions = TRUE;
|
|
|
|
static UINT FocusBorderHeight = 1;
|
|
|
|
static UINT FocusBorderWidth = 1;
|
|
|
|
|
|
|
|
if (!bInitialized)
|
|
|
|
{
|
|
|
|
RtlZeroMemory(&IconFont, sizeof(LOGFONTW));
|
|
|
|
RtlZeroMemory(&pMetrics, sizeof(NONCLIENTMETRICSW));
|
|
|
|
|
|
|
|
IntGetFontMetricSetting(L"CaptionFont", &pMetrics.lfCaptionFont);
|
|
|
|
IntGetFontMetricSetting(L"SmCaptionFont", &pMetrics.lfSmCaptionFont);
|
|
|
|
IntGetFontMetricSetting(L"MenuFont", &pMetrics.lfMenuFont);
|
|
|
|
IntGetFontMetricSetting(L"StatusFont", &pMetrics.lfStatusFont);
|
|
|
|
IntGetFontMetricSetting(L"MessageFont", &pMetrics.lfMessageFont);
|
|
|
|
IntGetFontMetricSetting(L"IconFont", &IconFont);
|
|
|
|
|
|
|
|
pMetrics.iBorderWidth = 1;
|
|
|
|
pMetrics.iScrollWidth = UserGetSystemMetrics(SM_CXVSCROLL);
|
|
|
|
pMetrics.iScrollHeight = UserGetSystemMetrics(SM_CYHSCROLL);
|
|
|
|
pMetrics.iCaptionWidth = UserGetSystemMetrics(SM_CXSIZE);
|
|
|
|
pMetrics.iCaptionHeight = UserGetSystemMetrics(SM_CYSIZE);
|
|
|
|
pMetrics.iSmCaptionWidth = UserGetSystemMetrics(SM_CXSMSIZE);
|
|
|
|
pMetrics.iSmCaptionHeight = UserGetSystemMetrics(SM_CYSMSIZE);
|
|
|
|
pMetrics.iMenuWidth = UserGetSystemMetrics(SM_CXMENUSIZE);
|
|
|
|
pMetrics.iMenuHeight = UserGetSystemMetrics(SM_CYMENUSIZE);
|
|
|
|
pMetrics.cbSize = sizeof(NONCLIENTMETRICSW);
|
|
|
|
|
|
|
|
bInitialized = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(uiAction)
|
|
|
|
{
|
|
|
|
case SPI_SETDOUBLECLKWIDTH:
|
|
|
|
case SPI_SETDOUBLECLKHEIGHT:
|
|
|
|
case SPI_SETDOUBLECLICKTIME:
|
|
|
|
case SPI_SETDESKWALLPAPER:
|
|
|
|
case SPI_GETDESKWALLPAPER:
|
|
|
|
{
|
|
|
|
PSYSTEM_CURSORINFO CurInfo;
|
|
|
|
|
|
|
|
Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
|
|
|
|
KernelMode,
|
|
|
|
0,
|
|
|
|
&WinStaObject);
|
|
|
|
if(!NT_SUCCESS(Status))
|
2004-08-17 21:47:36 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
SetLastNtError(Status);
|
|
|
|
return (DWORD)FALSE;
|
2004-08-17 21:47:36 +00:00
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
switch(uiAction)
|
|
|
|
{
|
|
|
|
case SPI_SETDOUBLECLKWIDTH:
|
|
|
|
CurInfo = IntGetSysCursorInfo(WinStaObject);
|
|
|
|
/* FIXME limit the maximum value? */
|
|
|
|
CurInfo->DblClickWidth = uiParam;
|
|
|
|
break;
|
|
|
|
case SPI_SETDOUBLECLKHEIGHT:
|
|
|
|
CurInfo = IntGetSysCursorInfo(WinStaObject);
|
|
|
|
/* FIXME limit the maximum value? */
|
|
|
|
CurInfo->DblClickHeight = uiParam;
|
|
|
|
break;
|
|
|
|
case SPI_SETDOUBLECLICKTIME:
|
|
|
|
CurInfo = IntGetSysCursorInfo(WinStaObject);
|
|
|
|
/* FIXME limit the maximum time to 1000 ms? */
|
|
|
|
CurInfo->DblClickSpeed = uiParam;
|
|
|
|
break;
|
|
|
|
case SPI_SETDESKWALLPAPER:
|
|
|
|
{
|
|
|
|
/* This function expects different parameters than the user mode version!
|
|
|
|
|
|
|
|
We let the user mode code load the bitmap, it passed the handle to
|
|
|
|
the bitmap. We'll change it's ownership to system and replace it with
|
|
|
|
the current wallpaper bitmap */
|
|
|
|
HBITMAP hOldBitmap, hNewBitmap;
|
2005-11-27 04:16:53 +00:00
|
|
|
UNICODE_STRING Key = RTL_CONSTANT_STRING(L"Control Panel\\Desktop");
|
2005-11-25 04:14:59 +00:00
|
|
|
UNICODE_STRING Tile = RTL_CONSTANT_STRING(L"TileWallpaper");
|
|
|
|
UNICODE_STRING Style = RTL_CONSTANT_STRING(L"WallpaperStyle");
|
2005-11-27 04:16:53 +00:00
|
|
|
UNICODE_STRING KeyPath;
|
2005-11-25 04:14:59 +00:00
|
|
|
OBJECT_ATTRIBUTES KeyAttributes;
|
2005-11-27 04:16:53 +00:00
|
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
2005-11-25 04:14:59 +00:00
|
|
|
NTSTATUS Status;
|
2005-11-27 04:16:53 +00:00
|
|
|
HANDLE CurrentUserKey = NULL;
|
2005-11-25 04:14:59 +00:00
|
|
|
HANDLE KeyHandle = NULL;
|
|
|
|
PKEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
|
|
|
|
ULONG Length = 0;
|
|
|
|
ULONG ResLength = 0;
|
|
|
|
ULONG TileNum = 0;
|
|
|
|
ULONG StyleNum = 0;
|
2006-01-08 23:26:03 +00:00
|
|
|
ASSERT(pvParam);
|
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
hNewBitmap = *(HBITMAP*)pvParam;
|
|
|
|
if(hNewBitmap != NULL)
|
|
|
|
{
|
|
|
|
BITMAPOBJ *bmp;
|
|
|
|
/* try to get the size of the wallpaper */
|
|
|
|
if(!(bmp = BITMAPOBJ_LockBitmap(hNewBitmap)))
|
|
|
|
{
|
|
|
|
ObDereferenceObject(WinStaObject);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
WinStaObject->cxWallpaper = bmp->SurfObj.sizlBitmap.cx;
|
|
|
|
WinStaObject->cyWallpaper = bmp->SurfObj.sizlBitmap.cy;
|
|
|
|
|
|
|
|
BITMAPOBJ_UnlockBitmap(bmp);
|
|
|
|
|
|
|
|
/* change the bitmap's ownership */
|
2006-04-01 15:25:40 +00:00
|
|
|
GDIOBJ_SetOwnership(GdiHandleTable, hNewBitmap, NULL);
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
hOldBitmap = (HBITMAP)InterlockedExchange((LONG*)&WinStaObject->hbmWallpaper, (LONG)hNewBitmap);
|
|
|
|
if(hOldBitmap != NULL)
|
|
|
|
{
|
|
|
|
/* delete the old wallpaper */
|
|
|
|
NtGdiDeleteObject(hOldBitmap);
|
|
|
|
}
|
2005-11-25 04:14:59 +00:00
|
|
|
|
|
|
|
/* Set the style */
|
|
|
|
|
|
|
|
/*default value is center */
|
|
|
|
WinStaObject->WallpaperMode = wmCenter;
|
|
|
|
|
2005-11-27 04:16:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Get a handle to the current users settings */
|
|
|
|
RtlFormatCurrentUserKeyPath(&KeyPath);
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,&KeyPath,OBJ_CASE_INSENSITIVE,NULL,NULL);
|
|
|
|
ZwOpenKey(&CurrentUserKey, KEY_READ, &ObjectAttributes);
|
|
|
|
RtlFreeUnicodeString(&KeyPath);
|
|
|
|
|
|
|
|
/* open up the settings to read the values */
|
2005-11-25 04:14:59 +00:00
|
|
|
InitializeObjectAttributes(&KeyAttributes, &Key, OBJ_CASE_INSENSITIVE,
|
2005-11-27 04:16:53 +00:00
|
|
|
CurrentUserKey, NULL);
|
2005-11-25 04:14:59 +00:00
|
|
|
ZwOpenKey(&KeyHandle, KEY_READ, &KeyAttributes);
|
2005-11-27 23:15:07 +00:00
|
|
|
ZwClose(CurrentUserKey);
|
2005-11-27 04:16:53 +00:00
|
|
|
|
|
|
|
/* read the tile value in the registry */
|
2005-11-25 04:14:59 +00:00
|
|
|
Status = ZwQueryValueKey(KeyHandle, &Tile, KeyValuePartialInformation,
|
|
|
|
0, 0, &ResLength);
|
2005-11-27 04:16:53 +00:00
|
|
|
|
2005-11-27 23:15:07 +00:00
|
|
|
/* fall back to .DEFAULT if we didnt find values */
|
|
|
|
if(Status == STATUS_INVALID_HANDLE)
|
|
|
|
{
|
|
|
|
RtlInitUnicodeString (&KeyPath,L"\\Registry\\User\\.Default\\Control Panel\\Desktop");
|
|
|
|
InitializeObjectAttributes(&KeyAttributes, &KeyPath, OBJ_CASE_INSENSITIVE,
|
|
|
|
NULL, NULL);
|
|
|
|
ZwOpenKey(&KeyHandle, KEY_READ, &KeyAttributes);
|
|
|
|
ZwQueryValueKey(KeyHandle, &Tile, KeyValuePartialInformation,
|
|
|
|
0, 0, &ResLength);
|
|
|
|
}
|
|
|
|
|
2005-11-25 04:14:59 +00:00
|
|
|
ResLength += sizeof(KEY_VALUE_PARTIAL_INFORMATION);
|
|
|
|
KeyValuePartialInfo = ExAllocatePoolWithTag(PagedPool, ResLength, TAG_STRING);
|
|
|
|
Length = ResLength;
|
|
|
|
|
|
|
|
if(!KeyValuePartialInfo)
|
|
|
|
{
|
|
|
|
NtClose(KeyHandle);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status = ZwQueryValueKey(KeyHandle, &Tile, KeyValuePartialInformation,
|
|
|
|
(PVOID)KeyValuePartialInfo, Length, &ResLength);
|
|
|
|
if(!NT_SUCCESS(Status) || (KeyValuePartialInfo->Type != REG_SZ))
|
|
|
|
{
|
2005-11-27 23:15:07 +00:00
|
|
|
ZwClose(KeyHandle);
|
2005-11-25 04:14:59 +00:00
|
|
|
ExFreePool(KeyValuePartialInfo);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Tile.Length = KeyValuePartialInfo->DataLength;
|
|
|
|
Tile.MaximumLength = KeyValuePartialInfo->DataLength;
|
|
|
|
Tile.Buffer = (PWSTR)KeyValuePartialInfo->Data;
|
|
|
|
|
|
|
|
Status = RtlUnicodeStringToInteger(&Tile, 0, &TileNum);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
TileNum = 0;
|
|
|
|
}
|
|
|
|
ExFreePool(KeyValuePartialInfo);
|
|
|
|
|
|
|
|
/* start over again and look for the style*/
|
|
|
|
ResLength = 0;
|
|
|
|
Status = ZwQueryValueKey(KeyHandle, &Style, KeyValuePartialInformation,
|
|
|
|
0, 0, &ResLength);
|
|
|
|
|
|
|
|
ResLength += sizeof(KEY_VALUE_PARTIAL_INFORMATION);
|
|
|
|
KeyValuePartialInfo = ExAllocatePoolWithTag(PagedPool, ResLength, TAG_STRING);
|
|
|
|
Length = ResLength;
|
|
|
|
|
|
|
|
if(!KeyValuePartialInfo)
|
|
|
|
{
|
2005-11-27 23:15:07 +00:00
|
|
|
ZwClose(KeyHandle);
|
2005-11-25 04:14:59 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status = ZwQueryValueKey(KeyHandle, &Style, KeyValuePartialInformation,
|
|
|
|
(PVOID)KeyValuePartialInfo, Length, &ResLength);
|
|
|
|
if(!NT_SUCCESS(Status) || (KeyValuePartialInfo->Type != REG_SZ))
|
|
|
|
{
|
2005-11-27 23:15:07 +00:00
|
|
|
ZwClose(KeyHandle);
|
2005-11-25 04:14:59 +00:00
|
|
|
ExFreePool(KeyValuePartialInfo);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
Style.Length = KeyValuePartialInfo->DataLength;
|
|
|
|
Style.MaximumLength = KeyValuePartialInfo->DataLength;
|
|
|
|
Style.Buffer = (PWSTR)KeyValuePartialInfo->Data;
|
|
|
|
|
|
|
|
Status = RtlUnicodeStringToInteger(&Style, 0, &StyleNum);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
StyleNum = 0;
|
|
|
|
}
|
|
|
|
ExFreePool(KeyValuePartialInfo);
|
|
|
|
|
|
|
|
/* Check the values we found in the registry */
|
|
|
|
if(TileNum && !StyleNum)
|
|
|
|
{
|
|
|
|
WinStaObject->WallpaperMode = wmTile;
|
|
|
|
}
|
|
|
|
else if(!TileNum && StyleNum == 2)
|
|
|
|
{
|
|
|
|
WinStaObject->WallpaperMode = wmStretch;
|
|
|
|
}
|
|
|
|
|
2005-11-27 23:15:07 +00:00
|
|
|
ZwClose(KeyHandle);
|
2005-09-07 21:25:42 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SPI_GETDESKWALLPAPER:
|
|
|
|
/* This function expects different parameters than the user mode version!
|
|
|
|
|
|
|
|
We basically return the current wallpaper handle - if any. The user
|
|
|
|
mode version should load the string from the registry and return it
|
|
|
|
without calling this function */
|
|
|
|
ASSERT(pvParam);
|
|
|
|
*(HBITMAP*)pvParam = (HBITMAP)WinStaObject->hbmWallpaper;
|
|
|
|
break;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* FIXME save the value to the registry */
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ObDereferenceObject(WinStaObject);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_SETWORKAREA:
|
|
|
|
{
|
|
|
|
RECT *rc;
|
|
|
|
PDESKTOP_OBJECT Desktop = PsGetWin32Thread()->Desktop;
|
|
|
|
|
|
|
|
if(!Desktop)
|
|
|
|
{
|
|
|
|
/* FIXME - Set last error */
|
|
|
|
return FALSE;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ASSERT(pvParam);
|
|
|
|
rc = (RECT*)pvParam;
|
|
|
|
Desktop->WorkArea = *rc;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETWORKAREA:
|
|
|
|
{
|
|
|
|
PDESKTOP_OBJECT Desktop = PsGetWin32Thread()->Desktop;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if(!Desktop)
|
|
|
|
{
|
|
|
|
/* FIXME - Set last error */
|
|
|
|
return FALSE;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ASSERT(pvParam);
|
|
|
|
IntGetDesktopWorkArea(Desktop, (PRECT)pvParam);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_SETGRADIENTCAPTIONS:
|
|
|
|
{
|
|
|
|
GradientCaptions = (pvParam != NULL);
|
|
|
|
/* FIXME - should be checked if the color depth is higher than 8bpp? */
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETGRADIENTCAPTIONS:
|
|
|
|
{
|
|
|
|
HDC hDC;
|
|
|
|
BOOL Ret = GradientCaptions;
|
|
|
|
|
|
|
|
hDC = IntGetScreenDC();
|
|
|
|
if(hDC)
|
|
|
|
{
|
|
|
|
Ret = (NtGdiGetDeviceCaps(hDC, BITSPIXEL) > 8) && Ret;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ASSERT(pvParam);
|
|
|
|
*((PBOOL)pvParam) = Ret;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
case SPI_SETFONTSMOOTHING:
|
|
|
|
{
|
|
|
|
IntEnableFontRendering(uiParam != 0);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETFONTSMOOTHING:
|
|
|
|
{
|
|
|
|
ASSERT(pvParam);
|
|
|
|
*((BOOL*)pvParam) = IntIsFontRenderingEnabled();
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETICONTITLELOGFONT:
|
|
|
|
{
|
|
|
|
ASSERT(pvParam);
|
|
|
|
*((LOGFONTW*)pvParam) = IconFont;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETNONCLIENTMETRICS:
|
|
|
|
{
|
|
|
|
ASSERT(pvParam);
|
|
|
|
*((NONCLIENTMETRICSW*)pvParam) = pMetrics;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETFOCUSBORDERHEIGHT:
|
|
|
|
{
|
|
|
|
ASSERT(pvParam);
|
|
|
|
*((UINT*)pvParam) = FocusBorderHeight;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_GETFOCUSBORDERWIDTH:
|
|
|
|
{
|
|
|
|
ASSERT(pvParam);
|
|
|
|
*((UINT*)pvParam) = FocusBorderWidth;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_SETFOCUSBORDERHEIGHT:
|
|
|
|
{
|
|
|
|
FocusBorderHeight = (UINT)pvParam;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
case SPI_SETFOCUSBORDERWIDTH:
|
|
|
|
{
|
|
|
|
FocusBorderWidth = (UINT)pvParam;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
DPRINT1("SystemParametersInfo: Unsupported Action 0x%x (uiParam: 0x%x, pvParam: 0x%x, fWinIni: 0x%x)\n",
|
|
|
|
uiAction, uiParam, pvParam, fWinIni);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return FALSE;
|
2004-05-01 11:38:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* @implemented
|
|
|
|
*/
|
2005-09-05 21:19:23 +00:00
|
|
|
BOOL FASTCALL
|
|
|
|
UserSystemParametersInfo(
|
2005-09-07 21:25:42 +00:00
|
|
|
UINT uiAction,
|
|
|
|
UINT uiParam,
|
|
|
|
PVOID pvParam,
|
|
|
|
UINT fWinIni)
|
2004-05-01 11:38:28 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
switch(uiAction)
|
|
|
|
{
|
|
|
|
case SPI_SETDOUBLECLKWIDTH:
|
|
|
|
case SPI_SETDOUBLECLKHEIGHT:
|
|
|
|
case SPI_SETDOUBLECLICKTIME:
|
|
|
|
case SPI_SETGRADIENTCAPTIONS:
|
|
|
|
case SPI_SETFONTSMOOTHING:
|
|
|
|
case SPI_SETFOCUSBORDERHEIGHT:
|
|
|
|
case SPI_SETFOCUSBORDERWIDTH:
|
|
|
|
{
|
|
|
|
return (DWORD)IntSystemParametersInfo(uiAction, uiParam, pvParam, fWinIni);
|
|
|
|
}
|
|
|
|
case SPI_SETWORKAREA:
|
|
|
|
{
|
|
|
|
RECT rc;
|
|
|
|
Status = MmCopyFromCaller(&rc, (PRECT)pvParam, sizeof(RECT));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( (DWORD)IntSystemParametersInfo(uiAction, uiParam, &rc, fWinIni));
|
|
|
|
}
|
|
|
|
case SPI_GETWORKAREA:
|
|
|
|
{
|
|
|
|
RECT rc;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if(!IntSystemParametersInfo(uiAction, uiParam, &rc, fWinIni))
|
|
|
|
{
|
|
|
|
return( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyToCaller((PRECT)pvParam, &rc, sizeof(RECT));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( TRUE);
|
|
|
|
}
|
|
|
|
case SPI_GETFONTSMOOTHING:
|
|
|
|
case SPI_GETGRADIENTCAPTIONS:
|
|
|
|
case SPI_GETFOCUSBORDERHEIGHT:
|
|
|
|
case SPI_GETFOCUSBORDERWIDTH:
|
|
|
|
{
|
|
|
|
BOOL Ret;
|
|
|
|
|
|
|
|
if(!IntSystemParametersInfo(uiAction, uiParam, &Ret, fWinIni))
|
|
|
|
{
|
|
|
|
return( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyToCaller(pvParam, &Ret, sizeof(BOOL));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( TRUE);
|
|
|
|
}
|
|
|
|
case SPI_SETDESKWALLPAPER:
|
|
|
|
{
|
|
|
|
/* !!! As opposed to the user mode version this version accepts a handle
|
|
|
|
to the bitmap! */
|
|
|
|
HBITMAP hbmWallpaper;
|
|
|
|
|
|
|
|
Status = MmCopyFromCaller(&hbmWallpaper, pvParam, sizeof(HBITMAP));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( IntSystemParametersInfo(SPI_SETDESKWALLPAPER, 0, &hbmWallpaper, fWinIni));
|
|
|
|
}
|
|
|
|
case SPI_GETDESKWALLPAPER:
|
|
|
|
{
|
|
|
|
/* !!! As opposed to the user mode version this version returns a handle
|
|
|
|
to the bitmap! */
|
|
|
|
HBITMAP hbmWallpaper;
|
|
|
|
BOOL Ret;
|
|
|
|
|
|
|
|
Ret = IntSystemParametersInfo(SPI_GETDESKWALLPAPER, 0, &hbmWallpaper, fWinIni);
|
|
|
|
|
|
|
|
Status = MmCopyToCaller(pvParam, &hbmWallpaper, sizeof(HBITMAP));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( Ret);
|
|
|
|
}
|
|
|
|
case SPI_GETICONTITLELOGFONT:
|
|
|
|
{
|
|
|
|
LOGFONTW IconFont;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if(!IntSystemParametersInfo(uiAction, uiParam, &IconFont, fWinIni))
|
|
|
|
{
|
|
|
|
return( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyToCaller(pvParam, &IconFont, sizeof(LOGFONTW));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( TRUE);
|
|
|
|
}
|
|
|
|
case SPI_GETNONCLIENTMETRICS:
|
|
|
|
{
|
|
|
|
NONCLIENTMETRICSW metrics;
|
|
|
|
|
|
|
|
Status = MmCopyFromCaller(&metrics.cbSize, pvParam, sizeof(UINT));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
if(metrics.cbSize != sizeof(NONCLIENTMETRICSW))
|
|
|
|
{
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if(!IntSystemParametersInfo(uiAction, uiParam, &metrics, fWinIni))
|
|
|
|
{
|
|
|
|
return( FALSE);
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyToCaller(pvParam, &metrics.cbSize, sizeof(NONCLIENTMETRICSW));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
return( FALSE);
|
|
|
|
}
|
|
|
|
return( TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return( FALSE);
|
2005-09-05 21:19:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* @implemented
|
|
|
|
*/
|
|
|
|
BOOL
|
|
|
|
STDCALL
|
|
|
|
NtUserSystemParametersInfo(
|
2005-09-07 21:25:42 +00:00
|
|
|
UINT uiAction,
|
|
|
|
UINT uiParam,
|
|
|
|
PVOID pvParam,
|
|
|
|
UINT fWinIni)
|
2005-09-05 21:19:23 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
DECLARE_RETURN(BOOLEAN);
|
|
|
|
|
|
|
|
DPRINT("Enter NtUserSystemParametersInfo\n");
|
|
|
|
UserEnterExclusive();
|
2005-09-05 21:19:23 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( UserSystemParametersInfo(uiAction, uiParam, pvParam, fWinIni));
|
2005-09-05 21:19:23 +00:00
|
|
|
|
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserSystemParametersInfo, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-08-28 18:04:59 +00:00
|
|
|
}
|
2003-09-12 12:54:26 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
|
|
|
|
|
2003-09-12 12:54:26 +00:00
|
|
|
UINT
|
|
|
|
STDCALL
|
|
|
|
NtUserGetDoubleClickTime(VOID)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
UINT Result;
|
|
|
|
NTSTATUS Status;
|
|
|
|
PWINSTATION_OBJECT WinStaObject;
|
|
|
|
PSYSTEM_CURSORINFO CurInfo;
|
|
|
|
DECLARE_RETURN(UINT);
|
|
|
|
|
|
|
|
DPRINT("Enter NtUserGetDoubleClickTime\n");
|
|
|
|
UserEnterShared();
|
|
|
|
|
|
|
|
Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
|
|
|
|
KernelMode,
|
|
|
|
0,
|
|
|
|
&WinStaObject);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
RETURN( (DWORD)FALSE);
|
|
|
|
|
|
|
|
CurInfo = IntGetSysCursorInfo(WinStaObject);
|
|
|
|
Result = CurInfo->DblClickSpeed;
|
|
|
|
|
|
|
|
ObDereferenceObject(WinStaObject);
|
|
|
|
RETURN( Result);
|
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserGetDoubleClickTime, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-09-12 12:54:26 +00:00
|
|
|
}
|
|
|
|
|
2003-11-18 23:33:31 +00:00
|
|
|
BOOL
|
|
|
|
STDCALL
|
|
|
|
NtUserGetGUIThreadInfo(
|
2005-09-07 21:25:42 +00:00
|
|
|
DWORD idThread, /* if NULL use foreground thread */
|
|
|
|
LPGUITHREADINFO lpgui)
|
2003-11-18 23:33:31 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
PTHRDCARETINFO CaretInfo;
|
|
|
|
GUITHREADINFO SafeGui;
|
|
|
|
PDESKTOP_OBJECT Desktop;
|
|
|
|
PUSER_MESSAGE_QUEUE MsgQueue;
|
|
|
|
PETHREAD Thread = NULL;
|
|
|
|
DECLARE_RETURN(BOOLEAN);
|
|
|
|
|
|
|
|
DPRINT("Enter NtUserGetGUIThreadInfo\n");
|
|
|
|
UserEnterShared();
|
|
|
|
|
|
|
|
Status = MmCopyFromCaller(&SafeGui, lpgui, sizeof(DWORD));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(SafeGui.cbSize != sizeof(GUITHREADINFO))
|
|
|
|
{
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
2005-09-05 21:19:23 +00:00
|
|
|
RETURN( FALSE);
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(idThread)
|
|
|
|
{
|
|
|
|
Status = PsLookupThreadByThreadId((HANDLE)idThread, &Thread);
|
|
|
|
if(!NT_SUCCESS(Status))
|
2003-11-18 23:33:31 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
SetLastWin32Error(ERROR_ACCESS_DENIED);
|
|
|
|
RETURN( FALSE);
|
2003-11-18 23:33:31 +00:00
|
|
|
}
|
2005-11-08 08:56:41 +00:00
|
|
|
Desktop = ((PW32THREAD)Thread->Tcb.Win32Thread)->Desktop;
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* get the foreground thread */
|
2005-11-08 08:56:41 +00:00
|
|
|
PW32THREAD W32Thread = (PW32THREAD)PsGetCurrentThread()->Tcb.Win32Thread;
|
2005-09-07 21:25:42 +00:00
|
|
|
Desktop = W32Thread->Desktop;
|
|
|
|
if(Desktop)
|
|
|
|
{
|
|
|
|
MsgQueue = Desktop->ActiveMessageQueue;
|
|
|
|
if(MsgQueue)
|
|
|
|
{
|
|
|
|
Thread = MsgQueue->Thread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
if(!Thread || !Desktop)
|
|
|
|
{
|
|
|
|
if(idThread && Thread)
|
|
|
|
ObDereferenceObject(Thread);
|
|
|
|
SetLastWin32Error(ERROR_ACCESS_DENIED);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
MsgQueue = (PUSER_MESSAGE_QUEUE)Desktop->ActiveMessageQueue;
|
|
|
|
CaretInfo = MsgQueue->CaretInfo;
|
|
|
|
|
|
|
|
SafeGui.flags = (CaretInfo->Visible ? GUI_CARETBLINKING : 0);
|
|
|
|
if(MsgQueue->MenuOwner)
|
|
|
|
SafeGui.flags |= GUI_INMENUMODE | MsgQueue->MenuState;
|
|
|
|
if(MsgQueue->MoveSize)
|
|
|
|
SafeGui.flags |= GUI_INMOVESIZE;
|
|
|
|
|
|
|
|
/* FIXME add flag GUI_16BITTASK */
|
|
|
|
|
|
|
|
SafeGui.hwndActive = MsgQueue->ActiveWindow;
|
|
|
|
SafeGui.hwndFocus = MsgQueue->FocusWindow;
|
|
|
|
SafeGui.hwndCapture = MsgQueue->CaptureWindow;
|
|
|
|
SafeGui.hwndMenuOwner = MsgQueue->MenuOwner;
|
|
|
|
SafeGui.hwndMoveSize = MsgQueue->MoveSize;
|
|
|
|
SafeGui.hwndCaret = CaretInfo->hWnd;
|
|
|
|
|
|
|
|
SafeGui.rcCaret.left = CaretInfo->Pos.x;
|
|
|
|
SafeGui.rcCaret.top = CaretInfo->Pos.y;
|
|
|
|
SafeGui.rcCaret.right = SafeGui.rcCaret.left + CaretInfo->Size.cx;
|
|
|
|
SafeGui.rcCaret.bottom = SafeGui.rcCaret.top + CaretInfo->Size.cy;
|
|
|
|
|
|
|
|
if(idThread)
|
2003-11-23 13:46:33 +00:00
|
|
|
ObDereferenceObject(Thread);
|
2005-09-07 21:25:42 +00:00
|
|
|
|
|
|
|
Status = MmCopyToCaller(lpgui, &SafeGui, sizeof(GUITHREADINFO));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN( TRUE);
|
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserGetGUIThreadInfo, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-11-18 23:33:31 +00:00
|
|
|
}
|
|
|
|
|
2003-11-19 12:25:03 +00:00
|
|
|
|
|
|
|
DWORD
|
|
|
|
STDCALL
|
|
|
|
NtUserGetGuiResources(
|
2005-09-07 21:25:42 +00:00
|
|
|
HANDLE hProcess,
|
|
|
|
DWORD uiFlags)
|
2003-11-19 12:25:03 +00:00
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
PEPROCESS Process;
|
|
|
|
PW32PROCESS W32Process;
|
|
|
|
NTSTATUS Status;
|
|
|
|
DWORD Ret = 0;
|
|
|
|
DECLARE_RETURN(DWORD);
|
|
|
|
|
|
|
|
DPRINT("Enter NtUserGetGuiResources\n");
|
|
|
|
UserEnterShared();
|
|
|
|
|
|
|
|
Status = ObReferenceObjectByHandle(hProcess,
|
|
|
|
PROCESS_QUERY_INFORMATION,
|
|
|
|
PsProcessType,
|
|
|
|
ExGetPreviousMode(),
|
|
|
|
(PVOID*)&Process,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
SetLastNtError(Status);
|
|
|
|
RETURN( 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
W32Process = (PW32PROCESS)Process->Win32Process;
|
|
|
|
if(!W32Process)
|
|
|
|
{
|
|
|
|
ObDereferenceObject(Process);
|
2003-11-19 12:25:03 +00:00
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
2005-09-07 21:25:42 +00:00
|
|
|
RETURN( 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(uiFlags)
|
|
|
|
{
|
|
|
|
case GR_GDIOBJECTS:
|
|
|
|
{
|
|
|
|
Ret = (DWORD)W32Process->GDIObjects;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case GR_USEROBJECTS:
|
|
|
|
{
|
|
|
|
Ret = (DWORD)W32Process->UserObjects;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
SetLastWin32Error(ERROR_INVALID_PARAMETER);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
ObDereferenceObject(Process);
|
|
|
|
|
|
|
|
RETURN( Ret);
|
2003-11-19 12:25:03 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
2005-09-07 21:25:42 +00:00
|
|
|
DPRINT("Leave NtUserGetGuiResources, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2003-11-19 12:25:03 +00:00
|
|
|
}
|
|
|
|
|
2003-12-13 15:49:32 +00:00
|
|
|
NTSTATUS FASTCALL
|
|
|
|
IntSafeCopyUnicodeString(PUNICODE_STRING Dest,
|
|
|
|
PUNICODE_STRING Source)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
PWSTR Src;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyFromCaller(Dest, Source, sizeof(UNICODE_STRING));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
2003-12-13 15:49:32 +00:00
|
|
|
return Status;
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(Dest->Length > 0x4000)
|
|
|
|
{
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
|
|
}
|
|
|
|
|
|
|
|
Src = Dest->Buffer;
|
|
|
|
Dest->Buffer = NULL;
|
|
|
|
|
|
|
|
if(Dest->Length > 0 && Src)
|
|
|
|
{
|
|
|
|
Dest->MaximumLength = Dest->Length;
|
|
|
|
Dest->Buffer = ExAllocatePoolWithTag(PagedPool, Dest->MaximumLength, TAG_STRING);
|
|
|
|
if(!Dest->Buffer)
|
|
|
|
{
|
|
|
|
return STATUS_NO_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status = MmCopyFromCaller(Dest->Buffer, Src, Dest->Length);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
ExFreePool(Dest->Buffer);
|
|
|
|
Dest->Buffer = NULL;
|
|
|
|
return Status;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* string is empty */
|
|
|
|
return STATUS_SUCCESS;
|
2003-12-13 15:49:32 +00:00
|
|
|
}
|
|
|
|
|
2004-05-19 19:09:20 +00:00
|
|
|
NTSTATUS FASTCALL
|
|
|
|
IntSafeCopyUnicodeStringTerminateNULL(PUNICODE_STRING Dest,
|
|
|
|
PUNICODE_STRING Source)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
PWSTR Src;
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
Status = MmCopyFromCaller(Dest, Source, sizeof(UNICODE_STRING));
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
2004-05-19 19:09:20 +00:00
|
|
|
return Status;
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(Dest->Length > 0x4000)
|
|
|
|
{
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
|
|
}
|
|
|
|
|
|
|
|
Src = Dest->Buffer;
|
|
|
|
Dest->Buffer = NULL;
|
|
|
|
|
|
|
|
if(Dest->Length > 0 && Src)
|
|
|
|
{
|
|
|
|
Dest->MaximumLength = Dest->Length + sizeof(WCHAR);
|
|
|
|
Dest->Buffer = ExAllocatePoolWithTag(PagedPool, Dest->MaximumLength, TAG_STRING);
|
|
|
|
if(!Dest->Buffer)
|
|
|
|
{
|
|
|
|
return STATUS_NO_MEMORY;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status = MmCopyFromCaller(Dest->Buffer, Src, Dest->Length);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
ExFreePool(Dest->Buffer);
|
|
|
|
Dest->Buffer = NULL;
|
|
|
|
return Status;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* make sure the string is null-terminated */
|
|
|
|
Src = (PWSTR)((PBYTE)Dest->Buffer + Dest->Length);
|
|
|
|
*Src = L'\0';
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
2005-05-08 02:11:54 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
/* string is empty */
|
|
|
|
return STATUS_SUCCESS;
|
2004-05-19 19:09:20 +00:00
|
|
|
}
|
|
|
|
|
2004-06-16 06:09:40 +00:00
|
|
|
NTSTATUS FASTCALL
|
|
|
|
IntUnicodeStringToNULLTerminated(PWSTR *Dest, PUNICODE_STRING Src)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
if (Src->Length + sizeof(WCHAR) <= Src->MaximumLength
|
|
|
|
&& L'\0' == Src->Buffer[Src->Length / sizeof(WCHAR)])
|
|
|
|
{
|
2004-06-16 06:09:40 +00:00
|
|
|
/* The unicode_string is already nul terminated. Just reuse it. */
|
|
|
|
*Dest = Src->Buffer;
|
|
|
|
return STATUS_SUCCESS;
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
2004-06-16 06:09:40 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
*Dest = ExAllocatePoolWithTag(PagedPool, Src->Length + sizeof(WCHAR), TAG_STRING);
|
|
|
|
if (NULL == *Dest)
|
|
|
|
{
|
2004-06-16 06:09:40 +00:00
|
|
|
return STATUS_NO_MEMORY;
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
|
|
|
RtlCopyMemory(*Dest, Src->Buffer, Src->Length);
|
|
|
|
(*Dest)[Src->Length / 2] = L'\0';
|
2004-06-16 06:09:40 +00:00
|
|
|
|
2005-09-07 21:25:42 +00:00
|
|
|
return STATUS_SUCCESS;
|
2004-06-16 06:09:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void FASTCALL
|
|
|
|
IntFreeNULLTerminatedFromUnicodeString(PWSTR NullTerminated, PUNICODE_STRING UnicodeString)
|
|
|
|
{
|
2005-09-07 21:25:42 +00:00
|
|
|
if (NullTerminated != UnicodeString->Buffer)
|
|
|
|
{
|
2004-06-16 06:09:40 +00:00
|
|
|
ExFreePool(NullTerminated);
|
2005-09-07 21:25:42 +00:00
|
|
|
}
|
2004-06-16 06:09:40 +00:00
|
|
|
}
|
|
|
|
|
2004-12-06 02:23:05 +00:00
|
|
|
BOOL STDCALL
|
|
|
|
NtUserUpdatePerUserSystemParameters(
|
2004-12-10 16:52:04 +00:00
|
|
|
DWORD dwReserved,
|
2004-12-06 02:23:05 +00:00
|
|
|
BOOL bEnable)
|
|
|
|
{
|
2004-12-10 16:52:04 +00:00
|
|
|
BOOL Result = TRUE;
|
2005-09-07 21:25:42 +00:00
|
|
|
DECLARE_RETURN(BOOLEAN);
|
2005-09-05 21:19:23 +00:00
|
|
|
|
|
|
|
DPRINT("Enter NtUserUpdatePerUserSystemParameters\n");
|
|
|
|
UserEnterExclusive();
|
2005-09-07 21:25:42 +00:00
|
|
|
|
2004-12-10 16:52:04 +00:00
|
|
|
Result &= IntDesktopUpdatePerUserSettings(bEnable);
|
2005-09-05 21:19:23 +00:00
|
|
|
RETURN( Result);
|
2005-09-07 21:25:42 +00:00
|
|
|
|
2005-09-05 21:19:23 +00:00
|
|
|
CLEANUP:
|
|
|
|
DPRINT("Leave NtUserUpdatePerUserSystemParameters, ret=%i\n",_ret_);
|
|
|
|
UserLeave();
|
|
|
|
END_CLEANUP;
|
2004-12-06 02:23:05 +00:00
|
|
|
}
|
|
|
|
|
2004-06-16 06:09:40 +00:00
|
|
|
/* EOF */
|