Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-01 20:32:36 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/win32ss/user/ntuser/painting.c
Timo Kreuzer 34586814ab [GDI32][NTUSER] Demote noisy debug prints
2024-08-30 16:06:41 +03:00

2622 lines
64 KiB
C
Raw Blame History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Win32k subsystem
* PURPOSE: Window painting function
* FILE: win32ss/user/ntuser/painting.c
* PROGRAMER: Filip Navara (xnavara@volny.cz)
*/
#include <win32k.h>
DBG_DEFAULT_CHANNEL(UserPainting);
BOOL UserExtTextOutW(HDC hdc, INT x, INT y, UINT flags, PRECTL lprc,
LPCWSTR lpString, UINT count);
/* PRIVATE FUNCTIONS **********************************************************/
/**
* @name IntIntersectWithParents
*
* Intersect window rectangle with all parent client rectangles.
*
* @param Child
* Pointer to child window to start intersecting from.
* @param WindowRect
* Pointer to rectangle that we want to intersect in screen
* coordinates on input and intersected rectangle on output (if TRUE
* is returned).
*
* @return
* If any parent is minimized or invisible or the resulting rectangle
* is empty then FALSE is returned. Otherwise TRUE is returned.
*/
BOOL FASTCALL
IntIntersectWithParents(PWND Child, RECTL *WindowRect)
{
PWND ParentWnd;
if (Child->ExStyle & WS_EX_REDIRECTED)
return TRUE;
ParentWnd = Child->spwndParent;
while (ParentWnd != NULL)
{
if (!(ParentWnd->style & WS_VISIBLE) ||
(ParentWnd->style & WS_MINIMIZE) ||
!RECTL_bIntersectRect(WindowRect, WindowRect, &ParentWnd->rcClient) )
{
return FALSE;
}
if (ParentWnd->ExStyle & WS_EX_REDIRECTED)
return TRUE;
ParentWnd = ParentWnd->spwndParent;
}
return TRUE;
}
BOOL FASTCALL
IntValidateParents(PWND Child, BOOL Recurse)
{
RECTL ParentRect, Rect;
BOOL Start, Ret = TRUE;
PWND ParentWnd = Child;
PREGION Rgn = NULL;
if (ParentWnd->style & WS_CHILD)
{
do
ParentWnd = ParentWnd->spwndParent;
while (ParentWnd->style & WS_CHILD);
}
// No pending nonclient paints.
if (!(ParentWnd->state & WNDS_SYNCPAINTPENDING)) Recurse = FALSE;
Start = TRUE;
ParentWnd = Child->spwndParent;
while (ParentWnd)
{
if (ParentWnd->style & WS_CLIPCHILDREN)
break;
if (ParentWnd->hrgnUpdate != 0)
{
if (Recurse)
{
Ret = FALSE;
break;
}
// Start with child clipping.
if (Start)
{
Start = FALSE;
Rect = Child->rcWindow;
if (!IntIntersectWithParents(Child, &Rect)) break;
Rgn = IntSysCreateRectpRgnIndirect(&Rect);
if (Child->hrgnClip)
{
PREGION RgnClip = REGION_LockRgn(Child->hrgnClip);
IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
REGION_UnlockRgn(RgnClip);
}
}
ParentRect = ParentWnd->rcWindow;
if (!IntIntersectWithParents(ParentWnd, &ParentRect)) break;
IntInvalidateWindows( ParentWnd,
Rgn,
RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOUPDATEDIRTY);
}
ParentWnd = ParentWnd->spwndParent;
}
if (Rgn) REGION_Delete(Rgn);
return Ret;
}
/*
Synchronize painting to the top-level windows of other threads.
*/
VOID FASTCALL
IntSendSyncPaint(PWND Wnd, ULONG Flags)
{
PTHREADINFO ptiCur, ptiWnd;
PUSER_SENT_MESSAGE Message;
PLIST_ENTRY Entry;
BOOL bSend = TRUE;
ptiWnd = Wnd->head.pti;
ptiCur = PsGetCurrentThreadWin32Thread();
/*
Not the current thread, Wnd is in send Nonclient paint also in send erase background and it is visiable.
*/
if ( Wnd->head.pti != ptiCur &&
Wnd->state & WNDS_SENDNCPAINT &&
Wnd->state & WNDS_SENDERASEBACKGROUND &&
Wnd->style & WS_VISIBLE)
{
// For testing, if you see this, break out the Champagne and have a party!
TRACE("SendSyncPaint Wnd in State!\n");
if (!IsListEmpty(&ptiWnd->SentMessagesListHead))
{
// Scan sent queue messages to see if we received sync paint messages.
Entry = ptiWnd->SentMessagesListHead.Flink;
Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
do
{
TRACE("LOOP it\n");
if (Message->Msg.message == WM_SYNCPAINT &&
Message->Msg.hwnd == UserHMGetHandle(Wnd))
{ // Already received so exit out.
ERR("SendSyncPaint Found one in the Sent Msg Queue!\n");
bSend = FALSE;
break;
}
Entry = Message->ListEntry.Flink;
Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
}
while (Entry != &ptiWnd->SentMessagesListHead);
}
if (bSend)
{
TRACE("Sending WM_SYNCPAINT\n");
// This message has no parameters. But it does! Pass Flags along.
co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SYNCPAINT, Flags, 0);
Wnd->state |= WNDS_SYNCPAINTPENDING;
}
}
// Send to all the children if this is the desktop window.
if (UserIsDesktopWindow(Wnd))
{
if ( Flags & RDW_ALLCHILDREN ||
( !(Flags & RDW_NOCHILDREN) && Wnd->style & WS_CLIPCHILDREN))
{
PWND spwndChild = Wnd->spwndChild;
while(spwndChild)
{
if ( spwndChild->style & WS_CHILD &&
spwndChild->head.pti != ptiCur)
{
spwndChild = spwndChild->spwndNext;
continue;
}
IntSendSyncPaint( spwndChild, Flags );
spwndChild = spwndChild->spwndNext;
}
}
}
}
/*
* @name IntCalcWindowRgn
*
* Get a window or client region.
*/
HRGN FASTCALL
IntCalcWindowRgn(PWND Wnd, BOOL Client)
{
HRGN hRgnWindow;
if (Client)
{
hRgnWindow = NtGdiCreateRectRgn(
Wnd->rcClient.left,
Wnd->rcClient.top,
Wnd->rcClient.right,
Wnd->rcClient.bottom);
}
else
{
hRgnWindow = NtGdiCreateRectRgn(
Wnd->rcWindow.left,
Wnd->rcWindow.top,
Wnd->rcWindow.right,
Wnd->rcWindow.bottom);
}
if (Wnd->hrgnClip != NULL && !(Wnd->style & WS_MINIMIZE))
{
NtGdiOffsetRgn(hRgnWindow,
-Wnd->rcWindow.left,
-Wnd->rcWindow.top);
NtGdiCombineRgn(hRgnWindow, hRgnWindow, Wnd->hrgnClip, RGN_AND);
NtGdiOffsetRgn(hRgnWindow,
Wnd->rcWindow.left,
Wnd->rcWindow.top);
}
return hRgnWindow;
}
/*
* @name IntGetNCUpdateRgn
*
* Get non-client update region of a window and optionally validate it.
*
* @param Window
* Pointer to window to get the NC update region from.
* @param Validate
* Set to TRUE to force validating the NC update region.
*
* @return
* Handle to NC update region. The caller is responsible for deleting
* it.
*/
HRGN FASTCALL
IntGetNCUpdateRgn(PWND Window, BOOL Validate)
{
HRGN hRgnNonClient;
HRGN hRgnWindow;
UINT RgnType, NcType;
RECT update;
if (Window->hrgnUpdate != NULL &&
Window->hrgnUpdate != HRGN_WINDOW)
{
hRgnNonClient = IntCalcWindowRgn(Window, FALSE);
/*
* If region creation fails it's safe to fallback to whole
* window region.
*/
if (hRgnNonClient == NULL)
{
return HRGN_WINDOW;
}
hRgnWindow = IntCalcWindowRgn(Window, TRUE);
if (hRgnWindow == NULL)
{
GreDeleteObject(hRgnNonClient);
return HRGN_WINDOW;
}
NcType = IntGdiGetRgnBox(hRgnNonClient, &update);
RgnType = NtGdiCombineRgn(hRgnNonClient, hRgnNonClient, hRgnWindow, RGN_DIFF);
if (RgnType == ERROR)
{
GreDeleteObject(hRgnWindow);
GreDeleteObject(hRgnNonClient);
return HRGN_WINDOW;
}
else if (RgnType == NULLREGION)
{
GreDeleteObject(hRgnWindow);
GreDeleteObject(hRgnNonClient);
Window->state &= ~WNDS_UPDATEDIRTY;
return NULL;
}
/*
* Remove the nonclient region from the standard update region if
* we were asked for it.
*/
if (Validate)
{
if (NtGdiCombineRgn(Window->hrgnUpdate, Window->hrgnUpdate, hRgnWindow, RGN_AND) == NULLREGION)
{
IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
GreDeleteObject(Window->hrgnUpdate);
Window->state &= ~WNDS_UPDATEDIRTY;
Window->hrgnUpdate = NULL;
if (!(Window->state & WNDS_INTERNALPAINT))
MsqDecPaintCountQueue(Window->head.pti);
}
}
/* check if update rgn contains complete nonclient area */
if (NcType == SIMPLEREGION)
{
RECT window;
IntGetWindowRect( Window, &window );
if (IntEqualRect( &window, &update ))
{
GreDeleteObject(hRgnNonClient);
hRgnNonClient = HRGN_WINDOW;
}
}
GreDeleteObject(hRgnWindow);
return hRgnNonClient;
}
else
{
return Window->hrgnUpdate;
}
}
VOID FASTCALL
IntSendNCPaint(PWND pWnd, HRGN hRgn)
{
pWnd->state &= ~WNDS_SENDNCPAINT;
if ( pWnd == GetW32ThreadInfo()->MessageQueue->spwndActive &&
!(pWnd->state & WNDS_ACTIVEFRAME))
{
pWnd->state |= WNDS_ACTIVEFRAME;
pWnd->state &= ~WNDS_NONCPAINT;
hRgn = HRGN_WINDOW;
}
if (pWnd->state2 & WNDS2_FORCEFULLNCPAINTCLIPRGN)
{
pWnd->state2 &= ~WNDS2_FORCEFULLNCPAINTCLIPRGN;
hRgn = HRGN_WINDOW;
}
if (hRgn) co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCPAINT, (WPARAM)hRgn, 0);
}
VOID FASTCALL
IntSendChildNCPaint(PWND pWnd)
{
pWnd = pWnd->spwndChild;
while (pWnd)
{
if ((pWnd->hrgnUpdate == NULL) && (pWnd->state & WNDS_SENDNCPAINT))
{
PWND Next;
USER_REFERENCE_ENTRY Ref;
/* Reference, IntSendNCPaint leaves win32k */
UserRefObjectCo(pWnd, &Ref);
IntSendNCPaint(pWnd, HRGN_WINDOW);
/* Make sure to grab next one before dereferencing/freeing */
Next = pWnd->spwndNext;
UserDerefObjectCo(pWnd);
pWnd = Next;
}
else
{
pWnd = pWnd->spwndNext;
}
}
}
/*
* IntPaintWindows
*
* Internal function used by IntRedrawWindow.
*/
VOID FASTCALL
co_IntPaintWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
{
HDC hDC;
HWND hWnd = UserHMGetHandle(Wnd);
HRGN TempRegion = NULL;
Wnd->state &= ~WNDS_PAINTNOTPROCESSED;
if (Wnd->state & WNDS_SENDNCPAINT ||
Wnd->state & WNDS_SENDERASEBACKGROUND)
{
if (!(Wnd->style & WS_VISIBLE))
{
Wnd->state &= ~(WNDS_SENDNCPAINT|WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
return;
}
else
{
if (Wnd->hrgnUpdate == NULL)
{
Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
}
if (Wnd->head.pti == PsGetCurrentThreadWin32Thread())
{
if (Wnd->state & WNDS_SENDNCPAINT)
{
TempRegion = IntGetNCUpdateRgn(Wnd, TRUE);
IntSendNCPaint(Wnd, TempRegion);
if (TempRegion > HRGN_WINDOW && GreIsHandleValid(TempRegion))
{
/* NOTE: The region can already be deleted! */
GreDeleteObject(TempRegion);
}
}
if (Wnd->state & WNDS_SENDERASEBACKGROUND)
{
PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
if (Wnd->hrgnUpdate)
{
hDC = UserGetDCEx( Wnd,
Wnd->hrgnUpdate,
DCX_CACHE|DCX_USESTYLE|DCX_INTERSECTRGN|DCX_KEEPCLIPRGN);
if (Wnd->head.pti->ppi != pti->ppi)
{
ERR("Sending DC to another Process!!!\n");
}
Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
// Kill the loop, so Clear before we send.
if (!co_IntSendMessage(hWnd, WM_ERASEBKGND, (WPARAM)hDC, 0))
{
Wnd->state |= (WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
}
UserReleaseDC(Wnd, hDC, FALSE);
}
}
}
}
}
/*
* Check that the window is still valid at this point
*/
if (!IntIsWindow(hWnd))
{
return;
}
/*
* Paint child windows.
*/
if (!(Flags & RDW_NOCHILDREN) &&
!(Wnd->style & WS_MINIMIZE) &&
( Flags & RDW_ALLCHILDREN ||
(Flags & RDW_CLIPCHILDREN && Wnd->style & WS_CLIPCHILDREN) ) )
{
HWND *List, *phWnd;
PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
if ((List = IntWinListChildren(Wnd)))
{
for (phWnd = List; *phWnd; ++phWnd)
{
if ((Wnd = UserGetWindowObject(*phWnd)) == NULL)
continue;
if (Wnd->head.pti != pti && Wnd->style & WS_CHILD)
continue;
if (Wnd->style & WS_VISIBLE)
{
USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Wnd, &Ref);
co_IntPaintWindows(Wnd, Flags, TRUE);
UserDerefObjectCo(Wnd);
}
}
ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
}
}
}
/*
* IntUpdateWindows
*
* Internal function used by IntRedrawWindow, simplecall.
*/
VOID FASTCALL
co_IntUpdateWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
{
HWND hWnd = UserHMGetHandle(Wnd);
if ( Wnd->hrgnUpdate != NULL || Wnd->state & WNDS_INTERNALPAINT )
{
if (Wnd->hrgnUpdate)
{
if (!IntValidateParents(Wnd, Recurse))
{
return;
}
}
if (Wnd->state & WNDS_INTERNALPAINT)
{
Wnd->state &= ~WNDS_INTERNALPAINT;
if (Wnd->hrgnUpdate == NULL)
MsqDecPaintCountQueue(Wnd->head.pti);
}
Wnd->state |= WNDS_PAINTNOTPROCESSED;
Wnd->state &= ~WNDS_UPDATEDIRTY;
Wnd->state2 |= WNDS2_WMPAINTSENT;
co_IntSendMessage(hWnd, WM_PAINT, 0, 0);
if (Wnd->state & WNDS_PAINTNOTPROCESSED)
{
USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Wnd, &Ref);
co_IntPaintWindows(Wnd, RDW_NOCHILDREN, FALSE);
UserDerefObjectCo(Wnd);
}
}
// Force flags as a toggle. Fixes msg:test_paint_messages:WmChildPaintNc.
Flags = (Flags & RDW_NOCHILDREN) ? RDW_NOCHILDREN : RDW_ALLCHILDREN; // All children is the default.
/*
* Update child windows.
*/
if (!(Flags & RDW_NOCHILDREN) &&
(Flags & RDW_ALLCHILDREN) &&
!UserIsDesktopWindow(Wnd))
{
PWND Child;
for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
{
/* transparent window, check for non-transparent sibling to paint first, then skip it */
if ( Child->ExStyle & WS_EX_TRANSPARENT &&
( Child->hrgnUpdate != NULL || Child->state & WNDS_INTERNALPAINT ) )
{
PWND Next = Child->spwndNext;
while (Next)
{
if ( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT ) break;
Next = Next->spwndNext;
}
if (Next) continue;
}
if (Child->style & WS_VISIBLE)
{
USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Child, &Ref);
co_IntUpdateWindows(Child, Flags, TRUE);
UserDerefObjectCo(Child);
}
}
}
}
VOID FASTCALL
UserUpdateWindows(PWND pWnd, ULONG Flags)
{
// If transparent and any sibling windows below needs to be painted, leave.
if (pWnd->ExStyle & WS_EX_TRANSPARENT)
{
PWND Next = pWnd->spwndNext;
while(Next)
{
if ( Next->head.pti == pWnd->head.pti &&
( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT) )
{
return;
}
Next = Next->spwndNext;
}
}
co_IntUpdateWindows(pWnd, Flags, FALSE);
}
VOID FASTCALL
UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
{
PWND Parent = pWnd;
// Find parent, if it needs to be painted, leave.
while(TRUE)
{
if ((Parent = Parent->spwndParent) == NULL) break;
if ( Parent->style & WS_CLIPCHILDREN ) break;
if ( Parent->hrgnUpdate != NULL || Parent->state & WNDS_INTERNALPAINT ) return;
}
IntSendSyncPaint(pWnd, Flags);
co_IntPaintWindows(pWnd, Flags, FALSE);
}
/*
* IntInvalidateWindows
*
* Internal function used by IntRedrawWindow, UserRedrawDesktop,
* co_WinPosSetWindowPos, co_UserRedrawWindow.
*/
VOID FASTCALL
IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
{
INT RgnType = NULLREGION;
BOOL HadPaintMessage;
TRACE("IntInvalidateWindows start Rgn %p\n",Rgn);
if ( Rgn > PRGN_WINDOW )
{
/*
* If the nonclient is not to be redrawn, clip the region to the client
* rect
*/
if ((Flags & RDW_INVALIDATE) != 0 && (Flags & RDW_FRAME) == 0)
{
PREGION RgnClient;
RgnClient = IntSysCreateRectpRgnIndirect(&Wnd->rcClient);
if (RgnClient)
{
RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClient, RGN_AND);
REGION_Delete(RgnClient);
}
}
/*
* Clip the given region with window rectangle (or region)
*/
if (!Wnd->hrgnClip || (Wnd->style & WS_MINIMIZE))
{
PREGION RgnWindow = IntSysCreateRectpRgnIndirect(&Wnd->rcWindow);
if (RgnWindow)
{
RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnWindow, RGN_AND);
REGION_Delete(RgnWindow);
}
}
else
{
PREGION RgnClip = REGION_LockRgn(Wnd->hrgnClip);
if (RgnClip)
{
REGION_bOffsetRgn(Rgn,
-Wnd->rcWindow.left,
-Wnd->rcWindow.top);
RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
REGION_bOffsetRgn(Rgn,
Wnd->rcWindow.left,
Wnd->rcWindow.top);
REGION_UnlockRgn(RgnClip);
}
}
}
else
{
RgnType = NULLREGION;
}
/* Nothing to paint, just return */
if ((RgnType == NULLREGION && (Flags & RDW_INVALIDATE)) || RgnType == ERROR)
{
return;
}
/*
* Save current state of pending updates
*/
HadPaintMessage = IntIsWindowDirty(Wnd);
/*
* Update the region and flags
*/
// The following flags are used to invalidate the window.
if (Flags & (RDW_INVALIDATE|RDW_INTERNALPAINT|RDW_ERASE|RDW_FRAME))
{
if (Flags & RDW_INTERNALPAINT)
{
Wnd->state |= WNDS_INTERNALPAINT;
}
if (Flags & RDW_INVALIDATE )
{
PREGION RgnUpdate;
Wnd->state &= ~WNDS_NONCPAINT;
/* If not the same thread set it dirty. */
if (Wnd->head.pti != PsGetCurrentThreadWin32Thread())
{
Wnd->state |= WNDS_UPDATEDIRTY;
if (Wnd->state2 & WNDS2_WMPAINTSENT)
Wnd->state2 |= WNDS2_ENDPAINTINVALIDATE;
}
if (Flags & RDW_FRAME)
Wnd->state |= WNDS_SENDNCPAINT;
if (Flags & RDW_ERASE)
Wnd->state |= WNDS_SENDERASEBACKGROUND;
if (RgnType != NULLREGION && Rgn > PRGN_WINDOW)
{
if (Wnd->hrgnUpdate == NULL)
{
Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_PUBLIC);
}
if (Wnd->hrgnUpdate != HRGN_WINDOW)
{
RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
if (RgnUpdate)
{
RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_OR);
REGION_UnlockRgn(RgnUpdate);
if (RgnType == NULLREGION)
{
IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
GreDeleteObject(Wnd->hrgnUpdate);
Wnd->hrgnUpdate = NULL;
}
}
}
}
Flags |= RDW_ERASE|RDW_FRAME; // For children.
}
if (!HadPaintMessage && IntIsWindowDirty(Wnd))
{
MsqIncPaintCountQueue(Wnd->head.pti);
}
} // The following flags are used to validate the window.
else if (Flags & (RDW_VALIDATE|RDW_NOINTERNALPAINT|RDW_NOERASE|RDW_NOFRAME))
{
if (Wnd->state & WNDS_UPDATEDIRTY && !(Flags & RDW_NOUPDATEDIRTY))
return;
if (Flags & RDW_NOINTERNALPAINT)
{
Wnd->state &= ~WNDS_INTERNALPAINT;
}
if (Flags & RDW_VALIDATE)
{
if (Flags & RDW_NOFRAME)
Wnd->state &= ~WNDS_SENDNCPAINT;
if (Flags & RDW_NOERASE)
Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
if (Wnd->hrgnUpdate > HRGN_WINDOW && RgnType != NULLREGION && Rgn > PRGN_WINDOW)
{
PREGION RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
if (RgnUpdate)
{
RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_DIFF);
REGION_UnlockRgn(RgnUpdate);
if (RgnType == NULLREGION)
{
IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
GreDeleteObject(Wnd->hrgnUpdate);
Wnd->hrgnUpdate = NULL;
}
}
}
// If update is null, do not erase.
if (Wnd->hrgnUpdate == NULL)
{
Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
}
}
if (HadPaintMessage && !IntIsWindowDirty(Wnd))
{
MsqDecPaintCountQueue(Wnd->head.pti);
}
}
/*
* Process children if needed
*/
if (!(Flags & RDW_NOCHILDREN) &&
!(Wnd->style & WS_MINIMIZE) &&
((Flags & RDW_ALLCHILDREN) || !(Wnd->style & WS_CLIPCHILDREN)))
{
PWND Child;
for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
{
if (Child->style & WS_VISIBLE)
{
/*
* Recursive call to update children hrgnUpdate
*/
PREGION RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
if (RgnTemp)
{
if (Rgn > PRGN_WINDOW) IntGdiCombineRgn(RgnTemp, Rgn, 0, RGN_COPY);
IntInvalidateWindows(Child, ((Rgn > PRGN_WINDOW)?RgnTemp:Rgn), Flags);
REGION_Delete(RgnTemp);
}
}
}
}
TRACE("IntInvalidateWindows exit\n");
}
/*
* IntIsWindowDrawable
*
* Remarks
* Window is drawable when it is visible and all parents are not
* minimized.
*/
BOOL FASTCALL
IntIsWindowDrawable(PWND Wnd)
{
PWND WndObject;
for (WndObject = Wnd; WndObject != NULL; WndObject = WndObject->spwndParent)
{
if ( WndObject->state2 & WNDS2_INDESTROY ||
WndObject->state & WNDS_DESTROYED ||
!WndObject ||
!(WndObject->style & WS_VISIBLE) ||
((WndObject->style & WS_MINIMIZE) && (WndObject != Wnd)))
{
return FALSE;
}
}
return TRUE;
}
/*
* IntRedrawWindow
*
* Internal version of NtUserRedrawWindow that takes WND as
* first parameter.
*/
BOOL FASTCALL
co_UserRedrawWindow(
PWND Window,
const RECTL* UpdateRect,
PREGION UpdateRgn,
ULONG Flags)
{
PREGION TmpRgn = NULL;
TRACE("co_UserRedrawWindow start Rgn %p\n",UpdateRgn);
/*
* Step 1.
* Validation of passed parameters.
*/
if (!IntIsWindowDrawable(Window))
{
return TRUE; // Just do nothing!!!
}
if (Window == NULL)
{
Window = UserGetDesktopWindow();
}
/*
* Step 2.
* Transform the parameters UpdateRgn and UpdateRect into
* a region hRgn specified in screen coordinates.
*/
if (Flags & (RDW_INVALIDATE | RDW_VALIDATE)) // Both are OKAY!
{
/* We can't hold lock on GDI objects while doing roundtrips to user mode,
* so use a copy instead */
if (UpdateRgn)
{
TmpRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
if (UpdateRgn > PRGN_WINDOW)
{
IntGdiCombineRgn(TmpRgn, UpdateRgn, NULL, RGN_COPY);
}
if (Window != UserGetDesktopWindow())
{
REGION_bOffsetRgn(TmpRgn, Window->rcClient.left, Window->rcClient.top);
}
}
else
{
if (UpdateRect != NULL)
{
if (Window == UserGetDesktopWindow())
{
TmpRgn = IntSysCreateRectpRgnIndirect(UpdateRect);
}
else
{
TmpRgn = IntSysCreateRectpRgn(Window->rcClient.left + UpdateRect->left,
Window->rcClient.top + UpdateRect->top,
Window->rcClient.left + UpdateRect->right,
Window->rcClient.top + UpdateRect->bottom);
}
}
else
{
if ((Flags & (RDW_INVALIDATE | RDW_FRAME)) == (RDW_INVALIDATE | RDW_FRAME) ||
(Flags & (RDW_VALIDATE | RDW_NOFRAME)) == (RDW_VALIDATE | RDW_NOFRAME))
{
if (!RECTL_bIsEmptyRect(&Window->rcWindow))
TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
}
else
{
if (!RECTL_bIsEmptyRect(&Window->rcClient))
TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcClient);
}
}
}
}
/* Fixes test RDW_INTERNALPAINT behavior */
if (TmpRgn == NULL)
{
TmpRgn = PRGN_WINDOW; // Need a region so the bits can be set!!!
}
/*
* Step 3.
* Adjust the window update region depending on hRgn and flags.
*/
if (Flags & (RDW_INVALIDATE | RDW_VALIDATE | RDW_INTERNALPAINT | RDW_NOINTERNALPAINT) &&
TmpRgn != NULL)
{
IntInvalidateWindows(Window, TmpRgn, Flags);
}
/*
* Step 4.
* Repaint and erase windows if needed.
*/
if (Flags & RDW_UPDATENOW)
{
UserUpdateWindows(Window, Flags);
}
else if (Flags & RDW_ERASENOW)
{
if ((Flags & (RDW_NOCHILDREN|RDW_ALLCHILDREN)) == 0)
Flags |= RDW_CLIPCHILDREN;
UserSyncAndPaintWindows(Window, Flags);
}
/*
* Step 5.
* Cleanup ;-)
*/
if (TmpRgn > PRGN_WINDOW)
{
REGION_Delete(TmpRgn);
}
TRACE("co_UserRedrawWindow exit\n");
return TRUE;
}
VOID FASTCALL
PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
{
if (pwnd->hrgnUpdate)
{
HDC hDC;
INT Flags = DC_NC|DC_NOSENDMSG;
HRGN hrgnTemp;
RECT Rect;
INT type;
PREGION prgn;
if (pwnd->hrgnUpdate > HRGN_WINDOW)
{
hrgnTemp = NtGdiCreateRectRgn(0, 0, 0, 0);
type = NtGdiCombineRgn( hrgnTemp, pwnd->hrgnUpdate, 0, RGN_COPY);
if (type == ERROR)
{
GreDeleteObject(hrgnTemp);
hrgnTemp = HRGN_WINDOW;
}
}
else
{
hrgnTemp = GreCreateRectRgnIndirect(&pwnd->rcWindow);
}
if ( hrgnOrig &&
hrgnTemp > HRGN_WINDOW &&
NtGdiCombineRgn(hrgnTemp, hrgnTemp, hrgnOrig, RGN_AND) == NULLREGION)
{
GreDeleteObject(hrgnTemp);
return;
}
hDC = UserGetDCEx(pwnd, hrgnTemp, DCX_WINDOW|DCX_INTERSECTRGN|DCX_USESTYLE|DCX_KEEPCLIPRGN);
Rect = pwnd->rcWindow;
RECTL_vOffsetRect(&Rect, -pwnd->rcWindow.left, -pwnd->rcWindow.top);
// Clear out client area!
FillRect(hDC, &Rect, IntGetSysColorBrush(COLOR_WINDOW));
NC_DoNCPaint(pwnd, hDC, Flags); // Redraw without MENUs.
UserReleaseDC(pwnd, hDC, FALSE);
prgn = REGION_LockRgn(hrgnTemp);
IntInvalidateWindows(pwnd, prgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN);
REGION_UnlockRgn(prgn);
// Set updates for this window.
pwnd->state |= WNDS_SENDNCPAINT|WNDS_SENDERASEBACKGROUND|WNDS_UPDATEDIRTY;
// DCX_KEEPCLIPRGN is set. Check it anyway.
if (hrgnTemp > HRGN_WINDOW && GreIsHandleValid(hrgnTemp)) GreDeleteObject(hrgnTemp);
}
}
VOID FASTCALL
UpdateTheadChildren(PWND pWnd, HRGN hRgn)
{
PaintSuspendedWindow( pWnd, hRgn );
if (!(pWnd->style & WS_CLIPCHILDREN))
return;
pWnd = pWnd->spwndChild; // invalidate children if any.
while (pWnd)
{
UpdateTheadChildren( pWnd, hRgn );
pWnd = pWnd->spwndNext;
}
}
VOID FASTCALL
UpdateThreadWindows(PWND pWnd, PTHREADINFO pti, HRGN hRgn)
{
PWND pwndTemp;
for ( pwndTemp = pWnd;
pwndTemp;
pwndTemp = pwndTemp->spwndNext )
{
if (pwndTemp->head.pti == pti)
{
UserUpdateWindows(pwndTemp, RDW_ALLCHILDREN);
}
else
{
if (IsThreadSuspended(pwndTemp->head.pti) || MsqIsHung(pwndTemp->head.pti, MSQ_HUNG))
{
UpdateTheadChildren(pwndTemp, hRgn);
}
else
UserUpdateWindows(pwndTemp, RDW_ALLCHILDREN);
}
}
}
BOOL FASTCALL
IntIsWindowDirty(PWND Wnd)
{
return ( Wnd->style & WS_VISIBLE &&
( Wnd->hrgnUpdate != NULL ||
Wnd->state & WNDS_INTERNALPAINT ) );
}
/*
Conditions to paint any window:
1. Update region is not null.
2. Internal paint flag is set.
3. Paint count is not zero.
*/
PWND FASTCALL
IntFindWindowToRepaint(PWND Window, PTHREADINFO Thread)
{
PWND hChild;
PWND TempWindow;
for (; Window != NULL; Window = Window->spwndNext)
{
if (IntWndBelongsToThread(Window, Thread))
{
if (IntIsWindowDirty(Window))
{
/* Make sure all non-transparent siblings are already drawn. */
if (Window->ExStyle & WS_EX_TRANSPARENT)
{
for (TempWindow = Window->spwndNext; TempWindow != NULL;
TempWindow = TempWindow->spwndNext)
{
if (!(TempWindow->ExStyle & WS_EX_TRANSPARENT) &&
IntWndBelongsToThread(TempWindow, Thread) &&
IntIsWindowDirty(TempWindow))
{
return TempWindow;
}
}
}
return Window;
}
}
/* find a child of the specified window that needs repainting */
if (Window->spwndChild)
{
hChild = IntFindWindowToRepaint(Window->spwndChild, Thread);
if (hChild != NULL)
return hChild;
}
}
return Window;
}
//
// Internal painting of windows.
//
VOID FASTCALL
IntPaintWindow( PWND Window )
{
// Handle normal painting.
co_IntPaintWindows( Window, RDW_NOCHILDREN, FALSE );
}
BOOL FASTCALL
IntGetPaintMessage(
PWND Window,
UINT MsgFilterMin,
UINT MsgFilterMax,
PTHREADINFO Thread,
MSG *Message,
BOOL Remove)
{
PWND PaintWnd, StartWnd;
if ((MsgFilterMin != 0 || MsgFilterMax != 0) &&
(MsgFilterMin > WM_PAINT || MsgFilterMax < WM_PAINT))
return FALSE;
if (Thread->TIF_flags & TIF_SYSTEMTHREAD )
{
ERR("WM_PAINT is in a System Thread!\n");
}
StartWnd = UserGetDesktopWindow();
PaintWnd = IntFindWindowToRepaint(StartWnd, Thread);
Message->hwnd = PaintWnd ? UserHMGetHandle(PaintWnd) : NULL;
if (Message->hwnd == NULL && Thread->cPaintsReady)
{
// Find note in window.c:"PAINTING BUG".
ERR("WARNING SOMETHING HAS GONE WRONG: Thread marked as containing dirty windows, but no dirty windows found! Counts %u\n",Thread->cPaintsReady);
/* Hack to stop spamming the debug log ! */
Thread->cPaintsReady = 0;
return FALSE;
}
if (Message->hwnd == NULL)
return FALSE;
if (!(Window == NULL ||
PaintWnd == Window ||
IntIsChildWindow(Window, PaintWnd))) /* check that it is a child of the specified parent */
return FALSE;
if (PaintWnd->state & WNDS_INTERNALPAINT)
{
PaintWnd->state &= ~WNDS_INTERNALPAINT;
if (!PaintWnd->hrgnUpdate)
MsqDecPaintCountQueue(Thread);
}
PaintWnd->state2 &= ~WNDS2_STARTPAINT;
PaintWnd->state &= ~WNDS_UPDATEDIRTY;
Window = PaintWnd;
while (Window && !UserIsDesktopWindow(Window))
{
// Role back and check for clip children, do not set if any.
if (Window->spwndParent && !(Window->spwndParent->style & WS_CLIPCHILDREN))
{
PaintWnd->state2 |= WNDS2_WMPAINTSENT;
}
Window = Window->spwndParent;
}
Message->wParam = Message->lParam = 0;
Message->message = WM_PAINT;
return TRUE;
}
BOOL
FASTCALL
IntPrintWindow(
PWND pwnd,
HDC hdcBlt,
UINT nFlags)
{
HDC hdcSrc;
INT cx, cy, xSrc, ySrc;
if ( nFlags & PW_CLIENTONLY)
{
cx = pwnd->rcClient.right - pwnd->rcClient.left;
cy = pwnd->rcClient.bottom - pwnd->rcClient.top;
xSrc = pwnd->rcClient.left - pwnd->rcWindow.left;
ySrc = pwnd->rcClient.top - pwnd->rcWindow.top;
}
else
{
cx = pwnd->rcWindow.right - pwnd->rcWindow.left;
cy = pwnd->rcWindow.bottom - pwnd->rcWindow.top;
xSrc = 0;
ySrc = 0;
}
// TODO: Setup Redirection for Print.
return FALSE;
/* Update the window just incase. */
co_IntUpdateWindows( pwnd, RDW_ALLCHILDREN, FALSE);
hdcSrc = UserGetDCEx( pwnd, NULL, DCX_CACHE|DCX_WINDOW);
/* Print window to printer context. */
NtGdiBitBlt( hdcBlt,
0,
0,
cx,
cy,
hdcSrc,
xSrc,
ySrc,
SRCCOPY,
0,
0);
UserReleaseDC( pwnd, hdcSrc, FALSE);
// TODO: Release Redirection from Print.
return TRUE;
}
BOOL
FASTCALL
IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
{
DWORD_PTR FlashState;
UINT uCount = pfwi->uCount;
BOOL Activate = FALSE, Ret = FALSE;
ASSERT(pfwi);
FlashState = (DWORD_PTR)UserGetProp(pWnd, AtomFlashWndState, TRUE);
if (FlashState == FLASHW_FINISHED)
{
// Cycle has finished, kill timer and set this to Stop.
FlashState |= FLASHW_KILLSYSTIMER;
pfwi->dwFlags = FLASHW_STOP;
}
else
{
if (FlashState)
{
if (pfwi->dwFlags == FLASHW_SYSTIMER)
{
// Called from system timer, restore flags, counts and state.
pfwi->dwFlags = LOWORD(FlashState);
uCount = HIWORD(FlashState);
FlashState = MAKELONG(LOWORD(FlashState),0);
}
else
{
// Clean out the trash! Fix SeaMonkey crash after restart.
FlashState = 0;
}
}
if (FlashState == 0)
{ // First time in cycle, setup flash state.
if ( pWnd->state & WNDS_ACTIVEFRAME ||
(pfwi->dwFlags & FLASHW_CAPTION && pWnd->style & (WS_BORDER|WS_DLGFRAME)))
{
FlashState = FLASHW_STARTED|FLASHW_ACTIVE;
}
}
// Set previous window state.
Ret = !!(FlashState & FLASHW_ACTIVE);
if ( (pfwi->dwFlags & FLASHW_TIMERNOFG) == FLASHW_TIMERNOFG &&
gpqForeground == pWnd->head.pti->MessageQueue )
{
// Flashing until foreground, set this to Stop.
pfwi->dwFlags = FLASHW_STOP;
}
}
// Toggle activate flag.
if ( pfwi->dwFlags == FLASHW_STOP )
{
if (gpqForeground && gpqForeground->spwndActive == pWnd)
Activate = TRUE;
else
Activate = FALSE;
}
else
{
Activate = (FlashState & FLASHW_ACTIVE) == 0;
}
if ( pfwi->dwFlags == FLASHW_STOP || pfwi->dwFlags & FLASHW_CAPTION )
{
co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCACTIVATE, Activate, 0);
}
// FIXME: Check for a Stop Sign here.
if ( pfwi->dwFlags & FLASHW_TRAY )
{
// Need some shell work here too.
TRACE("FIXME: Flash window no Tray support!\n");
}
if ( pfwi->dwFlags == FLASHW_STOP )
{
if (FlashState & FLASHW_KILLSYSTIMER)
{
IntKillTimer(pWnd, ID_EVENT_SYSTIMER_FLASHWIN, TRUE);
}
UserRemoveProp(pWnd, AtomFlashWndState, TRUE);
}
else
{ // Have a count and started, set timer.
if ( uCount )
{
FlashState |= FLASHW_COUNT;
if (!(Activate ^ !!(FlashState & FLASHW_STARTED)))
uCount--;
if (!(FlashState & FLASHW_KILLSYSTIMER))
pfwi->dwFlags |= FLASHW_TIMER;
}
if (pfwi->dwFlags & FLASHW_TIMER)
{
FlashState |= FLASHW_KILLSYSTIMER;
IntSetTimer( pWnd,
ID_EVENT_SYSTIMER_FLASHWIN,
pfwi->dwTimeout ? pfwi->dwTimeout : gpsi->dtCaretBlink,
SystemTimerProc,
TMRF_SYSTEM );
}
if (FlashState & FLASHW_COUNT && uCount == 0)
{
// Keep spinning? Nothing else to do.
FlashState = FLASHW_FINISHED;
}
else
{
// Save state and flags so this can be restored next time through.
FlashState ^= (FlashState ^ -!!(Activate)) & FLASHW_ACTIVE;
FlashState ^= (FlashState ^ pfwi->dwFlags) & (FLASHW_MASK & ~FLASHW_TIMER);
}
FlashState = MAKELONG(LOWORD(FlashState),uCount);
UserSetProp(pWnd, AtomFlashWndState, (HANDLE)FlashState, TRUE);
}
return Ret;
}
// Win: xxxBeginPaint
HDC FASTCALL
IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
{
RECT Rect;
INT type;
BOOL Erase = FALSE;
co_UserHideCaret(Window);
Window->state2 |= WNDS2_STARTPAINT;
Window->state &= ~WNDS_PAINTNOTPROCESSED;
if (Window->state & WNDS_SENDNCPAINT)
{
HRGN hRgn;
// Application can keep update dirty.
do
{
Window->state &= ~WNDS_UPDATEDIRTY;
hRgn = IntGetNCUpdateRgn(Window, FALSE);
IntSendNCPaint(Window, hRgn);
if (hRgn > HRGN_WINDOW && GreIsHandleValid(hRgn))
{
/* NOTE: The region can already be deleted! */
GreDeleteObject(hRgn);
}
}
while(Window->state & WNDS_UPDATEDIRTY);
}
else
{
Window->state &= ~WNDS_UPDATEDIRTY;
}
RtlZeroMemory(Ps, sizeof(PAINTSTRUCT));
if (Window->state2 & WNDS2_ENDPAINTINVALIDATE)
{
ERR("BP: Another thread invalidated this window\n");
}
Ps->hdc = UserGetDCEx( Window,
Window->hrgnUpdate,
DCX_INTERSECTRGN | DCX_USESTYLE);
if (!Ps->hdc)
{
return NULL;
}
// If set, always clear flags out due to the conditions later on for sending the message.
if (Window->state & WNDS_SENDERASEBACKGROUND)
{
Window->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
Erase = TRUE;
}
if (Window->hrgnUpdate != NULL)
{
MsqDecPaintCountQueue(Window->head.pti);
IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
/* The region is part of the dc now and belongs to the process! */
Window->hrgnUpdate = NULL;
}
else
{
if (Window->state & WNDS_INTERNALPAINT)
MsqDecPaintCountQueue(Window->head.pti);
}
type = GdiGetClipBox(Ps->hdc, &Ps->rcPaint);
IntGetClientRect(Window, &Rect);
Window->state &= ~WNDS_INTERNALPAINT;
if ( Erase && // Set to erase,
type != NULLREGION && // don't erase if the clip box is empty,
(!(Window->pcls->style & CS_PARENTDC) || // not parent dc or
RECTL_bIntersectRect( &Rect, &Rect, &Ps->rcPaint) ) ) // intersecting.
{
Ps->fErase = !co_IntSendMessage(UserHMGetHandle(Window), WM_ERASEBKGND, (WPARAM)Ps->hdc, 0);
if ( Ps->fErase )
{
Window->state |= (WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
}
}
else
{
Ps->fErase = FALSE;
}
IntSendChildNCPaint(Window);
return Ps->hdc;
}
// Win: xxxEndPaint
BOOL FASTCALL
IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
{
HDC hdc = NULL;
hdc = Ps->hdc;
UserReleaseDC(Wnd, hdc, TRUE);
if (Wnd->state2 & WNDS2_ENDPAINTINVALIDATE)
{
ERR("EP: Another thread invalidated this window\n");
Wnd->state2 &= ~WNDS2_ENDPAINTINVALIDATE;
}
Wnd->state2 &= ~(WNDS2_WMPAINTSENT|WNDS2_STARTPAINT);
co_UserShowCaret(Wnd);
return TRUE;
}
// Win: xxxFillWindow
BOOL FASTCALL
IntFillWindow(PWND pWndParent,
PWND pWnd,
HDC hDC,
HBRUSH hBrush)
{
RECT Rect, Rect1;
INT type;
if (!pWndParent)
pWndParent = pWnd;
type = GdiGetClipBox(hDC, &Rect);
IntGetClientRect(pWnd, &Rect1);
if ( type != NULLREGION && // Clip box is not empty,
(!(pWnd->pcls->style & CS_PARENTDC) || // not parent dc or
RECTL_bIntersectRect( &Rect, &Rect, &Rect1) ) ) // intersecting.
{
POINT ppt;
INT x = 0, y = 0;
if (!UserIsDesktopWindow(pWndParent))
{
x = pWndParent->rcClient.left - pWnd->rcClient.left;
y = pWndParent->rcClient.top - pWnd->rcClient.top;
}
GreSetBrushOrg(hDC, x, y, &ppt);
if ( hBrush < (HBRUSH)CTLCOLOR_MAX )
hBrush = GetControlColor( pWndParent, pWnd, hDC, HandleToUlong(hBrush) + WM_CTLCOLORMSGBOX);
FillRect(hDC, &Rect, hBrush);
GreSetBrushOrg(hDC, ppt.x, ppt.y, NULL);
return TRUE;
}
else
return FALSE;
}
/* PUBLIC FUNCTIONS ***********************************************************/
/*
* NtUserBeginPaint
*
* Status
* @implemented
*/
HDC APIENTRY
NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* UnsafePs)
{
PWND Window;
PAINTSTRUCT Ps;
NTSTATUS Status;
HDC hDC;
USER_REFERENCE_ENTRY Ref;
HDC Ret = NULL;
TRACE("Enter NtUserBeginPaint\n");
UserEnterExclusive();
if (!(Window = UserGetWindowObject(hWnd)))
{
goto Cleanup; // Return NULL
}
UserRefObjectCo(Window, &Ref);
hDC = IntBeginPaint(Window, &Ps);
Status = MmCopyToCaller(UnsafePs, &Ps, sizeof(PAINTSTRUCT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
goto Cleanup; // Return NULL
}
Ret = hDC;
Cleanup:
if (Window) UserDerefObjectCo(Window);
TRACE("Leave NtUserBeginPaint, ret=%p\n", Ret);
UserLeave();
return Ret;
}
/*
* NtUserEndPaint
*
* Status
* @implemented
*/
BOOL APIENTRY
NtUserEndPaint(HWND hWnd, CONST PAINTSTRUCT* pUnsafePs)
{
NTSTATUS Status = STATUS_SUCCESS;
PWND Window;
PAINTSTRUCT Ps;
USER_REFERENCE_ENTRY Ref;
BOOL Ret = FALSE;
TRACE("Enter NtUserEndPaint\n");
UserEnterExclusive();
if (!(Window = UserGetWindowObject(hWnd)))
{
goto Cleanup; // Return FALSE
}
UserRefObjectCo(Window, &Ref); // Here for the exception.
_SEH2_TRY
{
ProbeForRead(pUnsafePs, sizeof(*pUnsafePs), 1);
RtlCopyMemory(&Ps, pUnsafePs, sizeof(PAINTSTRUCT));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END
if (!NT_SUCCESS(Status))
{
goto Cleanup; // Return FALSE
}
Ret = IntEndPaint(Window, &Ps);
Cleanup:
if (Window) UserDerefObjectCo(Window);
TRACE("Leave NtUserEndPaint, ret=%i\n", Ret);
UserLeave();
return Ret;
}
/*
* FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
*/
/*
* @implemented
*/
BOOL APIENTRY
NtUserFillWindow(HWND hWndParent,
HWND hWnd,
HDC hDC,
HBRUSH hBrush)
{
BOOL ret = FALSE;
PWND pWnd, pWndParent = NULL;
USER_REFERENCE_ENTRY Ref;
TRACE("Enter NtUserFillWindow\n");
UserEnterExclusive();
if (!hDC)
{
goto Exit;
}
if (!(pWnd = UserGetWindowObject(hWnd)))
{
goto Exit;
}
if (hWndParent && !(pWndParent = UserGetWindowObject(hWndParent)))
{
goto Exit;
}
UserRefObjectCo(pWnd, &Ref);
ret = IntFillWindow( pWndParent, pWnd, hDC, hBrush );
UserDerefObjectCo(pWnd);
Exit:
TRACE("Leave NtUserFillWindow, ret=%i\n",ret);
UserLeave();
return ret;
}
/*
* @implemented
*/
BOOL APIENTRY
NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
{
PWND pWnd;
FLASHWINFO finfo = {0};
BOOL Ret = FALSE;
UserEnterExclusive();
_SEH2_TRY
{
ProbeForRead(pfwi, sizeof(FLASHWINFO), 1);
RtlCopyMemory(&finfo, pfwi, sizeof(FLASHWINFO));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
SetLastNtError(_SEH2_GetExceptionCode());
_SEH2_YIELD(goto Exit);
}
_SEH2_END
if (!( pWnd = ValidateHwndNoErr(finfo.hwnd)) ||
finfo.cbSize != sizeof(FLASHWINFO) ||
finfo.dwFlags & ~(FLASHW_ALL|FLASHW_TIMER|FLASHW_TIMERNOFG) )
{
EngSetLastError(ERROR_INVALID_PARAMETER);
goto Exit;
}
Ret = IntFlashWindowEx(pWnd, &finfo);
Exit:
UserLeave();
return Ret;
}
/*
GetUpdateRgn, this fails the same as the old one.
*/
INT FASTCALL
co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
{
int RegionType;
BOOL Type;
RECTL Rect;
ASSERT_REFS_CO(Window);
if (bErase)
{
USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Window, &Ref);
co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
UserDerefObjectCo(Window);
}
Window->state &= ~WNDS_UPDATEDIRTY;
if (Window->hrgnUpdate == NULL)
{
NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
return NULLREGION;
}
Rect = Window->rcClient;
Type = IntIntersectWithParents(Window, &Rect);
if (Window->hrgnUpdate == HRGN_WINDOW)
{
// Trap it out.
ERR("GURn: Caller is passing Window Region 1\n");
if (!Type)
{
NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
return NULLREGION;
}
RegionType = SIMPLEREGION;
if (!UserIsDesktopWindow(Window))
{
RECTL_vOffsetRect(&Rect,
-Window->rcClient.left,
-Window->rcClient.top);
}
GreSetRectRgnIndirect(hRgn, &Rect);
}
else
{
HRGN hrgnTemp = GreCreateRectRgnIndirect(&Rect);
RegionType = NtGdiCombineRgn(hRgn, hrgnTemp, Window->hrgnUpdate, RGN_AND);
if (RegionType == ERROR || RegionType == NULLREGION)
{
if (hrgnTemp) GreDeleteObject(hrgnTemp);
NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
return RegionType;
}
if (!UserIsDesktopWindow(Window))
{
NtGdiOffsetRgn(hRgn,
-Window->rcClient.left,
-Window->rcClient.top);
}
if (hrgnTemp) GreDeleteObject(hrgnTemp);
}
return RegionType;
}
BOOL FASTCALL
co_UserGetUpdateRect(PWND Window, PRECT pRect, BOOL bErase)
{
INT RegionType;
BOOL Ret = TRUE;
if (bErase)
{
USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Window, &Ref);
co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
UserDerefObjectCo(Window);
}
Window->state &= ~WNDS_UPDATEDIRTY;
if (Window->hrgnUpdate == NULL)
{
pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
Ret = FALSE;
}
else
{
/* Get the update region bounding box. */
if (Window->hrgnUpdate == HRGN_WINDOW)
{
*pRect = Window->rcClient;
ERR("GURt: Caller is retrieving Window Region 1\n");
}
else
{
RegionType = IntGdiGetRgnBox(Window->hrgnUpdate, pRect);
if (RegionType != ERROR && RegionType != NULLREGION)
RECTL_bIntersectRect(pRect, pRect, &Window->rcClient);
}
if (IntIntersectWithParents(Window, pRect))
{
if (!UserIsDesktopWindow(Window))
{
RECTL_vOffsetRect(pRect,
-Window->rcClient.left,
-Window->rcClient.top);
}
if (Window->pcls->style & CS_OWNDC)
{
HDC hdc;
//DWORD layout;
hdc = UserGetDCEx(Window, NULL, DCX_USESTYLE);
//layout = NtGdiSetLayout(hdc, -1, 0);
//IntMapWindowPoints( 0, Window, (LPPOINT)pRect, 2 );
GreDPtoLP( hdc, (LPPOINT)pRect, 2 );
//NtGdiSetLayout(hdc, -1, layout);
UserReleaseDC(Window, hdc, FALSE);
}
}
else
{
pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
}
}
return Ret;
}
/*
* NtUserGetUpdateRgn
*
* Status
* @implemented
*/
INT APIENTRY
NtUserGetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
{
PWND Window;
INT ret = ERROR;
TRACE("Enter NtUserGetUpdateRgn\n");
UserEnterExclusive();
Window = UserGetWindowObject(hWnd);
if (Window)
{
ret = co_UserGetUpdateRgn(Window, hRgn, bErase);
}
TRACE("Leave NtUserGetUpdateRgn, ret=%i\n", ret);
UserLeave();
return ret;
}
/*
* NtUserGetUpdateRect
*
* Status
* @implemented
*/
BOOL APIENTRY
NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
{
PWND Window;
RECTL Rect;
NTSTATUS Status;
BOOL Ret = FALSE;
TRACE("Enter NtUserGetUpdateRect\n");
UserEnterExclusive();
if (!(Window = UserGetWindowObject(hWnd)))
{
goto Exit; // Return FALSE
}
Ret = co_UserGetUpdateRect(Window, &Rect, bErase);
if (UnsafeRect != NULL)
{
Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECTL));
if (!NT_SUCCESS(Status))
{
EngSetLastError(ERROR_INVALID_PARAMETER);
Ret = FALSE;
}
}
Exit:
TRACE("Leave NtUserGetUpdateRect, ret=%i\n", Ret);
UserLeave();
return Ret;
}
/*
* NtUserRedrawWindow
*
* Status
* @implemented
*/
BOOL APIENTRY
NtUserRedrawWindow(
HWND hWnd,
CONST RECT *lprcUpdate,
HRGN hrgnUpdate,
UINT flags)
{
RECTL SafeUpdateRect;
PWND Wnd;
BOOL Ret = FALSE;
USER_REFERENCE_ENTRY Ref;
NTSTATUS Status = STATUS_SUCCESS;
PREGION RgnUpdate = NULL;
TRACE("Enter NtUserRedrawWindow\n");
UserEnterExclusive();
if (!(Wnd = UserGetWindowObject(hWnd ? hWnd : IntGetDesktopWindow())))
{
goto Exit; // Return FALSE
}
if (lprcUpdate)
{
_SEH2_TRY
{
ProbeForRead(lprcUpdate, sizeof(RECTL), 1);
RtlCopyMemory(&SafeUpdateRect, lprcUpdate, sizeof(RECTL));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END
if (!NT_SUCCESS(Status))
{
EngSetLastError(RtlNtStatusToDosError(Status));
goto Exit; // Return FALSE
}
}
if ( flags & ~(RDW_ERASE|RDW_FRAME|RDW_INTERNALPAINT|RDW_INVALIDATE|
RDW_NOERASE|RDW_NOFRAME|RDW_NOINTERNALPAINT|RDW_VALIDATE|
RDW_ERASENOW|RDW_UPDATENOW|RDW_ALLCHILDREN|RDW_NOCHILDREN) )
{
/* RedrawWindow fails only in case that flags are invalid */
EngSetLastError(ERROR_INVALID_FLAGS);
goto Exit; // Return FALSE
}
/* We can't hold lock on GDI objects while doing roundtrips to user mode,
* so it will be copied.
*/
if (hrgnUpdate > HRGN_WINDOW)
{
RgnUpdate = REGION_LockRgn(hrgnUpdate);
if (!RgnUpdate)
{
EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto Exit; // Return FALSE
}
REGION_UnlockRgn(RgnUpdate);
}
else if (hrgnUpdate == HRGN_WINDOW) // Trap it out.
{
ERR("NTRW: Caller is passing Window Region 1\n");
}
UserRefObjectCo(Wnd, &Ref);
Ret = co_UserRedrawWindow( Wnd,
lprcUpdate ? &SafeUpdateRect : NULL,
RgnUpdate,
flags);
UserDerefObjectCo(Wnd);
Exit:
TRACE("Leave NtUserRedrawWindow, ret=%i\n", Ret);
UserLeave();
return Ret;
}
BOOL
UserDrawCaptionText(
PWND pWnd,
HDC hDc,
const PUNICODE_STRING Text,
const RECTL *lpRc,
UINT uFlags,
HFONT hFont)
{
HFONT hOldFont = NULL;
COLORREF OldTextColor;
NONCLIENTMETRICSW nclm;
NTSTATUS Status;
BOOLEAN bDeleteFont = FALSE;
SIZE Size;
BOOL Ret = TRUE;
ULONG fit = 0, Length;
RECTL r = *lpRc;
TRACE("UserDrawCaptionText: %wZ\n", Text);
nclm.cbSize = sizeof(nclm);
if (!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0))
{
ERR("UserSystemParametersInfo() failed!\n");
return FALSE;
}
if (!hFont)
{
if(uFlags & DC_SMALLCAP)
Status = TextIntCreateFontIndirect(&nclm.lfSmCaptionFont, &hFont);
else
Status = TextIntCreateFontIndirect(&nclm.lfCaptionFont, &hFont);
if(!NT_SUCCESS(Status))
{
ERR("TextIntCreateFontIndirect() failed! Status: 0x%x\n", Status);
return FALSE;
}
bDeleteFont = TRUE;
}
IntGdiSetBkMode(hDc, TRANSPARENT);
hOldFont = NtGdiSelectFont(hDc, hFont);
if(uFlags & DC_INBUTTON)
OldTextColor = IntGdiSetTextColor(hDc, IntGetSysColor(COLOR_BTNTEXT));
else
OldTextColor = IntGdiSetTextColor(hDc,
IntGetSysColor(uFlags & DC_ACTIVE ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT));
// Adjust for system menu.
if (pWnd && pWnd->style & WS_SYSMENU)
{
r.right -= UserGetSystemMetrics(SM_CYCAPTION) - 1;
if ((pWnd->style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW))
{
r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
}
}
GreGetTextExtentExW(hDc, Text->Buffer, Text->Length/sizeof(WCHAR), r.right - r.left, &fit, 0, &Size, 0);
Length = (Text->Length/sizeof(WCHAR) == fit ? fit : fit+1);
if (Text->Length/sizeof(WCHAR) > Length)
{
Ret = FALSE;
}
if (Ret)
{ // Faster while in setup.
UserExtTextOutW( hDc,
lpRc->left,
lpRc->top + (lpRc->bottom - lpRc->top - Size.cy) / 2, // DT_SINGLELINE && DT_VCENTER
ETO_CLIPPED,
(RECTL *)lpRc,
Text->Buffer,
Length);
}
else
{
DrawTextW( hDc,
Text->Buffer,
Text->Length/sizeof(WCHAR),
(RECTL *)&r,
DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX|DT_LEFT);
}
IntGdiSetTextColor(hDc, OldTextColor);
if (hOldFont)
NtGdiSelectFont(hDc, hOldFont);
if (bDeleteFont)
GreDeleteObject(hFont);
return Ret;
}
//
// This draws Buttons, Icons and Text...
//
BOOL UserDrawCaption(
PWND pWnd,
HDC hDc,
RECTL *lpRc,
HFONT hFont,
HICON hIcon,
const PUNICODE_STRING Str,
UINT uFlags)
{
BOOL Ret = FALSE;
HBRUSH hBgBrush, hOldBrush = NULL;
RECTL Rect = *lpRc;
BOOL HasIcon;
RECTL_vMakeWellOrdered(lpRc);
/* Determine whether the icon needs to be displayed */
if (!hIcon && pWnd != NULL)
{
HasIcon = (uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP) &&
(pWnd->style & WS_SYSMENU) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW);
}
else
HasIcon = (hIcon != NULL);
// Draw the caption background
if((uFlags & DC_GRADIENT) && !(uFlags & DC_INBUTTON))
{
static GRADIENT_RECT gcap = {0, 1};
TRIVERTEX Vertices[2];
COLORREF Colors[2];
Colors[0] = IntGetSysColor((uFlags & DC_ACTIVE) ?
COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
Colors[1] = IntGetSysColor((uFlags & DC_ACTIVE) ?
COLOR_GRADIENTACTIVECAPTION : COLOR_GRADIENTINACTIVECAPTION);
Vertices[0].x = Rect.left;
Vertices[0].y = Rect.top;
Vertices[0].Red = (WORD)Colors[0]<<8;
Vertices[0].Green = (WORD)Colors[0] & 0xFF00;
Vertices[0].Blue = (WORD)(Colors[0]>>8) & 0xFF00;
Vertices[0].Alpha = 0;
Vertices[1].x = Rect.right;
Vertices[1].y = Rect.bottom;
Vertices[1].Red = (WORD)Colors[1]<<8;
Vertices[1].Green = (WORD)Colors[1] & 0xFF00;
Vertices[1].Blue = (WORD)(Colors[1]>>8) & 0xFF00;
Vertices[1].Alpha = 0;
if(!GreGradientFill(hDc, Vertices, 2, &gcap, 1, GRADIENT_FILL_RECT_H))
{
ERR("GreGradientFill() failed!\n");
goto cleanup;
}
}
else
{
if(uFlags & DC_INBUTTON)
hBgBrush = IntGetSysColorBrush(COLOR_3DFACE);
else if(uFlags & DC_ACTIVE)
hBgBrush = IntGetSysColorBrush(COLOR_ACTIVECAPTION);
else
hBgBrush = IntGetSysColorBrush(COLOR_INACTIVECAPTION);
hOldBrush = NtGdiSelectBrush(hDc, hBgBrush);
if(!hOldBrush)
{
ERR("NtGdiSelectBrush() failed!\n");
goto cleanup;
}
if(!NtGdiPatBlt(hDc, Rect.left, Rect.top,
Rect.right - Rect.left,
Rect.bottom - Rect.top,
PATCOPY))
{
ERR("NtGdiPatBlt() failed!\n");
goto cleanup;
}
}
/* Draw icon */
if (HasIcon)
{
PCURICON_OBJECT pIcon = NULL;
if (hIcon)
{
pIcon = UserGetCurIconObject(hIcon);
}
else if (pWnd)
{
pIcon = NC_IconForWindow(pWnd);
// FIXME: NC_IconForWindow should reference it for us */
if (pIcon)
UserReferenceObject(pIcon);
}
if (pIcon)
{
LONG cx = UserGetSystemMetrics(SM_CXSMICON);
LONG cy = UserGetSystemMetrics(SM_CYSMICON);
LONG x = Rect.left - cx/2 + 1 + (Rect.bottom - Rect.top)/2; // this is really what Window does
LONG y = (Rect.top + Rect.bottom - cy)/2; // center
UserDrawIconEx(hDc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
UserDereferenceObject(pIcon);
}
else
{
HasIcon = FALSE;
}
}
if (HasIcon)
Rect.left += Rect.bottom - Rect.top;
if((uFlags & DC_TEXT))
{
BOOL Set = FALSE;
Rect.left += 2;
if (Str)
Set = UserDrawCaptionText(pWnd, hDc, Str, &Rect, uFlags, hFont);
else if (pWnd != NULL) // FIXME: Windows does not do that
{
UNICODE_STRING ustr;
ustr.Buffer = pWnd->strName.Buffer; // FIXME: LARGE_STRING truncated!
ustr.Length = (USHORT)min(pWnd->strName.Length, MAXUSHORT);
ustr.MaximumLength = (USHORT)min(pWnd->strName.MaximumLength, MAXUSHORT);
Set = UserDrawCaptionText(pWnd, hDc, &ustr, &Rect, uFlags, hFont);
}
if (pWnd)
{
if (Set)
pWnd->state2 &= ~WNDS2_CAPTIONTEXTTRUNCATED;
else
pWnd->state2 |= WNDS2_CAPTIONTEXTTRUNCATED;
}
}
Ret = TRUE;
cleanup:
if (hOldBrush) NtGdiSelectBrush(hDc, hOldBrush);
return Ret;
}
INT
FASTCALL
UserRealizePalette(HDC hdc)
{
HWND hWnd, hWndDesktop;
DWORD Ret;
Ret = IntGdiRealizePalette(hdc);
if (Ret) // There was a change.
{
hWnd = IntWindowFromDC(hdc);
if (hWnd) // Send broadcast if dc is associated with a window.
{ // FYI: Thread locked in CallOneParam.
hWndDesktop = IntGetDesktopWindow();
if ( hWndDesktop != hWnd )
{
PWND pWnd = UserGetWindowObject(hWndDesktop);
ERR("RealizePalette Desktop.\n");
hdc = UserGetWindowDC(pWnd);
IntPaintDesktop(hdc);
UserReleaseDC(pWnd,hdc,FALSE);
}
UserSendNotifyMessage((HWND)HWND_BROADCAST, WM_PALETTECHANGED, (WPARAM)hWnd, 0);
}
}
return Ret;
}
BOOL
APIENTRY
NtUserDrawCaptionTemp(
HWND hWnd,
HDC hDC,
LPCRECT lpRc,
HFONT hFont,
HICON hIcon,
const PUNICODE_STRING str,
UINT uFlags)
{
PWND pWnd = NULL;
UNICODE_STRING SafeStr = {0};
NTSTATUS Status = STATUS_SUCCESS;
RECTL SafeRect;
BOOL Ret;
UserEnterExclusive();
if (hWnd != NULL)
{
if(!(pWnd = UserGetWindowObject(hWnd)))
{
UserLeave();
return FALSE;
}
}
_SEH2_TRY
{
ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
if (str != NULL)
{
SafeStr = ProbeForReadUnicodeString(str);
if (SafeStr.Length != 0)
{
ProbeForRead( SafeStr.Buffer,
SafeStr.Length,
sizeof(WCHAR));
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (Status != STATUS_SUCCESS)
{
SetLastNtError(Status);
UserLeave();
return FALSE;
}
if (str != NULL)
Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
else
{
if ( RECTL_bIsEmptyRect(&SafeRect) && hFont == 0 && hIcon == 0 )
{
Ret = TRUE;
if (uFlags & DC_DRAWCAPTIONMD)
{
ERR("NC Caption Mode\n");
UserDrawCaptionBar(pWnd, hDC, uFlags);
goto Exit;
}
else if (uFlags & DC_DRAWFRAMEMD)
{
ERR("NC Paint Mode\n");
NC_DoNCPaint(pWnd, hDC, uFlags); // Update Menus too!
goto Exit;
}
}
Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
}
Exit:
UserLeave();
return Ret;
}
BOOL
APIENTRY
NtUserDrawCaption(HWND hWnd,
HDC hDC,
LPCRECT lpRc,
UINT uFlags)
{
return NtUserDrawCaptionTemp(hWnd, hDC, lpRc, 0, 0, NULL, uFlags);
}
INT FASTCALL
co_UserExcludeUpdateRgn(HDC hDC, PWND Window)
{
POINT pt;
RECT rc;
if (Window->hrgnUpdate)
{
if (Window->hrgnUpdate == HRGN_WINDOW)
{
return NtGdiIntersectClipRect(hDC, 0, 0, 0, 0);
}
else
{
INT ret = ERROR;
HRGN hrgn = NtGdiCreateRectRgn(0,0,0,0);
if ( hrgn && GreGetDCPoint( hDC, GdiGetDCOrg, &pt) )
{
if ( NtGdiGetRandomRgn( hDC, hrgn, CLIPRGN) == NULLREGION )
{
NtGdiOffsetRgn(hrgn, pt.x, pt.y);
}
else
{
HRGN hrgnScreen;
PMONITOR pm = UserGetPrimaryMonitor();
hrgnScreen = NtGdiCreateRectRgn(0,0,0,0);
NtGdiCombineRgn(hrgnScreen, hrgnScreen, pm->hrgnMonitor, RGN_OR);
NtGdiCombineRgn(hrgn, hrgnScreen, NULL, RGN_COPY);
GreDeleteObject(hrgnScreen);
}
NtGdiCombineRgn(hrgn, hrgn, Window->hrgnUpdate, RGN_DIFF);
NtGdiOffsetRgn(hrgn, -pt.x, -pt.y);
ret = NtGdiExtSelectClipRgn(hDC, hrgn, RGN_COPY);
GreDeleteObject(hrgn);
}
return ret;
}
}
else
{
return GdiGetClipBox( hDC, &rc);
}
}
INT
APIENTRY
NtUserExcludeUpdateRgn(
HDC hDC,
HWND hWnd)
{
INT ret = ERROR;
PWND pWnd;
TRACE("Enter NtUserExcludeUpdateRgn\n");
UserEnterExclusive();
pWnd = UserGetWindowObject(hWnd);
if (hDC && pWnd)
ret = co_UserExcludeUpdateRgn(hDC, pWnd);
TRACE("Leave NtUserExcludeUpdateRgn, ret=%i\n", ret);
UserLeave();
return ret;
}
BOOL
APIENTRY
NtUserInvalidateRect(
HWND hWnd,
CONST RECT *lpUnsafeRect,
BOOL bErase)
{
UINT flags = RDW_INVALIDATE | (bErase ? RDW_ERASE : 0);
if (!hWnd)
{
flags = RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW;
lpUnsafeRect = NULL;
}
return NtUserRedrawWindow(hWnd, lpUnsafeRect, NULL, flags);
}
BOOL
APIENTRY
NtUserInvalidateRgn(
HWND hWnd,
HRGN hRgn,
BOOL bErase)
{
if (!hWnd)
{
EngSetLastError( ERROR_INVALID_WINDOW_HANDLE );
return FALSE;
}
return NtUserRedrawWindow(hWnd, NULL, hRgn, RDW_INVALIDATE | (bErase? RDW_ERASE : 0));
}
BOOL
APIENTRY
NtUserPrintWindow(
HWND hwnd,
HDC hdcBlt,
UINT nFlags)
{
PWND Window;
BOOL Ret = FALSE;
UserEnterExclusive();
if (hwnd)
{
if (!(Window = UserGetWindowObject(hwnd)) ||
UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
{
goto Exit;
}
if ( Window )
{
/* Validate flags and check it as a mask for 0 or 1. */
if ( (nFlags & PW_CLIENTONLY) == nFlags)
Ret = IntPrintWindow( Window, hdcBlt, nFlags);
else
EngSetLastError(ERROR_INVALID_PARAMETER);
}
}
Exit:
UserLeave();
return Ret;
}
/* ValidateRect gets redirected to NtUserValidateRect:
http://blog.csdn.net/ntdll/archive/2005/10/19/509299.aspx */
BOOL
APIENTRY
NtUserValidateRect(
HWND hWnd,
const RECT *lpRect)
{
UINT flags = RDW_VALIDATE;
if (!hWnd)
{
flags = RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW;
lpRect = NULL;
}
return NtUserRedrawWindow(hWnd, lpRect, NULL, flags);
}
/* EOF */
Reference in a new issue View git blame Copy permalink