HCURSOR FASTCALL IntSetCursor(PWINSTATION_OBJECT WinStaObject, PCURICON_OBJECT NewCursor, BOOL ForceChange);
BOOL FASTCALL IntSetupCurIconHandles(PWINSTATION_OBJECT WinStaObject);
-PCURICON_OBJECT FASTCALL IntGetCurIconObject(HANDLE Handle);
PCURICON_OBJECT FASTCALL IntCreateCurIconHandle(PWINSTATION_OBJECT WinStaObject);
VOID FASTCALL IntCleanupCurIcons(struct _EPROCESS *Process, PW32PROCESS Win32Process);
#define DCEOBJ_UnlockDCE(pDCE) GDIOBJ_UnlockObjByPtr(pDCE)
BOOL INTERNAL_CALL DCE_Cleanup(PVOID ObjectBody);
-PDCE FASTCALL DceAllocDCE(HWND hWnd, DCE_TYPE Type);
+PDCE FASTCALL DceAllocDCE(PWINDOW_OBJECT Window, DCE_TYPE Type);
PDCE FASTCALL DCE_FreeDCE(PDCE dce);
VOID FASTCALL DCE_FreeWindowDCE(HWND);
-HRGN STDCALL DceGetVisRgn(HWND hWnd, ULONG Flags, HWND hWndChild, ULONG CFlags);
INT FASTCALL DCE_ExcludeRgn(HDC, HWND, HRGN);
BOOL FASTCALL DCE_InvalidateDCE(HWND, const PRECTL);
HWND FASTCALL IntWindowFromDC(HDC hDc);
VOID
UnregisterThreadHotKeys(struct _ETHREAD *Thread);
-#define IntLockHotKeys(WinStaObject) \
- ExAcquireFastMutex(&WinStaObject->HotKeyListLock)
-
-#define IntUnLockHotKeys(WinStaObject) \
- ExReleaseFastMutex(&WinStaObject->HotKeyListLock)
-
#endif /* _WIN32K_HOTKEY_H */
/* EOF */
\r
HWND FASTCALL UserGetForegroundWindow(VOID);\r
\r
-HWND FASTCALL UserSetFocus(HWND hWnd);\r
+HWND FASTCALL co_UserSetFocus(PWINDOW_OBJECT Window);\r
\r
/*************** WINDC.C ***************/\r
\r
IntGetActiveWindow (VOID);
BOOL FASTCALL
-IntIsWindowVisible (HWND hWnd);
+IntIsWindowVisible (PWINDOW_OBJECT Window);
BOOL FASTCALL
IntIsChildWindow (HWND Parent, HWND Child);
IntGetParentObject(PWINDOW_OBJECT Wnd);
INT FASTCALL
-IntGetWindowRgn(HWND hWnd, HRGN hRgn);
+IntGetWindowRgn(PWINDOW_OBJECT Window, HRGN hRgn);
INT FASTCALL
-IntGetWindowRgnBox(HWND hWnd, RECT *Rect);
+IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECT *Rect);
BOOL FASTCALL
IntGetWindowInfo(PWINDOW_OBJECT WindowObject, PWINDOWINFO pwi);
DWORD IntAddWndProcHandle(WNDPROC WindowProc, BOOL IsUnicode);
BOOL FASTCALL
-IntShowOwnedPopups( HWND owner, BOOL fShow );
+IntShowOwnedPopups( PWINDOW_OBJECT owner, BOOL fShow );
#endif /* _WIN32K_WINDOW_H */
BOOL FASTCALL
IntGetClientOrigin(PWINDOW_OBJECT Window, LPPOINT Point);
LRESULT FASTCALL
-co_WinPosGetNonClientSize(HWND Wnd, RECT* WindowRect, RECT* ClientRect);
+co_WinPosGetNonClientSize(PWINDOW_OBJECT Window, RECT* WindowRect, RECT* ClientRect);
UINT FASTCALL
co_WinPosGetMinMaxInfo(PWINDOW_OBJECT Window, POINT* MaxSize, POINT* MaxPos,
POINT* MinTrack, POINT* MaxTrack);
struct _DESKTOP_OBJECT* ActiveDesktop;
/* FIXME: Clipboard */
LIST_ENTRY HotKeyListHead;
- FAST_MUTEX HotKeyListLock;
} WINSTATION_OBJECT, *PWINSTATION_OBJECT;
extern WINSTATION_OBJECT *InputWindowStation;
static
PACCELERATOR_TABLE FASTCALL UserGetAccelObject(HACCEL hAccel)
{
- PACCELERATOR_TABLE Accel= UserGetObject(&gHandleTable, hAccel, otAccel);
+ PACCELERATOR_TABLE Accel;
+
+ if (!hAccel) return NULL;
+
+ Accel= UserGetObject(&gHandleTable, hAccel, otAccel);
if (Accel)
{
mesg = 1;
else if (IntGetCaptureWindow())
mesg = 2;
- else if (!IntIsWindowVisible(Window->hSelf)) /* FIXME: WINE IsWindowEnabled == IntIsWindowVisible? */
+ else if (!IntIsWindowVisible(Window)) /* FIXME: WINE IsWindowEnabled == IntIsWindowVisible? */
mesg = 3;
else
{
int nWidth,
int nHeight)
{
- PWINDOW_OBJECT WindowObject;
+ PWINDOW_OBJECT Window;
PUSER_MESSAGE_QUEUE ThreadQueue;
DECLARE_RETURN(BOOL);
DPRINT("Enter NtUserCreateCaret\n");
UserEnterExclusive();
- WindowObject = IntGetWindowObject(hWnd);
- if(!WindowObject)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_HANDLE);
RETURN(FALSE);
}
- if(WindowObject->OwnerThread != PsGetCurrentThread())
+ if(Window->OwnerThread != PsGetCurrentThread())
{
- IntReleaseWindowObject(WindowObject);
SetLastWin32Error(ERROR_ACCESS_DENIED);
RETURN(FALSE);
}
ThreadQueue->CaretInfo->Visible = 0;
ThreadQueue->CaretInfo->Showing = 0;
- IntReleaseWindowObject(WindowObject);
-
RETURN(TRUE);
CLEANUP:
DECLARE_RETURN(UINT);
DPRINT("Enter NtUserGetCaretBlinkTime\n");
- UserEnterExclusive();
+ UserEnterShared();
RETURN(IntGetCaretBlinkTime());
}
-BOOL FASTCALL co_UserHideCaret(PWINDOW_OBJECT WindowObject)
+BOOL FASTCALL co_UserHideCaret(PWINDOW_OBJECT Window)
{
PUSER_MESSAGE_QUEUE ThreadQueue;
- if(WindowObject->OwnerThread != PsGetCurrentThread())
+ if(Window->OwnerThread != PsGetCurrentThread())
{
SetLastWin32Error(ERROR_ACCESS_DENIED);
return FALSE;
ThreadQueue = (PUSER_MESSAGE_QUEUE)PsGetWin32Thread()->MessageQueue;
- if(ThreadQueue->CaretInfo->hWnd != WindowObject->hSelf)
+ if(ThreadQueue->CaretInfo->hWnd != Window->hSelf)
{
SetLastWin32Error(ERROR_ACCESS_DENIED);
return FALSE;
if(ThreadQueue->CaretInfo->Visible)
{
- IntKillTimer(WindowObject->hSelf, IDCARETTIMER, TRUE);
+ IntKillTimer(Window->hSelf, IDCARETTIMER, TRUE);
co_IntHideCaret(ThreadQueue->CaretInfo);
ThreadQueue->CaretInfo->Visible = 0;
NtUserHideCaret(
HWND hWnd)
{
- PWINDOW_OBJECT WindowObject;
+ PWINDOW_OBJECT Window;
DECLARE_RETURN(BOOL);
BOOL ret;
DPRINT("Enter NtUserHideCaret\n");
UserEnterExclusive();
- WindowObject = IntGetWindowObject(hWnd);
- if(!WindowObject)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN(FALSE);
}
- ret = co_UserHideCaret(WindowObject);
- IntReleaseWindowObject(WindowObject);
+ UserRefObjectCo(Window);
+ ret = co_UserHideCaret(Window);
+ UserDerefObjectCo(Window);
RETURN(ret);
NtUserShowCaret(
HWND hWnd)
{
- PWINDOW_OBJECT WindowObject;
+ PWINDOW_OBJECT Window;
DECLARE_RETURN(BOOL);
BOOL ret;
DPRINT("Enter NtUserShowCaret\n");
UserEnterExclusive();
- WindowObject = IntGetWindowObject(hWnd);
- if(!WindowObject)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN(FALSE);
}
- ret = co_UserShowCaret(WindowObject);
- IntReleaseWindowObject(WindowObject);
+ UserRefObjectCo(Window);
+ ret = co_UserShowCaret(Window);
+ UserDerefObjectCo(Window);
+
RETURN(ret);
CLEANUP:
LPWSTR lpClassName,
ULONG nMaxCount)
{
- PWINDOW_OBJECT WindowObject;
- LONG Length;
+ PWINDOW_OBJECT Window;
DECLARE_RETURN(DWORD);
UserEnterShared();
+ DPRINT("Enter NtUserGetClassName\n");
- WindowObject = IntGetWindowObject(hWnd);
- if (WindowObject == NULL)
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN(0);
}
- Length = IntGetClassName(WindowObject, lpClassName, nMaxCount);
- IntReleaseWindowObject(WindowObject);
- RETURN(Length);
+
+ RETURN( IntGetClassName(Window, lpClassName, nMaxCount));
CLEANUP:
DPRINT("Leave NtUserGetClassName, ret=%i\n",_ret_);
}
-
-
-/* temp hack */
-PCURICON_OBJECT FASTCALL UserGetCurIconObject(HANDLE hWnd)
+#if 0
+static
+PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCursor)
{
- PCURICON_OBJECT Window = (PCURICON_OBJECT)UserGetObject(&gHandleTable, hWnd, otCursor);
- if (!Window)
+ PCURICON_OBJECT Cursor;
+
+ if (!hCursor) return NULL;
+
+ Cursor = (PCURICON_OBJECT)UserGetObject(&gHandleTable, hCursor, otCursor);
+ if (!Cursor)
{
SetLastWin32Error(ERROR_INVALID_CURSOR_HANDLE);
return NULL;
}
- ASSERT(USER_BODY_TO_HEADER(Window)->RefCount >= 0);
- return Window;
+ ASSERT(USER_BODY_TO_HEADER(Cursor)->RefCount >= 0);
+ return Cursor;
}
-
-PCURICON_OBJECT FASTCALL
-IntGetCurIconObject(HANDLE Handle)
+#endif
+static
+PCURICON_OBJECT FASTCALL IntGetCurIconObject(HCURSOR hCursor)
{
- PCURICON_OBJECT ci = UserGetCurIconObject(Handle);
- if (ci)
+ PCURICON_OBJECT Cursor;
+
+ if (!hCursor) return NULL;
+
+ Cursor = (PCURICON_OBJECT)UserGetObject(&gHandleTable, hCursor, otCursor);
+ if (!Cursor)
{
- ASSERT(USER_BODY_TO_HEADER(ci)->RefCount >= 0);
-
- USER_BODY_TO_HEADER(ci)->RefCount++;
+ SetLastWin32Error(ERROR_INVALID_CURSOR_HANDLE);
+ return NULL;
}
- return ci;
+
+ ASSERT(USER_BODY_TO_HEADER(Cursor)->RefCount >= 0);
+
+ USER_BODY_TO_HEADER(Cursor)->RefCount++;
+
+ return Cursor;
}
+
+
#define COLORCURSORS_ALLOWED FALSE
HCURSOR FASTCALL
IntSetCursor(PWINSTATION_OBJECT WinStaObject, PCURICON_OBJECT NewCursor,
return hWndPrev;
}
+static
HWND FASTCALL
-co_IntSetFocusWindow(HWND hWnd)
+co_IntSetFocusWindow(PWINDOW_OBJECT Window)
{
HWND hWndPrev = 0;
PUSER_MESSAGE_QUEUE ThreadQueue;
+ ASSERT_REFS_CO(Window);
+
ThreadQueue = (PUSER_MESSAGE_QUEUE)PsGetWin32Thread()->MessageQueue;
ASSERT(ThreadQueue != 0);
hWndPrev = ThreadQueue->FocusWindow;
- if (hWndPrev == hWnd)
+ if (hWndPrev == Window->hSelf)
{
return hWndPrev;
}
- ThreadQueue->FocusWindow = hWnd;
+ ThreadQueue->FocusWindow = Window->hSelf;
- co_IntSendKillFocusMessages(hWndPrev, hWnd);
- co_IntSendSetFocusMessages(hWndPrev, hWnd);
+ co_IntSendKillFocusMessages(hWndPrev, Window->hSelf);
+ co_IntSendSetFocusMessages(hWndPrev, Window->hSelf);
return hWndPrev;
}
-HWND FASTCALL UserSetFocus(HWND hWnd)
+HWND FASTCALL co_UserSetFocus(PWINDOW_OBJECT Window OPTIONAL)
{
- if (hWnd)
+ if (Window)
{
- PWINDOW_OBJECT Window;
PUSER_MESSAGE_QUEUE ThreadQueue;
HWND hWndPrev, hWndTop;
- if (!(Window = UserGetWindowObject(hWnd)))
- {
- return( 0);
- }
+ ASSERT_REFS_CO(Window);
ThreadQueue = (PUSER_MESSAGE_QUEUE)PsGetWin32Thread()->MessageQueue;
return( 0);
}
- hWndTop = UserGetAncestor(hWnd, GA_ROOT);
+ hWndTop = UserGetAncestor(Window->hSelf, GA_ROOT);
if (hWndTop != UserGetActiveWindow())
{
- PWINDOW_OBJECT WndTops = IntGetWindowObject(hWndTop);
+ PWINDOW_OBJECT WndTops = UserGetWindowObject(hWndTop);
+
+ UserRefObjectCo(WndTops);
co_IntSetActiveWindow(WndTops);
- IntReleaseWindowObject(WndTops);//temp hack
+ UserDerefObjectCo(WndTops);
}
- hWndPrev = co_IntSetFocusWindow(hWnd);
+ hWndPrev = co_IntSetFocusWindow(Window);
return( hWndPrev);
}
HWND STDCALL
NtUserSetFocus(HWND hWnd)
{
+ PWINDOW_OBJECT Window;
DECLARE_RETURN(HWND);
+ HWND ret;
DPRINT("Enter NtUserSetFocus(%x)\n", hWnd);
UserEnterExclusive();
- RETURN(UserSetFocus(hWnd));
+ if (!(Window = UserGetWindowObject(hWnd)))
+ {
+ RETURN(NULL);
+ }
+
+ UserRefObjectCo(Window);
+ ret = co_UserSetFocus(Window);
+ UserDerefObjectCo(Window);
+
+ RETURN(ret);
CLEANUP:
DPRINT("Leave NtUserSetFocus, ret=%i\n",_ret_);
InitHotKeys(PWINSTATION_OBJECT WinStaObject)
{
InitializeListHead(&WinStaObject->HotKeyListHead);
- ExInitializeFastMutex(&WinStaObject->HotKeyListLock);
return STATUS_SUCCESS;
}
return FALSE;
}
- IntLockHotKeys(WinStaObject);
-
Entry = WinStaObject->HotKeyListHead.Flink;
while (Entry != &WinStaObject->HotKeyListHead)
{
if (id != NULL)
*id = HotKeyItem->id;
- IntUnLockHotKeys(WinStaObject);
return TRUE;
}
Entry = Entry->Flink;
}
- IntUnLockHotKeys(WinStaObject);
-
return FALSE;
}
if(!WinStaObject)
return;
- IntLockHotKeys(WinStaObject);
-
Entry = WinStaObject->HotKeyListHead.Flink;
while (Entry != &WinStaObject->HotKeyListHead)
{
}
}
- IntUnLockHotKeys(WinStaObject);
}
if(!WinStaObject)
return;
- IntLockHotKeys(WinStaObject);
-
Entry = WinStaObject->HotKeyListHead.Flink;
while (Entry != &WinStaObject->HotKeyListHead)
{
}
}
- IntUnLockHotKeys(WinStaObject);
}
}
else
{
- Window = IntGetWindowObject(hWnd);
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( FALSE);
}
HotKeyThread = Window->OwnerThread;
- IntReleaseWindowObject(Window);
}
RETURN( FALSE);
}
- IntLockHotKeys(WinStaObject);
-
/* Check for existing hotkey */
if (IsHotKey (WinStaObject, fsModifiers, vk))
{
- IntUnLockHotKeys(WinStaObject);
RETURN( FALSE);
}
HotKeyItem = ExAllocatePoolWithTag (PagedPool, sizeof(HOT_KEY_ITEM), TAG_HOTKEY);
if (HotKeyItem == NULL)
{
- IntUnLockHotKeys(WinStaObject);
RETURN( FALSE);
}
InsertHeadList (&WinStaObject->HotKeyListHead,
&HotKeyItem->ListEntry);
- IntUnLockHotKeys(WinStaObject);
-
RETURN( TRUE);
CLEANUP:
DPRINT("Enter NtUserUnregisterHotKey\n");
UserEnterExclusive();
- Window = IntGetWindowObject(hWnd);
- if(!Window)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( FALSE);
}
if(!WinStaObject)
{
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
- IntLockHotKeys(WinStaObject);
-
Entry = WinStaObject->HotKeyListHead.Flink;
while (Entry != &WinStaObject->HotKeyListHead)
{
{
RemoveEntryList (&HotKeyItem->ListEntry);
ExFreePool (HotKeyItem);
- IntUnLockHotKeys(WinStaObject);
- IntReleaseWindowObject(Window);
RETURN( TRUE);
}
Entry = Entry->Flink;
}
- IntUnLockHotKeys(WinStaObject);
-
- IntReleaseWindowObject(Window);
RETURN( FALSE);
CLEANUP:
#define NDEBUG
#include <debug.h>
-extern BYTE QueueKeyStateTable[];
+extern BYTE gQueueKeyStateTable[];
/* GLOBALS *******************************************************************/
PWINDOW_OBJECT Window;
MSG Mesg;
- if (!(Window = IntGetWindowObject(InputWindowStation->ShellWindow)))
+ if (!(Window = UserGetWindowObject(InputWindowStation->ShellWindow)))
{
DPRINT1("Couldn't find window to send Windows key message!\n");
return;
/* The QS_HOTKEY is just a guess */
MsqPostMessage(Window->MessageQueue, &Mesg, FALSE, QS_HOTKEY);
-
- ObmDereferenceObject(Window);
}
STATIC VOID STDCALL
Msg.message = 0;
if(mi->dwFlags & MOUSEEVENTF_LEFTDOWN)
{
- QueueKeyStateTable[VK_LBUTTON] |= 0xc0;
+ gQueueKeyStateTable[VK_LBUTTON] |= 0xc0;
Msg.message = SwapBtnMsg[0][SwapButtons];
CurInfo->ButtonsDown |= SwapBtn[SwapButtons];
MsqInsertSystemMessage(&Msg);
}
else if(mi->dwFlags & MOUSEEVENTF_LEFTUP)
{
- QueueKeyStateTable[VK_LBUTTON] &= ~0x80;
+ gQueueKeyStateTable[VK_LBUTTON] &= ~0x80;
Msg.message = SwapBtnMsg[1][SwapButtons];
CurInfo->ButtonsDown &= ~SwapBtn[SwapButtons];
MsqInsertSystemMessage(&Msg);
}
if(mi->dwFlags & MOUSEEVENTF_MIDDLEDOWN)
{
- QueueKeyStateTable[VK_MBUTTON] |= 0xc0;
+ gQueueKeyStateTable[VK_MBUTTON] |= 0xc0;
Msg.message = WM_MBUTTONDOWN;
CurInfo->ButtonsDown |= MK_MBUTTON;
MsqInsertSystemMessage(&Msg);
}
else if(mi->dwFlags & MOUSEEVENTF_MIDDLEUP)
{
- QueueKeyStateTable[VK_MBUTTON] &= ~0x80;
+ gQueueKeyStateTable[VK_MBUTTON] &= ~0x80;
Msg.message = WM_MBUTTONUP;
CurInfo->ButtonsDown &= ~MK_MBUTTON;
MsqInsertSystemMessage(&Msg);
}
if(mi->dwFlags & MOUSEEVENTF_RIGHTDOWN)
{
- QueueKeyStateTable[VK_RBUTTON] |= 0xc0;
+ gQueueKeyStateTable[VK_RBUTTON] |= 0xc0;
Msg.message = SwapBtnMsg[0][!SwapButtons];
CurInfo->ButtonsDown |= SwapBtn[!SwapButtons];
MsqInsertSystemMessage(&Msg);
}
else if(mi->dwFlags & MOUSEEVENTF_RIGHTUP)
{
- QueueKeyStateTable[VK_RBUTTON] &= ~0x80;
+ gQueueKeyStateTable[VK_RBUTTON] &= ~0x80;
Msg.message = SwapBtnMsg[1][!SwapButtons];
CurInfo->ButtonsDown &= ~SwapBtn[!SwapButtons];
MsqInsertSystemMessage(&Msg);
Msg.message = WM_XBUTTONDOWN;
if(mi->mouseData & XBUTTON1)
{
- QueueKeyStateTable[VK_XBUTTON1] |= 0xc0;
+ gQueueKeyStateTable[VK_XBUTTON1] |= 0xc0;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON1);
CurInfo->ButtonsDown |= XBUTTON1;
MsqInsertSystemMessage(&Msg);
}
if(mi->mouseData & XBUTTON2)
{
- QueueKeyStateTable[VK_XBUTTON2] |= 0xc0;
+ gQueueKeyStateTable[VK_XBUTTON2] |= 0xc0;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON2);
CurInfo->ButtonsDown |= XBUTTON2;
MsqInsertSystemMessage(&Msg);
Msg.message = WM_XBUTTONUP;
if(mi->mouseData & XBUTTON1)
{
- QueueKeyStateTable[VK_XBUTTON1] &= ~0x80;
+ gQueueKeyStateTable[VK_XBUTTON1] &= ~0x80;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON1);
CurInfo->ButtonsDown &= ~XBUTTON1;
MsqInsertSystemMessage(&Msg);
}
if(mi->mouseData & XBUTTON2)
{
- QueueKeyStateTable[VK_XBUTTON2] &= ~0x80;
+ gQueueKeyStateTable[VK_XBUTTON2] &= ~0x80;
Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON2);
CurInfo->ButtonsDown &= ~XBUTTON2;
MsqInsertSystemMessage(&Msg);
/* From kbdxx.c -- Key changes with numlock */
#define KNUMP 0x400
-/* Lock the keyboard state to prevent unusual concurrent access */
-FAST_MUTEX QueueStateLock;
-BYTE QueueKeyStateTable[256];
+BYTE gQueueKeyStateTable[256];
-#define IntLockQueueState \
- ExAcquireFastMutex(&QueueStateLock)
-
-#define IntUnLockQueueState \
- ExReleaseFastMutex(&QueueStateLock)
/* FUNCTIONS *****************************************************************/
/* Initialization -- Right now, just zero the key state and init the lock */
NTSTATUS FASTCALL InitKeyboardImpl(VOID)
{
- ExInitializeFastMutex(&QueueStateLock);
- RtlZeroMemory(&QueueKeyStateTable,0x100);
+ RtlZeroMemory(&gQueueKeyStateTable,0x100);
return STATUS_SUCCESS;
}
if (vk == VK_CAPITAL || vk == VK_NUMLOCK)
{
if (down)
- QueueKeyStateTable[vk] ^= KS_LOCK_BIT;
+ gQueueKeyStateTable[vk] ^= KS_LOCK_BIT;
}
if (ext && vk == VK_LSHIFT)
vk = VK_RMENU;
if (down)
- QueueKeyStateTable[vk] |= KS_DOWN_BIT;
+ gQueueKeyStateTable[vk] |= KS_DOWN_BIT;
else
- QueueKeyStateTable[vk] &= ~KS_DOWN_MASK;
+ gQueueKeyStateTable[vk] &= ~KS_DOWN_MASK;
if (vk == VK_LSHIFT || vk == VK_RSHIFT)
{
- if ((QueueKeyStateTable[VK_LSHIFT] & KS_DOWN_BIT) ||
- (QueueKeyStateTable[VK_RSHIFT] & KS_DOWN_BIT))
+ if ((gQueueKeyStateTable[VK_LSHIFT] & KS_DOWN_BIT) ||
+ (gQueueKeyStateTable[VK_RSHIFT] & KS_DOWN_BIT))
{
- QueueKeyStateTable[VK_SHIFT] |= KS_DOWN_BIT;
+ gQueueKeyStateTable[VK_SHIFT] |= KS_DOWN_BIT;
}
else
{
- QueueKeyStateTable[VK_SHIFT] &= ~KS_DOWN_MASK;
+ gQueueKeyStateTable[VK_SHIFT] &= ~KS_DOWN_MASK;
}
}
if (vk == VK_LCONTROL || vk == VK_RCONTROL)
{
- if ((QueueKeyStateTable[VK_LCONTROL] & KS_DOWN_BIT) ||
- (QueueKeyStateTable[VK_RCONTROL] & KS_DOWN_BIT))
+ if ((gQueueKeyStateTable[VK_LCONTROL] & KS_DOWN_BIT) ||
+ (gQueueKeyStateTable[VK_RCONTROL] & KS_DOWN_BIT))
{
- QueueKeyStateTable[VK_CONTROL] |= KS_DOWN_BIT;
+ gQueueKeyStateTable[VK_CONTROL] |= KS_DOWN_BIT;
}
else
{
- QueueKeyStateTable[VK_CONTROL] &= ~KS_DOWN_MASK;
+ gQueueKeyStateTable[VK_CONTROL] &= ~KS_DOWN_MASK;
}
}
if (vk == VK_LMENU || vk == VK_RMENU)
{
- if ((QueueKeyStateTable[VK_LMENU] & KS_DOWN_BIT) ||
- (QueueKeyStateTable[VK_RMENU] & KS_DOWN_BIT))
+ if ((gQueueKeyStateTable[VK_LMENU] & KS_DOWN_BIT) ||
+ (gQueueKeyStateTable[VK_RMENU] & KS_DOWN_BIT))
{
- QueueKeyStateTable[VK_MENU] |= KS_DOWN_BIT;
+ gQueueKeyStateTable[VK_MENU] |= KS_DOWN_BIT;
}
else
{
- QueueKeyStateTable[VK_MENU] &= ~KS_DOWN_MASK;
+ gQueueKeyStateTable[VK_MENU] &= ~KS_DOWN_MASK;
}
}
}
{
DWORD ret = 0;
- IntLockQueueState;
if( key < 0x100 )
{
- ret = ((DWORD)(QueueKeyStateTable[key] & KS_DOWN_BIT) << 8 ) |
- (QueueKeyStateTable[key] & KS_LOCK_BIT);
+ ret = ((DWORD)(gQueueKeyStateTable[key] & KS_DOWN_BIT) << 8 ) |
+ (gQueueKeyStateTable[key] & KS_LOCK_BIT);
}
- IntUnLockQueueState;
+
return ret;
}
{
DWORD ret = 0;
- IntLockQueueState;
if( key < 0x100 )
{
- ret = ((DWORD)(QueueKeyStateTable[key] & KS_DOWN_BIT) << 8 ) |
- (QueueKeyStateTable[key] & KS_LOCK_BIT);
+ ret = ((DWORD)(gQueueKeyStateTable[key] & KS_DOWN_BIT) << 8 ) |
+ (gQueueKeyStateTable[key] & KS_LOCK_BIT);
}
- IntUnLockQueueState;
+
return ret;
}
}
else
{
- IntLockQueueState;
ToUnicodeResult = ToUnicodeInner( wVirtKey,
wScanCode,
lpKeyState,
wFlags,
PsGetWin32Thread() ?
PsGetWin32Thread()->KeyboardLayout : 0 );
- IntUnLockQueueState;
}
return ToUnicodeResult;
{
return ToUnicodeEx( wVirtKey,
wScanCode,
- QueueKeyStateTable,
+ gQueueKeyStateTable,
pwszBuff,
cchBuff,
wFlags,
ScanCode = (lpMsg->lParam >> 16) & 0xff;
- IntLockQueueState;
-
/* All messages have to contain the cursor point. */
IntGetCursorLocation(PsGetWin32Thread()->Desktop->WindowStation,
&NewMsg.pt);
UState = ToUnicodeInner(lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff,
- QueueKeyStateTable, wp, 2, 0,
+ gQueueKeyStateTable, wp, 2, 0,
keyLayout );
if (UState == 1)
Result = TRUE;
}
- IntUnLockQueueState;
return Result;
}
LPBYTE lpKeyState)
{
BOOL Result = TRUE;
-
- IntLockQueueState;
+ DECLARE_RETURN(DWORD);
+
+ DPRINT("Enter NtUserGetKeyboardState\n");
+ UserEnterShared();
+
if (lpKeyState)
{
- if(!NT_SUCCESS(MmCopyToCaller(lpKeyState, QueueKeyStateTable, 256)))
+ if(!NT_SUCCESS(MmCopyToCaller(lpKeyState, gQueueKeyStateTable, 256)))
Result = FALSE;
}
- IntUnLockQueueState;
- return Result;
+
+ RETURN(Result);
+
+CLEANUP:
+ DPRINT("Leave NtUserGetKeyboardState, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
DWORD
STDCALL
-NtUserSetKeyboardState(
- LPBYTE lpKeyState)
+NtUserSetKeyboardState(LPBYTE lpKeyState)
{
BOOL Result = TRUE;
+ DECLARE_RETURN(DWORD);
+
+ DPRINT("Enter NtUserSetKeyboardState\n");
+ UserEnterExclusive();
- IntLockQueueState;
if (lpKeyState)
{
- if(! NT_SUCCESS(MmCopyFromCaller(QueueKeyStateTable, lpKeyState, 256)))
+ if(! NT_SUCCESS(MmCopyFromCaller(gQueueKeyStateTable, lpKeyState, 256)))
Result = FALSE;
}
- IntUnLockQueueState;
+
+ RETURN(Result);
- return Result;
+CLEANUP:
+ DPRINT("Leave NtUserSetKeyboardState, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
static UINT VkToScan( UINT Code, BOOL ExtCode, PKBDTABLES pkKT )
STDCALL
NtUserMapVirtualKeyEx( UINT Code, UINT Type, DWORD keyboardId, HKL dwhkl )
{
- PKBDTABLES keyLayout = PsGetWin32Thread() ?
- PsGetWin32Thread()->KeyboardLayout : 0;
+ PKBDTABLES keyLayout;
+ DECLARE_RETURN(UINT);
+
+ DPRINT("Enter NtUserMapVirtualKeyEx\n");
+ UserEnterExclusive();
+
+ keyLayout = PsGetWin32Thread() ? PsGetWin32Thread()->KeyboardLayout : 0;
if( !keyLayout )
- return 0;
+ RETURN(0);
- return IntMapVirtualKeyEx( Code, Type, keyLayout );
+ RETURN(IntMapVirtualKeyEx( Code, Type, keyLayout ));
+
+CLEANUP:
+ DPRINT("Leave NtUserMapVirtualKeyEx, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
BYTE KeyStateBuf[0x100];
PWCHAR OutPwszBuff = 0;
int ret = 0;
+ DECLARE_RETURN(int);
+
+ DPRINT("Enter NtUserSetKeyboardState\n");
+ UserEnterShared();//faxme: this syscall doesnt seem to need any locking...
if( !NT_SUCCESS(MmCopyFromCaller(KeyStateBuf,
sizeof(KeyStateBuf))) )
{
DPRINT1( "Couldn't copy key state from caller.\n" );
- return 0;
+ RETURN(0);
}
OutPwszBuff = ExAllocatePoolWithTag(NonPagedPool,sizeof(WCHAR) * cchBuff, TAG_STRING);
if( !OutPwszBuff )
{
DPRINT1( "ExAllocatePool(%d) failed\n", sizeof(WCHAR) * cchBuff);
- return 0;
+ RETURN(0);
}
RtlZeroMemory( OutPwszBuff, sizeof( WCHAR ) * cchBuff );
MmCopyToCaller(pwszBuff,OutPwszBuff,sizeof(WCHAR)*cchBuff);
ExFreePool(OutPwszBuff);
- return ret;
+ RETURN(ret);
+
+CLEANUP:
+ DPRINT("Leave NtUserSetKeyboardState, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
static int W32kSimpleToupper( int ch )
UINT VkCode = 0;
UINT ScanCode = (lParam >> 16) & 0xff;
BOOL ExtKey = lParam & (1<<24) ? TRUE : FALSE;
- PKBDTABLES keyLayout =
- PsGetWin32Thread() ?
+ PKBDTABLES keyLayout;
+ DECLARE_RETURN(DWORD);
+
+ DPRINT("Enter NtUserGetKeyNameText\n");
+ UserEnterShared();
+
+ keyLayout = PsGetWin32Thread() ?
PsGetWin32Thread()->KeyboardLayout : 0;
if( !keyLayout || nSize < 1 )
- return 0;
+ RETURN(0);
if( lParam & (1<<25) )
{
ret = 1;
if( !NT_SUCCESS(MmCopyToCaller( lpString, UCName, 2 * sizeof(WCHAR) )) )
- return 0;
+ RETURN(0);
}
- return ret;
+ RETURN(ret);
+
+CLEANUP:
+ DPRINT("Leave NtUserGetKeyNameText, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
/*
return;
}
- IntLockQueueState;
-
/* arty -- handle numpad -- On real windows, the actual key produced
* by the messaging layer is different based on the state of numlock. */
- ModifierBits = ModBits(KeyboardLayout,QueueKeyStateTable);
+ ModifierBits = ModBits(KeyboardLayout,gQueueKeyStateTable);
/* Get the raw scan code, so we can look up whether the key is a numpad
* key
/* ignore shift codes */
if( ScanCode == 0x2A || ScanCode == 0x36 )
{
- IntUnLockQueueState;
return;
}
VscVkTable = KeyboardLayout->pVSCtoVK_E0;
}
/* We need to unset SYSKEYDOWN if the ALT key is an ALT+Gr */
- if( QueueKeyStateTable[VK_RMENU] & KS_DOWN_BIT )
+ if( gQueueKeyStateTable[VK_RMENU] & KS_DOWN_BIT )
{
if( Msg->message == WM_SYSKEYDOWN )
Msg->message = WM_KEYDOWN;
Msg->message = WM_KEYUP;
}
- IntUnLockQueueState;
}
DWORD
NtUserGetKeyboardType(
DWORD TypeFlag)
{
- return UserGetKeyboardType(TypeFlag);
+ DECLARE_RETURN(DWORD);
+
+ DPRINT("Enter NtUserGetKeyboardType\n");
+ UserEnterShared();
+
+ RETURN( UserGetKeyboardType(TypeFlag));
+
+CLEANUP:
+ DPRINT("Leave NtUserGetKeyboardType, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
DWORD KeyboardLayout,
DWORD Unknown2)
{
+/* FAXME: currently, this routine doesnt seem to need any locking */
+
PKBDTABLES KeyLayout;
PVK_TO_WCHAR_TABLE vtwTbl;
PVK_TO_WCHARS10 vkPtr;
if(bRecurse && MenuItem->hSubMenu)
{
PMENU_OBJECT SubMenu;
- SubMenu = IntGetMenuObject(MenuItem->hSubMenu );
+ SubMenu = UserGetMenuObject(MenuItem->hSubMenu );
if(SubMenu)
{
IntDestroyMenuObject(SubMenu, bRecurse, TRUE);
- IntReleaseMenuObject(SubMenu);
}
}
{
PMENU_OBJECT Menu;
- if((Menu = IntGetMenuObject(hMenu)))
+ if((Menu = UserGetMenuObject(hMenu)))
{
- IntReleaseMenuObject(Menu);
return TRUE;
}
return FALSE;
/* Make sure the submenu is marked as a popup menu */
if (MenuItem->hSubMenu)
{
- SubMenuObject = IntGetMenuObject(MenuItem->hSubMenu);
+ SubMenuObject = UserGetMenuObject(MenuItem->hSubMenu);
if (SubMenuObject != NULL)
{
SubMenuObject->MenuInfo.Flags |= MF_POPUP;
MenuItem->fType |= MF_POPUP;
- IntReleaseMenuObject(SubMenuObject);
}
else
{
MenuItem->hSubMenu)
{
- SubMenuObject = IntGetMenuObject(MenuItem->hSubMenu);
+ SubMenuObject = UserGetMenuObject(MenuItem->hSubMenu);
if(!SubMenuObject || (SubMenuObject == MenuObject))
break;
sres = IntGetMenuDefaultItem(SubMenuObject, fByPos, gmdiFlags, gismc);
(*gismc)--;
- IntReleaseMenuObject(SubMenuObject);
-
if(sres > (UINT)-1)
res = sres;
}
DWORD Reserved)
{
DWORD res = -1;
- PMENU_OBJECT MenuObject;
+ PMENU_OBJECT Menu;
DECLARE_RETURN(DWORD);
DPRINT("Enter NtUserBuildMenuItemList\n");
UserEnterExclusive();
- MenuObject = IntGetMenuObject(hMenu);
- if(!MenuObject)
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
RETURN( (DWORD)-1);
}
if(Buffer)
{
- res = IntBuildMenuItemList(MenuObject, Buffer, nBufSize);
+ res = IntBuildMenuItemList(Menu, Buffer, nBufSize);
}
else
{
- res = MenuObject->MenuInfo.MenuItemCount;
+ res = Menu->MenuInfo.MenuItemCount;
}
- IntReleaseMenuObject(MenuObject);
-
RETURN( res);
CLEANUP:
*/
DWORD STDCALL
NtUserCheckMenuItem(
- HMENU hmenu,
+ HMENU hMenu,
UINT uIDCheckItem,
UINT uCheck)
{
- DWORD res = 0;
- PMENU_OBJECT MenuObject;
+ PMENU_OBJECT Menu;
DECLARE_RETURN(DWORD);
DPRINT("Enter NtUserCheckMenuItem\n");
UserEnterExclusive();
- MenuObject = IntGetMenuObject(hmenu);
- if(!MenuObject)
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
RETURN( (DWORD)-1);
}
- res = IntCheckMenuItem(MenuObject, uIDCheckItem, uCheck);
-
- IntReleaseMenuObject(MenuObject);
- RETURN( res);
+ RETURN( IntCheckMenuItem(Menu, uIDCheckItem, uCheck));
CLEANUP:
DPRINT("Leave NtUserCheckMenuItem, ret=%i\n",_ret_);
UINT uPosition,
UINT uFlags)
{
- BOOL res;
- PMENU_OBJECT MenuObject;
+ PMENU_OBJECT Menu;
DECLARE_RETURN(BOOL);
DPRINT("Enter NtUserDeleteMenu\n");
UserEnterExclusive();
- MenuObject = IntGetMenuObject(hMenu);
- if(!MenuObject)
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
RETURN( FALSE);
}
- res = IntRemoveMenuItem(MenuObject, uPosition, uFlags, TRUE);
- IntReleaseMenuObject(MenuObject);
-
- RETURN( res);
+ RETURN( IntRemoveMenuItem(Menu, uPosition, uFlags, TRUE));
CLEANUP:
DPRINT("Leave NtUserDeleteMenu, ret=%i\n",_ret_);
*/
BOOL FASTCALL UserDestroyMenu(HMENU hMenu)
{
- BOOL Ret;
-
- PMENU_OBJECT MenuObject = IntGetMenuObject(hMenu);
- if(!MenuObject)
+ PMENU_OBJECT Menu;
+
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
return FALSE;
}
- if(MenuObject->Process != PsGetCurrentProcess())
+
+ if(Menu->Process != PsGetCurrentProcess())
{
- IntReleaseMenuObject(MenuObject);
SetLastWin32Error(ERROR_ACCESS_DENIED);
return FALSE;
}
- Ret = IntDestroyMenuObject(MenuObject, FALSE, TRUE);
-
- IntReleaseMenuObject(MenuObject);
- return Ret;
+ return IntDestroyMenuObject(Menu, FALSE, TRUE);
}
/*
NtUserDestroyMenu(
HMENU hMenu)
{
- BOOL Ret;
+ PMENU_OBJECT Menu;
DECLARE_RETURN(BOOL);
DPRINT("Enter NtUserDestroyMenu\n");
UserEnterExclusive();
- PMENU_OBJECT MenuObject = IntGetMenuObject(hMenu);
- if(!MenuObject)
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
RETURN( FALSE);
}
- if(MenuObject->Process != PsGetCurrentProcess())
+
+ if(Menu->Process != PsGetCurrentProcess())
{
- IntReleaseMenuObject(MenuObject);
SetLastWin32Error(ERROR_ACCESS_DENIED);
RETURN( FALSE);
}
- Ret = IntDestroyMenuObject(MenuObject, FALSE, TRUE);
-
- IntReleaseMenuObject(MenuObject);
- RETURN( Ret);
+ RETURN( IntDestroyMenuObject(Menu, FALSE, TRUE));
CLEANUP:
DPRINT("Leave NtUserDestroyMenu, ret=%i\n",_ret_);
UINT uIDEnableItem,
UINT uEnable)
{
- UINT res = (UINT)-1;
- PMENU_OBJECT MenuObject;
+ PMENU_OBJECT Menu;
DECLARE_RETURN(UINT);
DPRINT("Enter NtUserEnableMenuItem\n");
UserEnterExclusive();
- MenuObject = IntGetMenuObject(hMenu);
- if(!MenuObject)
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
- RETURN( res);
+ RETURN(-1);
}
- res = IntEnableMenuItem(MenuObject, uIDEnableItem, uEnable);
-
- IntReleaseMenuObject(MenuObject);
-
- RETURN( res);
+ RETURN( IntEnableMenuItem(Menu, uIDEnableItem, uEnable));
CLEANUP:
DPRINT("Leave NtUserEnableMenuItem, ret=%i\n",_ret_);
BOOL fByPosition,
LPCMENUITEMINFOW UnsafeItemInfo)
{
- DWORD Res = 0;
- PMENU_OBJECT MenuObject;
+ PMENU_OBJECT Menu;
NTSTATUS Status;
ROSMENUITEMINFO ItemInfo;
DECLARE_RETURN(DWORD);
DPRINT("Enter NtUserInsertMenuItem\n");
UserEnterExclusive();
- MenuObject = IntGetMenuObject(hMenu);
- if(!MenuObject)
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
- RETURN( 0);
+ RETURN(0);
}
Status = MmCopyFromCaller(&ItemInfo, UnsafeItemInfo, sizeof(MENUITEMINFOW));
if (! NT_SUCCESS(Status))
{
- IntReleaseMenuObject(MenuObject);
SetLastNtError(Status);
RETURN( FALSE);
}
if (ItemInfo.cbSize != sizeof(MENUITEMINFOW))
{
- IntReleaseMenuObject(MenuObject);
SetLastWin32Error(ERROR_INVALID_PARAMETER);
RETURN( FALSE);
}
- Res = IntInsertMenuItem(MenuObject, uItem, fByPosition, &ItemInfo);
-
- IntReleaseMenuObject(MenuObject);
-
- RETURN( Res);
+ RETURN( IntInsertMenuItem(Menu, uItem, fByPosition, &ItemInfo));
CLEANUP:
DPRINT("Leave NtUserInsertMenuItem, ret=%i\n",_ret_);
*/
BOOL STDCALL
NtUserHiliteMenuItem(
- HWND hwnd,
- HMENU hmenu,
+ HWND hWnd,
+ HMENU hMenu,
UINT uItemHilite,
UINT uHilite)
{
- BOOL res = FALSE;
- PMENU_OBJECT MenuObject;
- PWINDOW_OBJECT WindowObject;
+ PMENU_OBJECT Menu;
+ PWINDOW_OBJECT Window;
DECLARE_RETURN(BOOLEAN);
DPRINT("Enter NtUserHiliteMenuItem\n");
UserEnterExclusive();
- WindowObject = IntGetWindowObject(hwnd);
- if(!WindowObject)
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_HANDLE);
- RETURN( res);
+ RETURN(FALSE);
}
- MenuObject = IntGetMenuObject(hmenu);
- if(!MenuObject)
+
+ if(!(Menu = UserGetMenuObject(hMenu)))
{
- IntReleaseWindowObject(WindowObject);
- SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
- RETURN( res);
+ RETURN(FALSE);
}
- if(WindowObject->IDMenu == (UINT)hmenu)
+
+ if(Window->IDMenu == (UINT)hMenu)
{
- res = IntHiliteMenuItem(WindowObject, MenuObject, uItemHilite, uHilite);
+ RETURN( IntHiliteMenuItem(Window, Menu, uItemHilite, uHilite));
}
- IntReleaseMenuObject(MenuObject);
- IntReleaseWindowObject(WindowObject);
- RETURN( res);
+
+ RETURN(FALSE);
CLEANUP:
DPRINT("Leave NtUserHiliteMenuItem, ret=%i\n",_ret_);
DECLARE_RETURN(ULONG);
DPRINT("Enter NtUserGetSystemMetrics\n");
- UserEnterExclusive();
+ UserEnterShared();
RETURN(UserGetSystemMetrics(Index));
{
DWORD Ret;
RECT rcRect;
- Ret = (DWORD)IntGetWindowRgnBox((HWND)Param1, &rcRect);
+ PWINDOW_OBJECT Window = UserGetWindowObject((HWND)Param1);
+ if (!Window) RETURN(ERROR);
+
+ Ret = (DWORD)IntGetWindowRgnBox(Window, &rcRect);
Status = MmCopyToCaller((PVOID)Param2, &rcRect, sizeof(RECT));
if(!NT_SUCCESS(Status))
{
}
case TWOPARAM_ROUTINE_GETWINDOWRGN:
{
- RETURN( (DWORD)IntGetWindowRgn((HWND)Param1, (HRGN)Param2));
+ PWINDOW_OBJECT Window = UserGetWindowObject((HWND)Param1);
+ if (!Window) RETURN(ERROR);
+
+ RETURN( (DWORD)IntGetWindowRgn(Window, (HRGN)Param2));
}
case TWOPARAM_ROUTINE_SETMENUBARHEIGHT:
{
RETURN( 0);
case TWOPARAM_ROUTINE_SHOWOWNEDPOPUPS:
- RETURN( (DWORD)IntShowOwnedPopups((HWND) Param1, (BOOL) Param2));
+ {
+ PWINDOW_OBJECT Window = UserGetWindowObject((HWND)Param1);
+ if (!Window) RETURN(0);
+
+ RETURN( (DWORD)IntShowOwnedPopups(Window, (BOOL) Param2));
+ }
case TWOPARAM_ROUTINE_ROS_SHOWWINDOW:
{
/* GLOBALS *******************************************************************/
/* list of monitors */
-static PMONITOR_OBJECT MonitorList = NULL;
-static FAST_MUTEX MonitorListLock; /* R/W lock for monitor list */
+static PMONITOR_OBJECT gMonitorList = NULL;
/* INITALIZATION FUNCTIONS ****************************************************/
InitMonitorImpl()
{
DPRINT("Initializing monitor implementation...\n");
- ExInitializeFastMutex(&MonitorListLock);
return STATUS_SUCCESS;
}
ObmDereferenceObject(pMonitor);
}
-/* IntGetMonitorObject
- *
- * Returns the MONITOR_OBJECT for the given monitor handle.
- *
- * Arguments
- *
- * hMonitor
- * Monitor handle for which to get the MONITOR_OBJECT
- *
- * Return value
- * Returns a pointer to a MONITOR_OBJECT on success and increase the
- * refcount of the monitor object; NULL on failure
- */
+
static
-PMONITOR_OBJECT
-IntGetMonitorObject(IN HMONITOR hMonitor)
+PMONITOR_OBJECT FASTCALL
+UserGetMonitorObject(IN HMONITOR hMonitor)
{
-
PMONITOR_OBJECT Monitor = (PMONITOR_OBJECT)UserGetObject(&gHandleTable, hMonitor, otMonitor);
if (!Monitor)
{
ASSERT(USER_BODY_TO_HEADER(Monitor)->RefCount >= 0);
- USER_BODY_TO_HEADER(Monitor)->RefCount++;
-
return Monitor;
}
-/* IntReleaseMonitorObject
- *
- * Releases the given MONITOR_OBJECT.
- *
- * Arguments
- *
- * pMonitor
- * MONITOR_OBJECT to be released
- */
-#define IntReleaseMonitorObject(MonitorObj) \
- ObmDereferenceObject(MonitorObj);
/* IntAttachMonitor
*
}
Monitor->GdiDevice = pGdiDevice;
- ExAcquireFastMutex(&MonitorListLock);
- if (MonitorList == NULL)
+ if (gMonitorList == NULL)
{
DPRINT("Primary monitor is beeing attached\n");
Monitor->IsPrimary = TRUE;
- MonitorList = Monitor;
+ gMonitorList = Monitor;
}
else
{
PMONITOR_OBJECT p;
DPRINT("Additional monitor is beeing attached\n");
- for (p = MonitorList; p->Next != NULL; p = p->Next)
+ for (p = gMonitorList; p->Next != NULL; p = p->Next)
;
{
p->Next = Monitor;
}
Monitor->Prev = p;
}
- ExReleaseFastMutex(&MonitorListLock);
return STATUS_SUCCESS;
}
{
PMONITOR_OBJECT Monitor;
- ExAcquireFastMutex(&MonitorListLock);
- for (Monitor = MonitorList; Monitor != NULL; Monitor = Monitor->Next)
+ for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{
if (Monitor->GdiDevice == pGdiDevice)
break;
if (Monitor == NULL)
{
/* no monitor for given device found */
- ExReleaseFastMutex(&MonitorListLock);
return STATUS_INVALID_PARAMETER;
}
ExReleaseFastMutex(&NewPrimaryMonitor->Lock);
}
- if (MonitorList == Monitor)
+ if (gMonitorList == Monitor)
{
- MonitorList = Monitor->Next;
+ gMonitorList = Monitor->Next;
if (Monitor->Next != NULL)
Monitor->Next->Prev = NULL;
}
if (Monitor->Next != NULL)
Monitor->Next->Prev = Monitor->Prev;
}
- ExReleaseFastMutex(&MonitorListLock);
IntDestroyMonitorObject(Monitor);
{
PMONITOR_OBJECT Monitor;
- ExAcquireFastMutex(&MonitorListLock);
- for (Monitor = MonitorList; Monitor != NULL; Monitor = Monitor->Next)
+ for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{
/* FIXME: I guess locking the monitor is not neccessary to read 1 int */
if (Monitor->IsPrimary)
break;
}
- ExReleaseFastMutex(&MonitorListLock);
return Monitor;
}
LONG iNearestDistanceX = 0x7fffffff, iNearestDistanceY = 0x7fffffff;
/* find monitors which intersect the rectangle */
- ExAcquireFastMutex(&MonitorListLock);
- for (Monitor = MonitorList; Monitor != NULL; Monitor = Monitor->Next)
+ for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{
RECT MonitorRect, IntersectionRect;
}
iCount++;
}
- ExReleaseFastMutex(&MonitorListLock);
if (iCount == 0 && flags == MONITOR_DEFAULTTONEAREST)
{
PMONITOR_OBJECT Monitor;
MONITORINFOEXW MonitorInfo;
NTSTATUS Status;
-
+ DECLARE_RETURN(BOOL);
+
+ DPRINT("Enter NtUserGetMonitorInfo\n");
+ UserEnterShared();
+
/* get monitor object */
- if ((Monitor = IntGetMonitorObject(hMonitor)) == NULL)
+ if (!(Monitor = UserGetMonitorObject(hMonitor)))
{
DPRINT("Couldnt find monitor 0x%lx\n", hMonitor);
- SetLastNtError(STATUS_INVALID_HANDLE);
- return FALSE;
+ RETURN(FALSE);
}
/* get size of pMonitorInfo */
Status = MmCopyFromCaller(&MonitorInfo.cbSize, &pMonitorInfo->cbSize, sizeof (MonitorInfo.cbSize));
if (!NT_SUCCESS(Status))
{
- IntReleaseMonitorObject(Monitor);
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
if ((MonitorInfo.cbSize != sizeof (MONITORINFO)) &&
(MonitorInfo.cbSize != sizeof (MONITORINFOEXW)))
{
SetLastNtError(STATUS_INVALID_PARAMETER);
- return FALSE;
+ RETURN(FALSE);
}
- ExAcquireFastMutex(&Monitor->Lock);
/* fill monitor info */
MonitorInfo.rcMonitor.left = 0; /* FIXME: get origin */
MonitorInfo.rcMonitor.top = 0; /* FIXME: get origin */
MonitorInfo.rcMonitor.bottom = MonitorInfo.rcMonitor.top + Monitor->GdiDevice->GDIInfo.ulVertRes;
MonitorInfo.rcWork = MonitorInfo.rcMonitor; /* FIXME: use DEVMODE panning to calculate work area? */
MonitorInfo.dwFlags = 0;
+
if (Monitor->IsPrimary)
MonitorInfo.dwFlags |= MONITORINFOF_PRIMARY;
memcpy(MonitorInfo.szDevice, Monitor->DeviceName.Buffer, len);
memcpy(MonitorInfo.szDevice + (len / sizeof (WCHAR)), &nul, sizeof (WCHAR));
}
- ExReleaseFastMutex(&Monitor->Lock);
- IntReleaseMonitorObject(Monitor);
/* output data */
Status = MmCopyToCaller(pMonitorInfo, &MonitorInfo, MonitorInfo.cbSize);
{
DPRINT("GetMonitorInfo: MmCopyToCaller failed\n");
SetLastNtError(Status);
- return FALSE;
+ RETURN(FALSE);
}
DPRINT("GetMonitorInfo: success\n");
- return TRUE;
+ RETURN(TRUE);
+
+CLEANUP:
+ DPRINT("Leave NtUserGetMonitorInfo, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
/* NtUserMonitorFromPoint
PWINDOW_OBJECT Window;
HMONITOR hMonitor = NULL;
RECT Rect;
-
- Window = IntGetWindowObject(hWnd);
- if (Window == NULL)
+ DECLARE_RETURN(HMONITOR);
+
+ DPRINT("Enter NtUserMonitorFromWindow\n");
+ UserEnterShared();
+
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return (HMONITOR)NULL;
+ RETURN(NULL);
}
Rect.left = Rect.right = Window->WindowRect.left;
IntGetMonitorsFromRect(&Rect, &hMonitor, NULL, 1, dwFlags);
- IntReleaseWindowObject(Window);
-
- return hMonitor;
+ RETURN(hMonitor);
+
+CLEANUP:
+ DPRINT("Leave NtUserMonitorFromWindow, ret=%i\n",_ret_);
+ UserLeave();
+ END_CLEANUP;
}
return TRUE;
}
- // DPRINT1("info: something not destroyed bcause refs still left, inuse %i\n",usedHandles);
+// DPRINT1("info: something not destroyed bcause refs still left, inuse %i\n",usedHandles);
return FALSE;
}
if (hdr->RefCount == 0 && hdr->destroyed)
{
- // DPRINT1("info: something destroyed bcaise of deref, in use=%i\n",usedHandles);
+// DPRINT1("info: something destroyed bcaise of deref, in use=%i\n",usedHandles);
UserFreeHandle(&gHandleTable, hdr->hSelf);
RtlZeroMemory(Window->Scroll, Size);
- Result = co_WinPosGetNonClientSize(Window->hSelf,
+ Result = co_WinPosGetNonClientSize(Window,
&Window->WindowRect,
&Window->ClientRect);
DECLARE_RETURN(BOOL);
DPRINT("Enter NtUserGetScrollInfo\n");
- UserEnterShared();
+ UserEnterExclusive();
Status = MmCopyFromCaller(&psi.cbSize, &(lpsi->cbSize), sizeof(UINT));
if(!NT_SUCCESS(Status) ||
/* NOTE - I think we should store this per window station (including gdi objects) */
-static FAST_MUTEX DceListLock;
static PDCE FirstDce = NULL;
static HDC defaultDCstate;
-#if 0
-
-#define DCE_LockList() \
- ExAcquireFastMutex(&DceListLock)
-#define DCE_UnlockList() \
- ExReleaseFastMutex(&DceListLock)
-
-#else
-#define DCE_LockList()
-#define DCE_UnlockList()
-#endif
-
#define DCX_CACHECOMPAREMASK (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | \
DCX_CACHE | DCX_WINDOW | DCX_PARENTCLIP)
VOID FASTCALL
DceInit(VOID)
{
- ExInitializeFastMutex(&DceListLock);
+
}
-HRGN STDCALL
-DceGetVisRgn(HWND hWnd, ULONG Flags, HWND hWndChild, ULONG CFlags)
+static
+HRGN FASTCALL
+DceGetVisRgn(PWINDOW_OBJECT Window, ULONG Flags, HWND hWndChild, ULONG CFlags)
{
- PWINDOW_OBJECT Window;
HRGN VisRgn;
- Window = IntGetWindowObject(hWnd);
-
- if (NULL == Window)
- {
- return NULL;
- }
-
VisRgn = VIS_ComputeVisibleRegion(Window,
0 == (Flags & DCX_WINDOW),
0 != (Flags & DCX_CLIPCHILDREN),
0 != (Flags & DCX_CLIPSIBLINGS));
- IntReleaseWindowObject(Window);
-
return VisRgn;
}
}
PDCE FASTCALL
-DceAllocDCE(HWND hWnd, DCE_TYPE Type)
+DceAllocDCE(PWINDOW_OBJECT Window OPTIONAL, DCE_TYPE Type)
{
HDCE DceHandle;
DCE* Dce;
}
GDIOBJ_SetOwnership(Dce->Self, NULL);
DC_SetOwnership(Dce->hDC, NULL);
- Dce->hwndCurrent = hWnd;
+ Dce->hwndCurrent = (Window ? Window->hSelf : NULL);
Dce->hClipRgn = NULL;
- DCE_LockList();
+
Dce->next = FirstDce;
FirstDce = Dce;
- DCE_UnlockList();
if (Type != DCE_CACHE_DC)
{
Dce->DCXFlags = DCX_DCEBUSY;
- if (hWnd != NULL)
+
+ if (Window)
{
- PWINDOW_OBJECT WindowObject;
-
- WindowObject = IntGetWindowObject(hWnd);
- if (WindowObject->Style & WS_CLIPCHILDREN)
+ if (Window->Style & WS_CLIPCHILDREN)
{
Dce->DCXFlags |= DCX_CLIPCHILDREN;
}
- if (WindowObject->Style & WS_CLIPSIBLINGS)
+ if (Window->Style & WS_CLIPSIBLINGS)
{
Dce->DCXFlags |= DCX_CLIPSIBLINGS;
}
- IntReleaseWindowObject(WindowObject);
}
}
else
}
VOID STATIC STDCALL
-DceSetDrawable(PWINDOW_OBJECT WindowObject, HDC hDC, ULONG Flags,
+DceSetDrawable(PWINDOW_OBJECT Window OPTIONAL, HDC hDC, ULONG Flags,
BOOL SetClipOrigin)
{
DC *dc = DC_LockDc(hDC);
if(!dc)
return;
- if (WindowObject == NULL)
+ if (Window == NULL)
{
dc->w.DCOrgX = 0;
dc->w.DCOrgY = 0;
{
if (Flags & DCX_WINDOW)
{
- dc->w.DCOrgX = WindowObject->WindowRect.left;
- dc->w.DCOrgY = WindowObject->WindowRect.top;
+ dc->w.DCOrgX = Window->WindowRect.left;
+ dc->w.DCOrgY = Window->WindowRect.top;
}
else
{
- dc->w.DCOrgX = WindowObject->ClientRect.left;
- dc->w.DCOrgY = WindowObject->ClientRect.top;
+ dc->w.DCOrgX = Window->ClientRect.left;
+ dc->w.DCOrgY = Window->ClientRect.top;
}
}
DC_UnlockDc(dc);
{
DcxFlags = Flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_WINDOW);
}
- hRgnVisible = DceGetVisRgn(Parent->hSelf, DcxFlags, Window->hSelf, Flags);
+ hRgnVisible = DceGetVisRgn(Parent, DcxFlags, Window->hSelf, Flags);
if (hRgnVisible == NULL)
{
hRgnVisible = NtGdiCreateRectRgn(0, 0, 0, 0);
}
else
{
- hRgnVisible = DceGetVisRgn(Window->hSelf, Flags, 0, 0);
+ hRgnVisible = DceGetVisRgn(Window, Flags, 0, 0);
}
noparent:
DCE* DceEmpty = NULL;
DCE* DceUnused = NULL;
- DCE_LockList();
-
for (Dce = FirstDce; Dce != NULL; Dce = Dce->next)
{
if ((Dce->DCXFlags & (DCX_CACHE | DCX_DCEBUSY)) == DCX_CACHE)
}
}
- DCE_UnlockList();
if (Dce == NULL)
{
PDCE PrevInList;
PDCE pDce = (PDCE)ObjectBody;
- DCE_LockList();
-
if (pDce == FirstDce)
{
FirstDce = pDce->next;
assert(NULL != PrevInList);
}
- DCE_UnlockList();
-
return NULL != PrevInList;
}
{
DCE *Dce;
- DCE_LockList();
for (Dce = FirstDce; Dce != NULL; Dce = Dce->next)
{
if(Dce->hDC == hDc)
{
- DCE_UnlockList();
return Dce->hwndCurrent;
}
}
- DCE_UnlockList();
+
return 0;
}
DCE *dce;
INT nRet = 0;
- DCE_LockList();
-
dce = FirstDce;
DPRINT("%p %p\n", Window, hDc);
nRet = DceReleaseDC(dce);
}
- DCE_UnlockList();
-
return nRet;
}
{
DCE *pDCE;
- DCE_LockList();
-
pDCE = FirstDce;
while (pDCE)
{
}
pDCE = pDCE->next;
}
- DCE_UnlockList();
}
void FASTCALL
DceEmptyCache()
{
- DCE_LockList();
while (FirstDce != NULL)
{
DceFreeDCE(FirstDce, TRUE);
}
- DCE_UnlockList();
}
VOID FASTCALL
return;
}
- DCE_LockList();
-
pDCE = FirstDce;
while (pDCE)
{
pDCE = pDCE->next;
}
- DCE_UnlockList();
}
VOID FASTCALL IntReleaseWindowObject(PWINDOW_OBJECT Window)
{
- ASSERT(Window);
+ /*
+ ASSERT(Window);
ASSERT(USER_BODY_TO_HEADER(Window)->RefCount >= 1);
if (USER_BODY_TO_HEADER(Window)->RefCount == 0 && USER_BODY_TO_HEADER(Window)->destroyed)
{
}
+ */
+
+ ObmDereferenceObject(Window);
}
PWINDOW_OBJECT FASTCALL IntGetWindowObject(HWND hWnd)
{
- PWINDOW_OBJECT Window = UserGetWindowObject(hWnd);
+ PWINDOW_OBJECT Window;
+
+ if (!hWnd) return NULL;
+
+ Window = UserGetWindowObject(hWnd);
if (Window)
{
ASSERT(USER_BODY_TO_HEADER(Window)->RefCount >= 0);
/* temp hack */
PWINDOW_OBJECT FASTCALL UserGetWindowObject(HWND hWnd)
{
- PWINDOW_OBJECT Window = (PWINDOW_OBJECT)UserGetObject(&gHandleTable, hWnd, otWindow);
+ PWINDOW_OBJECT Window;
+
+ if (!hWnd) return NULL;
+
+ Window = (PWINDOW_OBJECT)UserGetObject(&gHandleTable, hWnd, otWindow);
if (!Window)
{
SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
}
BOOL FASTCALL
-IntIsWindowVisible(HWND hWnd)
+IntIsWindowVisible(PWINDOW_OBJECT BaseWindow)
{
- PWINDOW_OBJECT BaseWindow, Window, Old;
-
- if(!(BaseWindow = IntGetWindowObject(hWnd)))
- {
- return FALSE;
- }
+ PWINDOW_OBJECT Window;
Window = BaseWindow;
while(Window)
}
if(!(Window->Style & WS_VISIBLE))
{
- if(Window != BaseWindow)
- IntReleaseWindowObject(Window);
- IntReleaseWindowObject(BaseWindow);
return FALSE;
}
- Old = Window;
- Window = IntGetParentObject(Window);
- if(Old != BaseWindow)
- IntReleaseWindowObject(Old);
+
+ Window = Window->Parent;
}
- if(Window)
+ if(Window && Window->Style & WS_VISIBLE)
{
- if(Window->Style & WS_VISIBLE)
- {
- if(Window != BaseWindow)
- IntReleaseWindowObject(Window);
- IntReleaseWindowObject(BaseWindow);
- return TRUE;
- }
- if(Window != BaseWindow)
- IntReleaseWindowObject(Window);
+ return TRUE;
}
- IntReleaseWindowObject(BaseWindow);
+
return FALSE;
}
/* Allocate a DCE for this window. */
if (dwStyle & CS_OWNDC)
{
- Window->Dce = DceAllocDCE(Window->hSelf, DCE_WINDOW_DC);
+ Window->Dce = DceAllocDCE(Window, DCE_WINDOW_DC);
}
/* FIXME: Handle "CS_CLASSDC" */
MaxPos.y = Window->WindowRect.top;
DPRINT("IntCreateWindowEx(): About to get non-client size.\n");
/* WinPosGetNonClientSize SENDS THE WM_NCCALCSIZE message */
- Result = co_WinPosGetNonClientSize(Window->hSelf,
+ Result = co_WinPosGetNonClientSize(Window,
&Window->WindowRect,
&Window->ClientRect);
IntGdiOffsetRect(&Window->WindowRect,
DPRINT("Enter NtUserGetWindowPlacement\n");
UserEnterShared();
- if (!(Window = IntGetWindowObject(hWnd)))
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( FALSE);
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
if(Safepl.length != sizeof(WINDOWPLACEMENT))
{
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
}
else
{
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
- IntReleaseWindowObject(Window);
RETURN( TRUE);
CLEANUP:
DPRINT("Enter NtUserGetWindowRect\n");
UserEnterShared();
- if (!(Wnd = IntGetWindowObject(hWnd)))
+ if (!(Wnd = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN(FALSE);
}
Status = MmCopyToCaller(Rect, &Wnd->WindowRect, sizeof(RECT));
if (!NT_SUCCESS(Status))
{
- IntReleaseWindowObject(Wnd);
SetLastNtError(Status);
RETURN( FALSE);
}
- IntReleaseWindowObject(Wnd);
RETURN( TRUE);
CLEANUP:
DPRINT("Enter NtUserGetWindowThreadProcessId\n");
UserEnterShared();
- if (!(Wnd = IntGetWindowObject(hWnd)))
+ if (!(Wnd = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( 0);
}
DWORD STDCALL
NtUserQueryWindow(HWND hWnd, DWORD Index)
{
- PWINDOW_OBJECT Window = IntGetWindowObject(hWnd);
+ PWINDOW_OBJECT Window;
DWORD Result;
DECLARE_RETURN(UINT);
DPRINT("Enter NtUserQueryWindow\n");
UserEnterShared();
- if (Window == NULL)
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( 0);
}
break;
}
- IntReleaseWindowObject(Window);
-
RETURN( Result);
-
CLEANUP:
DPRINT("Leave NtUserQueryWindow, ret=%i\n",_ret_);
UserLeave();
DPRINT("Enter NtUserSetWindowPlacement\n");
UserEnterExclusive();
- if (!(Window = IntGetWindowObject(hWnd)))
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( FALSE);
}
Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
if(Safepl.length != sizeof(WINDOWPLACEMENT))
{
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
+ UserRefObjectCo(Window);
+
if ((Window->Style & (WS_MAXIMIZE | WS_MINIMIZE)) == 0)
{
co_WinPosSetWindowPos(Window, NULL,
Window->InternalPos->IconPos = Safepl.ptMinPosition;
Window->InternalPos->MaxPos = Safepl.ptMaxPosition;
- IntReleaseWindowObject(Window);
- RETURN( TRUE);
+ UserDerefObjectCo(Window);
+ RETURN(TRUE);
CLEANUP:
DPRINT("Leave NtUserSetWindowPlacement, ret=%i\n",_ret_);
INT FASTCALL
-IntGetWindowRgn(HWND hWnd, HRGN hRgn)
+IntGetWindowRgn(PWINDOW_OBJECT Window, HRGN hRgn)
{
INT Ret;
- PWINDOW_OBJECT Window;
HRGN VisRgn;
ROSRGNDATA *pRgn;
- if(!(Window = IntGetWindowObject(hWnd)))
+ if(!Window)
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
return ERROR;
}
if(!hRgn)
{
- IntReleaseWindowObject(Window);
return ERROR;
}
NtGdiDeleteObject(VisRgn);
- IntReleaseWindowObject(Window);
return Ret;
}
INT FASTCALL
-IntGetWindowRgnBox(HWND hWnd, RECT *Rect)
+IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECT *Rect)
{
INT Ret;
- PWINDOW_OBJECT Window;
HRGN VisRgn;
ROSRGNDATA *pRgn;
- if(!(Window = IntGetWindowObject(hWnd)))
+ if(!Window)
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
return ERROR;
}
if(!Rect)
{
- IntReleaseWindowObject(Window);
return ERROR;
}
NtGdiDeleteObject(VisRgn);
- IntReleaseWindowObject(Window);
return Ret;
}
DPRINT("Enter NtUserSetWindowRgn\n");
UserEnterExclusive();
- if (!(Window = IntGetWindowObject(hWnd)))
+ if (!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( 0);
}
if(bRedraw)
{
+ UserRefObjectCo(Window);
co_UserRedrawWindow(Window, NULL, NULL, RDW_INVALIDATE);
+ UserDerefObjectCo(Window);
}
- IntReleaseWindowObject(Window);
RETURN( (INT)hRgn);
CLEANUP:
DPRINT("Enter NtUserDefSetText\n");
UserEnterExclusive();
- if(!(Window = IntGetWindowObject(hWnd)))
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( FALSE);
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- IntReleaseWindowObject(Window);
RETURN( FALSE);
}
}
IntReleaseWindowObject(Parent);
}
- IntReleaseWindowObject(Window);
RETURN( TRUE);
CLEANUP:
RETURN( 0);
}
- if(!(Window = IntGetWindowObject(hWnd)))
+ if(!(Window = UserGetWindowObject(hWnd)))
{
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
RETURN( 0);
}
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- IntReleaseWindowObject(Window);
RETURN( 0);
}
Buffer += Copy;
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
- IntReleaseWindowObject(Window);
RETURN( 0);
}
Result = Copy;
}
- IntReleaseWindowObject(Window);
RETURN( Result);
CLEANUP:
BOOL
FASTCALL
-IntShowOwnedPopups( HWND owner, BOOL fShow )
+IntShowOwnedPopups(PWINDOW_OBJECT OwnerWnd, BOOL fShow )
{
int count = 0;
- PWINDOW_OBJECT Window, pWnd;
+ PWINDOW_OBJECT pWnd;
HWND *win_array;
- if(!(Window = IntGetWindowObject(owner)))
- {
- SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
- return FALSE;
- }
+ ASSERT(OwnerWnd);
- win_array = IntWinListChildren( Window);
- IntReleaseWindowObject(Window);
+ win_array = IntWinListChildren(OwnerWnd);//faxme: use desktop?
if (!win_array)
return TRUE;
count++;
while (--count >= 0)
{
- if (UserGetWindow( win_array[count], GW_OWNER ) != owner)
+ if (UserGetWindow( win_array[count], GW_OWNER ) != OwnerWnd->hSelf)
continue;
- if (!(pWnd = IntGetWindowObject( win_array[count] )))
+ if (!(pWnd = UserGetWindowObject( win_array[count] )))
continue;
// if (pWnd == WND_OTHER_PROCESS) continue;
{
if (pWnd->Flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
{
- IntReleaseWindowObject( pWnd );
/* In Windows, ShowOwnedPopups(TRUE) generates
* WM_SHOWWINDOW messages with SW_PARENTOPENING,
* regardless of the state of the owner
{
if (pWnd->Style & WS_VISIBLE)
{
- IntReleaseWindowObject( pWnd );
/* In Windows, ShowOwnedPopups(FALSE) generates
* WM_SHOWWINDOW messages with SW_PARENTCLOSING,
* regardless of the state of the owner
continue;
}
}
- IntReleaseWindowObject( pWnd );
+
}
ExFreePool( win_array );
return TRUE;
co_WinPosArrangeIconicWindows(PWINDOW_OBJECT parent)
{
RECT rectParent;
- HWND hwndChild;
INT i, x, y, xspacing, yspacing;
HWND *List = IntWinListChildren(parent);
{
PWINDOW_OBJECT WndChild;
- hwndChild = List[i];
-
if (!(WndChild = UserGetWindowObject(List[i])))
continue;
- if((UserGetWindowLong( hwndChild, GWL_STYLE, FALSE) & WS_MINIMIZE) != 0 )
+ if((WndChild->Style & WS_MINIMIZE) != 0 )
{
UserRefObjectCo(WndChild);
{
MINMAXINFO MinMax;
+ ASSERT_REFS_CO(Window);
+
WinPosFillMinMaxInfoStruct(Window, &MinMax);
co_IntSendMessage(Window->hSelf, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax);
PWINDOW_OBJECT Parent;
UINT wvrFlags = 0;
+ ASSERT_REFS_CO(Window);
+
/* Send WM_NCCALCSIZE message to get new client area */
if ((WinPos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE)
{
{
INT X, Y;
+ ASSERT_REFS_CO(Window);
+
if (!(WinPos->flags & SWP_NOSENDCHANGING))
{
co_IntSendMessage(Window->hSelf, WM_WINDOWPOSCHANGING, 0, (LPARAM) WinPos);
if (!(Wnd = UserGetWindowObject(List[i])))
continue;
- if ((UserGetWindowLong(List[i], GWL_STYLE, FALSE) & WS_POPUP) &&
+ if ((Wnd->Style & WS_POPUP) &&
UserGetWindow(List[i], GW_OWNER) == hWnd)
{
UserRefObjectCo(Wnd);
PWINDOW_OBJECT Sibling;
PWINDOW_OBJECT InsertAfterWindow;
- if ((ParentWindow = IntGetParentObject(Window)))
+ if ((ParentWindow = Window->Parent))
{
if (HWND_TOPMOST == WinPos.hwndInsertAfter)
{
Window->ExStyle &= ~ WS_EX_TOPMOST;
}
- IntReleaseWindowObject(ParentWindow);
}
}
}
LRESULT FASTCALL
-co_WinPosGetNonClientSize(HWND Wnd, RECT* WindowRect, RECT* ClientRect)
+co_WinPosGetNonClientSize(PWINDOW_OBJECT Window, RECT* WindowRect, RECT* ClientRect)
{
LRESULT Result;
+ ASSERT_REFS_CO(Window);
+
*ClientRect = *WindowRect;
- Result = co_IntSendMessage(Wnd, WM_NCCALCSIZE, FALSE, (LPARAM) ClientRect);
+ Result = co_IntSendMessage(Window->hSelf, WM_NCCALCSIZE, FALSE, (LPARAM) ClientRect);
FixClientRect(ClientRect, WindowRect);
if (Window->hSelf == IntGetThreadFocusWindow() ||
IntIsChildWindow(Window->hSelf, IntGetThreadFocusWindow()))
{
- UserSetFocus(Window->Parent->hSelf);
+ //faxme: as long as we have ref on Window, we also, indirectly, have ref on parent...
+ co_UserSetFocus(Window->Parent);
}
if (!(Window->Parent))
projects / reactos.git / commitdiff