ReactOS 0.4.15-dev-7788-g1ad9096
painting.c File Reference
#include <win32k.h>
Include dependency graph for painting.c:

Go to the source code of this file.

Functions

 DBG_DEFAULT_CHANNEL (UserPainting)
 
BOOL UserExtTextOutW (HDC hdc, INT x, INT y, UINT flags, PRECTL lprc, LPCWSTR lpString, UINT count)
 
IntIntersectWithParents

Intersect window rectangle with all parent client rectangles.

Parameters
ChildPointer to child window to start intersecting from.
WindowRectPointer to rectangle that we want to intersect in screen coordinates on input and intersected rectangle on output (if TRUE is returned).
Returns
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)
 
BOOL FASTCALL IntValidateParents (PWND Child, BOOL Recurse)
 
VOID FASTCALL IntSendSyncPaint (PWND Wnd, ULONG Flags)
 
HRGN FASTCALL IntCalcWindowRgn (PWND Wnd, BOOL Client)
 
HRGN FASTCALL IntGetNCUpdateRgn (PWND Window, BOOL Validate)
 
VOID FASTCALL IntSendNCPaint (PWND pWnd, HRGN hRgn)
 
VOID FASTCALL IntSendChildNCPaint (PWND pWnd)
 
VOID FASTCALL co_IntPaintWindows (PWND Wnd, ULONG Flags, BOOL Recurse)
 
VOID FASTCALL co_IntUpdateWindows (PWND Wnd, ULONG Flags, BOOL Recurse)
 
VOID FASTCALL UserUpdateWindows (PWND pWnd, ULONG Flags)
 
VOID FASTCALL UserSyncAndPaintWindows (PWND pWnd, ULONG Flags)
 
VOID FASTCALL IntInvalidateWindows (PWND Wnd, PREGION Rgn, ULONG Flags)
 
BOOL FASTCALL IntIsWindowDrawable (PWND Wnd)
 
BOOL FASTCALL co_UserRedrawWindow (PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
 
VOID FASTCALL PaintSuspendedWindow (PWND pwnd, HRGN hrgnOrig)
 
VOID FASTCALL UpdateTheadChildren (PWND pWnd, HRGN hRgn)
 
VOID FASTCALL UpdateThreadWindows (PWND pWnd, PTHREADINFO pti, HRGN hRgn)
 
BOOL FASTCALL IntIsWindowDirty (PWND Wnd)
 
PWND FASTCALL IntFindWindowToRepaint (PWND Window, PTHREADINFO Thread)
 
VOID FASTCALL IntPaintWindow (PWND Window)
 
BOOL FASTCALL IntGetPaintMessage (PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, PTHREADINFO Thread, MSG *Message, BOOL Remove)
 
BOOL FASTCALL IntPrintWindow (PWND pwnd, HDC hdcBlt, UINT nFlags)
 
BOOL FASTCALL IntFlashWindowEx (PWND pWnd, PFLASHWINFO pfwi)
 
HDC FASTCALL IntBeginPaint (PWND Window, PPAINTSTRUCT Ps)
 
BOOL FASTCALL IntEndPaint (PWND Wnd, PPAINTSTRUCT Ps)
 
BOOL FASTCALL IntFillWindow (PWND pWndParent, PWND pWnd, HDC hDC, HBRUSH hBrush)
 
HDC APIENTRY NtUserBeginPaint (HWND hWnd, PAINTSTRUCT *UnsafePs)
 
BOOL APIENTRY NtUserEndPaint (HWND hWnd, CONST PAINTSTRUCT *pUnsafePs)
 
BOOL APIENTRY NtUserFillWindow (HWND hWndParent, HWND hWnd, HDC hDC, HBRUSH hBrush)
 
BOOL APIENTRY NtUserFlashWindowEx (IN PFLASHWINFO pfwi)
 
INT FASTCALL co_UserGetUpdateRgn (PWND Window, HRGN hRgn, BOOL bErase)
 
BOOL FASTCALL co_UserGetUpdateRect (PWND Window, PRECT pRect, BOOL bErase)
 
INT APIENTRY NtUserGetUpdateRgn (HWND hWnd, HRGN hRgn, BOOL bErase)
 
BOOL APIENTRY NtUserGetUpdateRect (HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
 
BOOL APIENTRY NtUserRedrawWindow (HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags)
 
BOOL UserDrawCaptionText (PWND pWnd, HDC hDc, const PUNICODE_STRING Text, const RECTL *lpRc, UINT uFlags, HFONT hFont)
 
BOOL UserDrawCaption (PWND pWnd, HDC hDc, RECTL *lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING Str, UINT uFlags)
 
INT FASTCALL UserRealizePalette (HDC hdc)
 
BOOL APIENTRY NtUserDrawCaptionTemp (HWND hWnd, HDC hDC, LPCRECT lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING str, UINT uFlags)
 
BOOL APIENTRY NtUserDrawCaption (HWND hWnd, HDC hDC, LPCRECT lpRc, UINT uFlags)
 
INT FASTCALL co_UserExcludeUpdateRgn (HDC hDC, PWND Window)
 
INT APIENTRY NtUserExcludeUpdateRgn (HDC hDC, HWND hWnd)
 
BOOL APIENTRY NtUserInvalidateRect (HWND hWnd, CONST RECT *lpUnsafeRect, BOOL bErase)
 
BOOL APIENTRY NtUserInvalidateRgn (HWND hWnd, HRGN hRgn, BOOL bErase)
 
BOOL APIENTRY NtUserPrintWindow (HWND hwnd, HDC hdcBlt, UINT nFlags)
 
BOOL APIENTRY NtUserValidateRect (HWND hWnd, const RECT *lpRect)
 

Function Documentation

◆ co_IntPaintWindows()

VOID FASTCALL co_IntPaintWindows ( PWND  Wnd,
ULONG  Flags,
BOOL  Recurse 
)

Definition at line 403 of file painting.c.

404{
405 HDC hDC;
407 HRGN TempRegion = NULL;
408
409 Wnd->state &= ~WNDS_PAINTNOTPROCESSED;
410
411 if (Wnd->state & WNDS_SENDNCPAINT ||
413 {
414 if (!(Wnd->style & WS_VISIBLE))
415 {
417 return;
418 }
419 else
420 {
421 if (Wnd->hrgnUpdate == NULL)
422 {
424 }
425
426 if (Wnd->head.pti == PsGetCurrentThreadWin32Thread())
427 {
428 if (Wnd->state & WNDS_SENDNCPAINT)
429 {
430 TempRegion = IntGetNCUpdateRgn(Wnd, TRUE);
431
432 IntSendNCPaint(Wnd, TempRegion);
433
434 if (TempRegion > HRGN_WINDOW && GreIsHandleValid(TempRegion))
435 {
436 /* NOTE: The region can already be deleted! */
437 GreDeleteObject(TempRegion);
438 }
439 }
440
442 {
444 if (Wnd->hrgnUpdate)
445 {
446 hDC = UserGetDCEx( Wnd,
447 Wnd->hrgnUpdate,
449
450 if (Wnd->head.pti->ppi != pti->ppi)
451 {
452 ERR("Sending DC to another Process!!!\n");
453 }
454
456 // Kill the loop, so Clear before we send.
458 {
460 }
461 UserReleaseDC(Wnd, hDC, FALSE);
462 }
463 }
464 }
465
466 }
467 }
468
469 /*
470 * Check that the window is still valid at this point
471 */
472 if (!IntIsWindow(hWnd))
473 {
474 return;
475 }
476
477 /*
478 * Paint child windows.
479 */
480
481 if (!(Flags & RDW_NOCHILDREN) &&
482 !(Wnd->style & WS_MINIMIZE) &&
485 {
486 HWND *List, *phWnd;
488
489 if ((List = IntWinListChildren(Wnd)))
490 {
491 for (phWnd = List; *phWnd; ++phWnd)
492 {
493 if ((Wnd = UserGetWindowObject(*phWnd)) == NULL)
494 continue;
495
496 if (Wnd->head.pti != pti && Wnd->style & WS_CHILD)
497 continue;
498
499 if (Wnd->style & WS_VISIBLE)
500 {
502 UserRefObjectCo(Wnd, &Ref);
505 }
506 }
508 }
509 }
510}
static HDC hDC
Definition: 3dtext.c:33
#define DCX_USESTYLE
Definition: GetDCEx.c:10
HWND hWnd
Definition: settings.c:17
#define ERR(fmt,...)
Definition: debug.h:110
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define WNDS_SENDNCPAINT
Definition: ntuser.h:616
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define WNDS_ERASEBACKGROUND
Definition: ntuser.h:615
#define HRGN_WINDOW
Definition: ntuser.h:361
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:614
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
static HDC
Definition: imagelist.c:92
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
#define RDW_CLIPCHILDREN
Definition: painting.h:15
#define WS_CHILD
Definition: pedump.c:617
#define WS_MINIMIZE
Definition: pedump.c:622
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_CLIPCHILDREN
Definition: pedump.c:619
PPROCESSINFO ppi
Definition: win32.h:88
Definition: object.h:4
THRDESKHEAD head
Definition: ntuser.h:695
DWORD style
Definition: ntuser.h:706
HRGN hrgnUpdate
Definition: ntuser.h:721
DWORD state
Definition: ntuser.h:701
#define DCX_KEEPCLIPRGN
Definition: undocuser.h:68
HRGN FASTCALL IntGetNCUpdateRgn(PWND Window, BOOL Validate)
Definition: painting.c:260
VOID FASTCALL IntSendNCPaint(PWND pWnd, HRGN hRgn)
Definition: painting.c:348
VOID FASTCALL co_IntPaintWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:403
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
BOOL NTAPI GreIsHandleValid(HGDIOBJ hobj)
Definition: gdiobj.c:1146
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1445
#define USERTAG_WINDOWLIST
Definition: tags.h:298
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:274
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:176
UINT_PTR WPARAM
Definition: windef.h:207
#define WM_ERASEBKGND
Definition: winuser.h:1625
#define DCX_CACHE
Definition: winuser.h:2114
#define RDW_NOCHILDREN
Definition: winuser.h:1222
#define DCX_INTERSECTRGN
Definition: winuser.h:2122
#define RDW_ALLCHILDREN
Definition: winuser.h:1221
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by co_IntGetUpdateRgn(), co_IntPaintWindows(), co_IntUpdateWindows(), co_UserGetUpdateRect(), co_UserGetUpdateRgn(), co_WinPosSetWindowPos(), IntPaintWindow(), and UserSyncAndPaintWindows().

◆ co_IntUpdateWindows()

VOID FASTCALL co_IntUpdateWindows ( PWND  Wnd,
ULONG  Flags,
BOOL  Recurse 
)

Definition at line 519 of file painting.c.

520{
522
523 if ( Wnd->hrgnUpdate != NULL || Wnd->state & WNDS_INTERNALPAINT )
524 {
525 if (Wnd->hrgnUpdate)
526 {
527 if (!IntValidateParents(Wnd, Recurse))
528 {
529 return;
530 }
531 }
532
533 if (Wnd->state & WNDS_INTERNALPAINT)
534 {
535 Wnd->state &= ~WNDS_INTERNALPAINT;
536
537 if (Wnd->hrgnUpdate == NULL)
538 MsqDecPaintCountQueue(Wnd->head.pti);
539 }
540
542 Wnd->state &= ~WNDS_UPDATEDIRTY;
543
546
547 if (Wnd->state & WNDS_PAINTNOTPROCESSED)
548 {
550 UserRefObjectCo(Wnd, &Ref);
553 }
554 }
555
556 // Force flags as a toggle. Fixes msg:test_paint_messages:WmChildPaintNc.
557 Flags = (Flags & RDW_NOCHILDREN) ? RDW_NOCHILDREN : RDW_ALLCHILDREN; // All children is the default.
558
559 /*
560 * Update child windows.
561 */
562
563 if (!(Flags & RDW_NOCHILDREN) &&
566 {
567 PWND Child;
568
569 for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
570 {
571 /* transparent window, check for non-transparent sibling to paint first, then skip it */
572 if ( Child->ExStyle & WS_EX_TRANSPARENT &&
573 ( Child->hrgnUpdate != NULL || Child->state & WNDS_INTERNALPAINT ) )
574 {
575 PWND Next = Child->spwndNext;
576 while (Next)
577 {
578 if ( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT ) break;
579
580 Next = Next->spwndNext;
581 }
582
583 if (Next) continue;
584 }
585
586 if (Child->style & WS_VISIBLE)
587 {
589 UserRefObjectCo(Child, &Ref);
592 }
593 }
594 }
595}
#define WNDS_INTERNALPAINT
Definition: ntuser.h:617
#define WNDS2_WMPAINTSENT
Definition: ntuser.h:641
#define WNDS_PAINTNOTPROCESSED
Definition: ntuser.h:627
VOID FASTCALL MsqDecPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:508
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
Definition: ntuser.h:694
DWORD state2
Definition: ntuser.h:702
struct _WND * spwndChild
Definition: ntuser.h:714
struct _WND * spwndNext
Definition: ntuser.h:711
BOOL FASTCALL IntValidateParents(PWND Child, BOOL Recurse)
Definition: painting.c:62
VOID FASTCALL co_IntUpdateWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:519
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:536
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:194
#define WM_PAINT
Definition: winuser.h:1620

Referenced by co_IntUpdateWindows(), IntPrintWindow(), MENU_ShowPopup(), NC_DoButton(), NtUserCallHwndLock(), and UserUpdateWindows().

◆ co_UserExcludeUpdateRgn()

INT FASTCALL co_UserExcludeUpdateRgn ( HDC  hDC,
PWND  Window 
)

Definition at line 2459 of file painting.c.

2460{
2461 POINT pt;
2462 RECT rc;
2463
2464 if (Window->hrgnUpdate)
2465 {
2466 if (Window->hrgnUpdate == HRGN_WINDOW)
2467 {
2468 return NtGdiIntersectClipRect(hDC, 0, 0, 0, 0);
2469 }
2470 else
2471 {
2472 INT ret = ERROR;
2473 HRGN hrgn = NtGdiCreateRectRgn(0,0,0,0);
2474
2475 if ( hrgn && GreGetDCPoint( hDC, GdiGetDCOrg, &pt) )
2476 {
2478 {
2479 NtGdiOffsetRgn(hrgn, pt.x, pt.y);
2480 }
2481 else
2482 {
2483 HRGN hrgnScreen;
2485 hrgnScreen = NtGdiCreateRectRgn(0,0,0,0);
2486 NtGdiCombineRgn(hrgnScreen, hrgnScreen, pm->hrgnMonitor, RGN_OR);
2487
2488 NtGdiCombineRgn(hrgn, hrgnScreen, NULL, RGN_COPY);
2489
2490 GreDeleteObject(hrgnScreen);
2491 }
2492
2493 NtGdiCombineRgn(hrgn, hrgn, Window->hrgnUpdate, RGN_DIFF);
2494
2495 NtGdiOffsetRgn(hrgn, -pt.x, -pt.y);
2496
2498
2500 }
2501 return ret;
2502 }
2503 }
2504 else
2505 {
2506 return GdiGetClipBox( hDC, &rc);
2507 }
2508}
static HRGN hrgn
#define pt(x, y)
Definition: drawing.c:79
#define ERROR(name)
Definition: error_private.h:53
static LPMONITOREX pm
Definition: localmon.c:45
#define CLIPRGN
Definition: precomp.h:18
BOOL APIENTRY GreGetDCPoint(HDC hDC, UINT iPoint, PPOINTL Point)
Definition: coord.c:1291
__kernel_entry W32KAPI INT APIENTRY NtGdiCombineRgn(_In_ HRGN hrgnDst, _In_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ INT iMode)
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
__kernel_entry W32KAPI INT APIENTRY NtGdiExtSelectClipRgn(_In_ HDC hdc, _In_opt_ HRGN hrgn, _In_ INT iMode)
__kernel_entry W32KAPI INT APIENTRY NtGdiIntersectClipRect(_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: cliprgn.c:486
__kernel_entry W32KAPI INT APIENTRY NtGdiGetRandomRgn(_In_ HDC hdc, _In_ HRGN hrgn, _In_ INT iRgn)
__kernel_entry W32KAPI INT APIENTRY NtGdiOffsetRgn(_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:3961
@ GdiGetDCOrg
Definition: ntgdityp.h:80
Definition: window.c:28
int32_t INT
Definition: typedefs.h:58
int ret
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
#define RGN_DIFF
Definition: wingdi.h:358
#define NULLREGION
Definition: wingdi.h:361
#define RGN_COPY
Definition: wingdi.h:357
#define RGN_OR
Definition: wingdi.h:359

Referenced by NtUserExcludeUpdateRgn().

◆ co_UserGetUpdateRect()

BOOL FASTCALL co_UserGetUpdateRect ( PWND  Window,
PRECT  pRect,
BOOL  bErase 
)

Definition at line 1856 of file painting.c.

1857{
1859 BOOL Ret = TRUE;
1860
1861 if (bErase)
1862 {
1864 UserRefObjectCo(Window, &Ref);
1867 }
1868
1869 Window->state &= ~WNDS_UPDATEDIRTY;
1870
1871 if (Window->hrgnUpdate == NULL)
1872 {
1873 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1874 Ret = FALSE;
1875 }
1876 else
1877 {
1878 /* Get the update region bounding box. */
1879 if (Window->hrgnUpdate == HRGN_WINDOW)
1880 {
1881 *pRect = Window->rcClient;
1882 ERR("GURt: Caller is retrieving Window Region 1\n");
1883 }
1884 else
1885 {
1886 RegionType = IntGdiGetRgnBox(Window->hrgnUpdate, pRect);
1887
1889 RECTL_bIntersectRect(pRect, pRect, &Window->rcClient);
1890 }
1891
1892 if (IntIntersectWithParents(Window, pRect))
1893 {
1895 {
1896 RECTL_vOffsetRect(pRect,
1897 -Window->rcClient.left,
1898 -Window->rcClient.top);
1899 }
1900 if (Window->pcls->style & CS_OWNDC)
1901 {
1902 HDC hdc;
1903 //DWORD layout;
1905 //layout = NtGdiSetLayout(hdc, -1, 0);
1906 //IntMapWindowPoints( 0, Window, (LPPOINT)pRect, 2 );
1907 GreDPtoLP( hdc, (LPPOINT)pRect, 2 );
1908 //NtGdiSetLayout(hdc, -1, layout);
1910 }
1911 }
1912 else
1913 {
1914 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1915 }
1916 }
1917 return Ret;
1918}
BOOL FASTCALL GreDPtoLP(HDC, LPPOINT, INT)
Definition: dcutil.c:7
unsigned int BOOL
Definition: ntddk_ex.h:94
RegionType
HDC hdc
Definition: main.c:9
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
BOOL FASTCALL IntIntersectWithParents(PWND Child, RECTL *WindowRect)
Definition: painting.c:35
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
INT APIENTRY IntGdiGetRgnBox(HRGN hRgn, PRECTL pRect)
Definition: region.c:2561
#define CS_OWNDC
Definition: winuser.h:655

Referenced by NtUserGetUpdateRect().

◆ co_UserGetUpdateRgn()

INT FASTCALL co_UserGetUpdateRgn ( PWND  Window,
HRGN  hRgn,
BOOL  bErase 
)

Definition at line 1784 of file painting.c.

1785{
1786 int RegionType;
1787 BOOL Type;
1788 RECTL Rect;
1789
1791
1792 if (bErase)
1793 {
1795 UserRefObjectCo(Window, &Ref);
1798 }
1799
1800 Window->state &= ~WNDS_UPDATEDIRTY;
1801
1802 if (Window->hrgnUpdate == NULL)
1803 {
1804 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1805 return NULLREGION;
1806 }
1807
1808 Rect = Window->rcClient;
1810
1811 if (Window->hrgnUpdate == HRGN_WINDOW)
1812 {
1813 // Trap it out.
1814 ERR("GURn: Caller is passing Window Region 1\n");
1815 if (!Type)
1816 {
1817 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1818 return NULLREGION;
1819 }
1820
1822
1824 {
1826 -Window->rcClient.left,
1827 -Window->rcClient.top);
1828 }
1830 }
1831 else
1832 {
1833 HRGN hrgnTemp = GreCreateRectRgnIndirect(&Rect);
1834
1835 RegionType = NtGdiCombineRgn(hRgn, hrgnTemp, Window->hrgnUpdate, RGN_AND);
1836
1838 {
1839 if (hrgnTemp) GreDeleteObject(hrgnTemp);
1840 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1841 return RegionType;
1842 }
1843
1845 {
1847 -Window->rcClient.left,
1848 -Window->rcClient.top);
1849 }
1850 if (hrgnTemp) GreDeleteObject(hrgnTemp);
1851 }
1852 return RegionType;
1853}
Type
Definition: Type.h:7
static HRGN hRgn
Definition: mapping.c:33
__kernel_entry W32KAPI BOOL APIENTRY NtGdiSetRectRgn(_In_ HRGN hrgn, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: region.c:4048
#define GreCreateRectRgnIndirect(prc)
Definition: region.h:96
#define GreSetRectRgnIndirect(hRgn, prc)
Definition: region.h:99
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:14
#define RGN_AND
Definition: wingdi.h:356
#define SIMPLEREGION
Definition: wingdi.h:362

Referenced by IntDefWindowProc(), and NtUserGetUpdateRgn().

◆ co_UserRedrawWindow()

BOOL FASTCALL co_UserRedrawWindow ( PWND  Window,
const RECTL UpdateRect,
PREGION  UpdateRgn,
ULONG  Flags 
)

Definition at line 888 of file painting.c.

893{
894 PREGION TmpRgn = NULL;
895 TRACE("co_UserRedrawWindow start Rgn %p\n",UpdateRgn);
896
897 /*
898 * Step 1.
899 * Validation of passed parameters.
900 */
901
903 {
904 return TRUE; // Just do nothing!!!
905 }
906
907 if (Window == NULL)
908 {
910 }
911
912 /*
913 * Step 2.
914 * Transform the parameters UpdateRgn and UpdateRect into
915 * a region hRgn specified in screen coordinates.
916 */
917
918 if (Flags & (RDW_INVALIDATE | RDW_VALIDATE)) // Both are OKAY!
919 {
920 /* We can't hold lock on GDI objects while doing roundtrips to user mode,
921 * so use a copy instead */
922 if (UpdateRgn)
923 {
924 TmpRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
925
926 if (UpdateRgn > PRGN_WINDOW)
927 {
928 IntGdiCombineRgn(TmpRgn, UpdateRgn, NULL, RGN_COPY);
929 }
930
932 {
933 REGION_bOffsetRgn(TmpRgn, Window->rcClient.left, Window->rcClient.top);
934 }
935 }
936 else
937 {
938 if (UpdateRect != NULL)
939 {
941 {
943 }
944 else
945 {
946 TmpRgn = IntSysCreateRectpRgn(Window->rcClient.left + UpdateRect->left,
947 Window->rcClient.top + UpdateRect->top,
948 Window->rcClient.left + UpdateRect->right,
949 Window->rcClient.top + UpdateRect->bottom);
950 }
951 }
952 else
953 {
956 {
957 if (!RECTL_bIsEmptyRect(&Window->rcWindow))
958 TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
959 }
960 else
961 {
962 if (!RECTL_bIsEmptyRect(&Window->rcClient))
963 TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcClient);
964 }
965 }
966 }
967 }
968
969 /* Fixes test RDW_INTERNALPAINT behavior */
970 if (TmpRgn == NULL)
971 {
972 TmpRgn = PRGN_WINDOW; // Need a region so the bits can be set!!!
973 }
974
975 /*
976 * Step 3.
977 * Adjust the window update region depending on hRgn and flags.
978 */
979
981 TmpRgn != NULL)
982 {
984 }
985
986 /*
987 * Step 4.
988 * Repaint and erase windows if needed.
989 */
990
991 if (Flags & RDW_UPDATENOW)
992 {
994 }
995 else if (Flags & RDW_ERASENOW)
996 {
997 if ((Flags & (RDW_NOCHILDREN|RDW_ALLCHILDREN)) == 0)
999
1001 }
1002
1003 /*
1004 * Step 5.
1005 * Cleanup ;-)
1006 */
1007
1008 if (TmpRgn > PRGN_WINDOW)
1009 {
1010 REGION_Delete(TmpRgn);
1011 }
1012 TRACE("co_UserRedrawWindow exit\n");
1013
1014 return TRUE;
1015}
#define PRGN_WINDOW
Definition: painting.h:12
#define IntSysCreateRectpRgnIndirect(prc)
Definition: region.h:93
#define TRACE(s)
Definition: solgame.cpp:4
Definition: region.h:8
static int UpdateRect(TreeListData *pData, unsigned uItem, unsigned uSub)
Definition: treelist.c:1529
BOOL FASTCALL IntIsWindowDrawable(PWND Wnd)
Definition: painting.c:861
VOID FASTCALL UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:620
VOID FASTCALL UserUpdateWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:598
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:642
FORCEINLINE BOOL RECTL_bIsEmptyRect(_In_ const RECTL *prcl)
Definition: rect.h:44
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2449
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
Definition: region.c:2407
BOOL FASTCALL REGION_bOffsetRgn(_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:2707
INT FASTCALL IntGdiCombineRgn(PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
Definition: region.c:2487
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1217
#define RDW_UPDATENOW
Definition: winuser.h:1220
#define RDW_ERASENOW
Definition: winuser.h:1219
#define RDW_FRAME
Definition: winuser.h:1212
#define RDW_NOFRAME
Definition: winuser.h:1216
#define RDW_INTERNALPAINT
Definition: winuser.h:1213
#define RDW_VALIDATE
Definition: winuser.h:1218
#define RDW_INVALIDATE
Definition: winuser.h:1214

Referenced by co_IntSetScrollInfo(), co_IntShowDesktop(), co_UserFreeWindow(), co_VIS_WindowLayoutChanged(), co_WinPosMinMaximize(), co_WinPosSetWindowPos(), DefWndDoSizeMove(), DesktopWindowProc(), IntDefWindowProc(), IntScrollWindowEx(), IntSetLayeredWindowAttributes(), NtGdiUpdateColors(), NtUserCallHwndParamLock(), and NtUserRedrawWindow().

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserPainting  )

◆ IntBeginPaint()

HDC FASTCALL IntBeginPaint ( PWND  Window,
PPAINTSTRUCT  Ps 
)

Definition at line 1435 of file painting.c.

1436{
1437 RECT Rect;
1438 INT type;
1439 BOOL Erase = FALSE;
1440
1442
1443 Window->state2 |= WNDS2_STARTPAINT;
1444 Window->state &= ~WNDS_PAINTNOTPROCESSED;
1445
1446 if (Window->state & WNDS_SENDNCPAINT)
1447 {
1448 HRGN hRgn;
1449 // Application can keep update dirty.
1450 do
1451 {
1452 Window->state &= ~WNDS_UPDATEDIRTY;
1456 {
1457 /* NOTE: The region can already be deleted! */
1459 }
1460 }
1461 while(Window->state & WNDS_UPDATEDIRTY);
1462 }
1463 else
1464 {
1465 Window->state &= ~WNDS_UPDATEDIRTY;
1466 }
1467
1468 RtlZeroMemory(Ps, sizeof(PAINTSTRUCT));
1469
1470 if (Window->state2 & WNDS2_ENDPAINTINVALIDATE)
1471 {
1472 ERR("BP: Another thread invalidated this window\n");
1473 }
1474
1475 Ps->hdc = UserGetDCEx( Window,
1476 Window->hrgnUpdate,
1478 if (!Ps->hdc)
1479 {
1480 return NULL;
1481 }
1482
1483 // If set, always clear flags out due to the conditions later on for sending the message.
1484 if (Window->state & WNDS_SENDERASEBACKGROUND)
1485 {
1487 Erase = TRUE;
1488 }
1489
1490 if (Window->hrgnUpdate != NULL)
1491 {
1492 MsqDecPaintCountQueue(Window->head.pti);
1494 /* The region is part of the dc now and belongs to the process! */
1495 Window->hrgnUpdate = NULL;
1496 }
1497 else
1498 {
1499 if (Window->state & WNDS_INTERNALPAINT)
1500 MsqDecPaintCountQueue(Window->head.pti);
1501 }
1502
1503 type = GdiGetClipBox(Ps->hdc, &Ps->rcPaint);
1504
1506
1507 Window->state &= ~WNDS_INTERNALPAINT;
1508
1509 if ( Erase && // Set to erase,
1510 type != NULLREGION && // don't erase if the clip box is empty,
1511 (!(Window->pcls->style & CS_PARENTDC) || // not parent dc or
1512 RECTL_bIntersectRect( &Rect, &Rect, &Ps->rcPaint) ) ) // intersecting.
1513 {
1515 if ( Ps->fErase )
1516 {
1518 }
1519 }
1520 else
1521 {
1522 Ps->fErase = FALSE;
1523 }
1524
1526
1527 return Ps->hdc;
1528}
void Erase(HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2, COLORREF color, LONG radius)
Definition: drawing.cpp:115
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define WNDS2_ENDPAINTINVALIDATE
Definition: ntuser.h:642
#define WNDS_UPDATEDIRTY
Definition: ntuser.h:618
#define WNDS2_STARTPAINT
Definition: ntuser.h:643
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
VOID FASTCALL IntSendChildNCPaint(PWND pWnd)
Definition: painting.c:370
BOOL FASTCALL IntGdiSetRegionOwner(HRGN hRgn, DWORD OwnerMask)
Definition: region.c:2459
BOOL FASTCALL co_UserHideCaret(PWND Window OPTIONAL)
Definition: caret.c:226
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:92
#define CS_PARENTDC
Definition: winuser.h:656

Referenced by DesktopWindowProc(), IntDefWindowProc(), NtUserBeginPaint(), and PopupMenuWndProc().

◆ IntCalcWindowRgn()

HRGN FASTCALL IntCalcWindowRgn ( PWND  Wnd,
BOOL  Client 
)

Definition at line 209 of file painting.c.

210{
211 HRGN hRgnWindow;
212
213 if (Client)
214 {
215 hRgnWindow = NtGdiCreateRectRgn(
216 Wnd->rcClient.left,
217 Wnd->rcClient.top,
218 Wnd->rcClient.right,
219 Wnd->rcClient.bottom);
220 }
221 else
222 {
223 hRgnWindow = NtGdiCreateRectRgn(
224 Wnd->rcWindow.left,
225 Wnd->rcWindow.top,
226 Wnd->rcWindow.right,
227 Wnd->rcWindow.bottom);
228 }
229
230 if (Wnd->hrgnClip != NULL && !(Wnd->style & WS_MINIMIZE))
231 {
232 NtGdiOffsetRgn(hRgnWindow,
233 -Wnd->rcWindow.left,
234 -Wnd->rcWindow.top);
235 NtGdiCombineRgn(hRgnWindow, hRgnWindow, Wnd->hrgnClip, RGN_AND);
236 NtGdiOffsetRgn(hRgnWindow,
237 Wnd->rcWindow.left,
238 Wnd->rcWindow.top);
239 }
240
241 return hRgnWindow;
242}
Definition: client.c:28
HRGN hrgnClip
Definition: ntuser.h:733
RECT rcClient
Definition: ntuser.h:717
RECT rcWindow
Definition: ntuser.h:716

Referenced by IntGetNCUpdateRgn().

◆ IntEndPaint()

BOOL FASTCALL IntEndPaint ( PWND  Wnd,
PPAINTSTRUCT  Ps 
)

Definition at line 1532 of file painting.c.

1533{
1534 HDC hdc = NULL;
1535
1536 hdc = Ps->hdc;
1537
1538 UserReleaseDC(Wnd, hdc, TRUE);
1539
1541 {
1542 ERR("EP: Another thread invalidated this window\n");
1543 Wnd->state2 &= ~WNDS2_ENDPAINTINVALIDATE;
1544 }
1545
1547
1548 co_UserShowCaret(Wnd);
1549
1550 return TRUE;
1551}
BOOL FASTCALL co_UserShowCaret(PWND Window OPTIONAL)
Definition: caret.c:262

Referenced by DesktopWindowProc(), IntDefWindowProc(), NtUserEndPaint(), and PopupMenuWndProc().

◆ IntFillWindow()

BOOL FASTCALL IntFillWindow ( PWND  pWndParent,
PWND  pWnd,
HDC  hDC,
HBRUSH  hBrush 
)

Definition at line 1555 of file painting.c.

1559{
1560 RECT Rect, Rect1;
1561 INT type;
1562
1563 if (!pWndParent)
1564 pWndParent = pWnd;
1565
1566 type = GdiGetClipBox(hDC, &Rect);
1567
1568 IntGetClientRect(pWnd, &Rect1);
1569
1570 if ( type != NULLREGION && // Clip box is not empty,
1571 (!(pWnd->pcls->style & CS_PARENTDC) || // not parent dc or
1572 RECTL_bIntersectRect( &Rect, &Rect, &Rect1) ) ) // intersecting.
1573 {
1574 POINT ppt;
1575 INT x = 0, y = 0;
1576
1577 if (!UserIsDesktopWindow(pWndParent))
1578 {
1579 x = pWndParent->rcClient.left - pWnd->rcClient.left;
1580 y = pWndParent->rcClient.top - pWnd->rcClient.top;
1581 }
1582
1583 GreSetBrushOrg(hDC, x, y, &ppt);
1584
1585 if ( hBrush < (HBRUSH)CTLCOLOR_MAX )
1586 hBrush = GetControlColor( pWndParent, pWnd, hDC, HandleToUlong(hBrush) + WM_CTLCOLORMSGBOX);
1587
1588 FillRect(hDC, &Rect, hBrush);
1589
1590 GreSetBrushOrg(hDC, ppt.x, ppt.y, NULL);
1591
1592 return TRUE;
1593 }
1594 else
1595 return FALSE;
1596}
#define HandleToUlong(h)
Definition: basetsd.h:79
BOOL FASTCALL GreSetBrushOrg(HDC, INT, INT, LPPOINT)
Definition: dcutil.c:231
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
UINT style
Definition: ntuser.h:580
PCLS pcls
Definition: ntuser.h:720
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
HBRUSH FASTCALL GetControlColor(PWND pwndParent, PWND pwnd, HDC hdc, UINT CtlMsg)
Definition: misc.c:154
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
#define WM_CTLCOLORMSGBOX
Definition: winuser.h:1766
#define CTLCOLOR_MAX
Definition: winuser.h:958

Referenced by NtUserFillWindow().

◆ IntFindWindowToRepaint()

PWND FASTCALL IntFindWindowToRepaint ( PWND  Window,
PTHREADINFO  Thread 
)

Definition at line 1134 of file painting.c.

1135{
1136 PWND hChild;
1137 PWND TempWindow;
1138
1139 for (; Window != NULL; Window = Window->spwndNext)
1140 {
1142 {
1144 {
1145 /* Make sure all non-transparent siblings are already drawn. */
1146 if (Window->ExStyle & WS_EX_TRANSPARENT)
1147 {
1148 for (TempWindow = Window->spwndNext; TempWindow != NULL;
1149 TempWindow = TempWindow->spwndNext)
1150 {
1151 if (!(TempWindow->ExStyle & WS_EX_TRANSPARENT) &&
1152 IntWndBelongsToThread(TempWindow, Thread) &&
1153 IntIsWindowDirty(TempWindow))
1154 {
1155 return TempWindow;
1156 }
1157 }
1158 }
1159 return Window;
1160 }
1161 }
1162 /* find a child of the specified window that needs repainting */
1163 if (Window->spwndChild)
1164 {
1166 if (hChild != NULL)
1167 return hChild;
1168 }
1169 }
1170 return Window;
1171}
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
static HTREEITEM hChild
Definition: treeview.c:381
DWORD ExStyle
Definition: ntuser.h:704
PWND FASTCALL IntFindWindowToRepaint(PWND Window, PTHREADINFO Thread)
Definition: painting.c:1134
BOOL FASTCALL IntIsWindowDirty(PWND Wnd)
Definition: painting.c:1118
#define IntWndBelongsToThread(WndObj, W32Thread)
Definition: window.h:32

Referenced by IntFindWindowToRepaint(), and IntGetPaintMessage().

◆ IntFlashWindowEx()

BOOL FASTCALL IntFlashWindowEx ( PWND  pWnd,
PFLASHWINFO  pfwi 
)

Definition at line 1304 of file painting.c.

1305{
1306 DWORD_PTR FlashState;
1307 UINT uCount = pfwi->uCount;
1308 BOOL Activate = FALSE, Ret = FALSE;
1309
1310 ASSERT(pfwi);
1311
1312 FlashState = (DWORD_PTR)UserGetProp(pWnd, AtomFlashWndState, TRUE);
1313
1314 if (FlashState == FLASHW_FINISHED)
1315 {
1316 // Cycle has finished, kill timer and set this to Stop.
1317 FlashState |= FLASHW_KILLSYSTIMER;
1318 pfwi->dwFlags = FLASHW_STOP;
1319 }
1320 else
1321 {
1322 if (FlashState)
1323 {
1324 if (pfwi->dwFlags == FLASHW_SYSTIMER)
1325 {
1326 // Called from system timer, restore flags, counts and state.
1327 pfwi->dwFlags = LOWORD(FlashState);
1328 uCount = HIWORD(FlashState);
1329 FlashState = MAKELONG(LOWORD(FlashState),0);
1330 }
1331 else
1332 {
1333 // Clean out the trash! Fix SeaMonkey crash after restart.
1334 FlashState = 0;
1335 }
1336 }
1337
1338 if (FlashState == 0)
1339 { // First time in cycle, setup flash state.
1340 if ( pWnd->state & WNDS_ACTIVEFRAME ||
1341 (pfwi->dwFlags & FLASHW_CAPTION && pWnd->style & (WS_BORDER|WS_DLGFRAME)))
1342 {
1343 FlashState = FLASHW_STARTED|FLASHW_ACTIVE;
1344 }
1345 }
1346
1347 // Set previous window state.
1348 Ret = !!(FlashState & FLASHW_ACTIVE);
1349
1350 if ( (pfwi->dwFlags & FLASHW_TIMERNOFG) == FLASHW_TIMERNOFG &&
1351 gpqForeground == pWnd->head.pti->MessageQueue )
1352 {
1353 // Flashing until foreground, set this to Stop.
1354 pfwi->dwFlags = FLASHW_STOP;
1355 }
1356 }
1357
1358 // Toggle activate flag.
1359 if ( pfwi->dwFlags == FLASHW_STOP )
1360 {
1361 if (gpqForeground && gpqForeground->spwndActive == pWnd)
1362 Activate = TRUE;
1363 else
1364 Activate = FALSE;
1365 }
1366 else
1367 {
1368 Activate = (FlashState & FLASHW_ACTIVE) == 0;
1369 }
1370
1371 if ( pfwi->dwFlags == FLASHW_STOP || pfwi->dwFlags & FLASHW_CAPTION )
1372 {
1373 co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCACTIVATE, Activate, 0);
1374 }
1375
1376 // FIXME: Check for a Stop Sign here.
1377 if ( pfwi->dwFlags & FLASHW_TRAY )
1378 {
1379 // Need some shell work here too.
1380 TRACE("FIXME: Flash window no Tray support!\n");
1381 }
1382
1383 if ( pfwi->dwFlags == FLASHW_STOP )
1384 {
1385 if (FlashState & FLASHW_KILLSYSTIMER)
1386 {
1388 }
1389
1391 }
1392 else
1393 { // Have a count and started, set timer.
1394 if ( uCount )
1395 {
1396 FlashState |= FLASHW_COUNT;
1397
1398 if (!(Activate ^ !!(FlashState & FLASHW_STARTED)))
1399 uCount--;
1400
1401 if (!(FlashState & FLASHW_KILLSYSTIMER))
1402 pfwi->dwFlags |= FLASHW_TIMER;
1403 }
1404
1405 if (pfwi->dwFlags & FLASHW_TIMER)
1406 {
1407 FlashState |= FLASHW_KILLSYSTIMER;
1408
1409 IntSetTimer( pWnd,
1411 pfwi->dwTimeout ? pfwi->dwTimeout : gpsi->dtCaretBlink,
1413 TMRF_SYSTEM );
1414 }
1415
1416 if (FlashState & FLASHW_COUNT && uCount == 0)
1417 {
1418 // Keep spinning? Nothing else to do.
1419 FlashState = FLASHW_FINISHED;
1420 }
1421 else
1422 {
1423 // Save state and flags so this can be restored next time through.
1424 FlashState ^= (FlashState ^ -!!(Activate)) & FLASHW_ACTIVE;
1425 FlashState ^= (FlashState ^ pfwi->dwFlags) & (FLASHW_MASK & ~FLASHW_TIMER);
1426 }
1427 FlashState = MAKELONG(LOWORD(FlashState),uCount);
1428 UserSetProp(pWnd, AtomFlashWndState, (HANDLE)FlashState, TRUE);
1429 }
1430 return Ret;
1431}
PSERVERINFO gpsi
Definition: imm.c:18
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
#define WNDS_ACTIVEFRAME
Definition: ntuser.h:611
#define ASSERT(a)
Definition: mode.c:44
unsigned int UINT
Definition: ndis.h:50
ATOM AtomFlashWndState
Definition: ntuser.c:22
#define FLASHW_FINISHED
Definition: painting.h:5
#define FLASHW_STARTED
Definition: painting.h:6
#define FLASHW_COUNT
Definition: painting.h:7
#define FLASHW_ACTIVE
Definition: painting.h:9
#define FLASHW_SYSTIMER
Definition: painting.h:4
#define FLASHW_MASK
Definition: painting.h:3
#define FLASHW_KILLSYSTIMER
Definition: painting.h:8
#define LOWORD(l)
Definition: pedump.c:82
#define WS_BORDER
Definition: pedump.c:625
#define WS_DLGFRAME
Definition: pedump.c:626
HANDLE FASTCALL UserRemoveProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
#define DWORD_PTR
Definition: treelist.c:76
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define HIWORD(l)
Definition: typedefs.h:247
HANDLE FASTCALL UserGetProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
Definition: prop.c:46
VOID CALLBACK SystemTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
Definition: timer.c:280
BOOL FASTCALL IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
Definition: timer.c:573
UINT_PTR FASTCALL IntSetTimer(PWND Window, UINT_PTR IDEvent, UINT Elapse, TIMERPROC TimerFunc, INT Type)
Definition: timer.c:177
#define TMRF_SYSTEM
Definition: timer.h:20
#define ID_EVENT_SYSTIMER_FLASHWIN
Definition: timer.h:28
#define WM_NCACTIVATE
Definition: winuser.h:1688

Referenced by DefWndHandleSetCursor(), NtUserFlashWindowEx(), and SystemTimerProc().

◆ IntGetNCUpdateRgn()

HRGN FASTCALL IntGetNCUpdateRgn ( PWND  Window,
BOOL  Validate 
)

Definition at line 260 of file painting.c.

261{
262 HRGN hRgnNonClient;
263 HRGN hRgnWindow;
264 UINT RgnType, NcType;
265 RECT update;
266
267 if (Window->hrgnUpdate != NULL &&
268 Window->hrgnUpdate != HRGN_WINDOW)
269 {
270 hRgnNonClient = IntCalcWindowRgn(Window, FALSE);
271
272 /*
273 * If region creation fails it's safe to fallback to whole
274 * window region.
275 */
276 if (hRgnNonClient == NULL)
277 {
278 return HRGN_WINDOW;
279 }
280
281 hRgnWindow = IntCalcWindowRgn(Window, TRUE);
282 if (hRgnWindow == NULL)
283 {
284 GreDeleteObject(hRgnNonClient);
285 return HRGN_WINDOW;
286 }
287
288 NcType = IntGdiGetRgnBox(hRgnNonClient, &update);
289
290 RgnType = NtGdiCombineRgn(hRgnNonClient, hRgnNonClient, hRgnWindow, RGN_DIFF);
291
292 if (RgnType == ERROR)
293 {
294 GreDeleteObject(hRgnWindow);
295 GreDeleteObject(hRgnNonClient);
296 return HRGN_WINDOW;
297 }
298 else if (RgnType == NULLREGION)
299 {
300 GreDeleteObject(hRgnWindow);
301 GreDeleteObject(hRgnNonClient);
302 Window->state &= ~WNDS_UPDATEDIRTY;
303 return NULL;
304 }
305
306 /*
307 * Remove the nonclient region from the standard update region if
308 * we were asked for it.
309 */
310
311 if (Validate)
312 {
313 if (NtGdiCombineRgn(Window->hrgnUpdate, Window->hrgnUpdate, hRgnWindow, RGN_AND) == NULLREGION)
314 {
316 GreDeleteObject(Window->hrgnUpdate);
317 Window->state &= ~WNDS_UPDATEDIRTY;
318 Window->hrgnUpdate = NULL;
319 if (!(Window->state & WNDS_INTERNALPAINT))
320 MsqDecPaintCountQueue(Window->head.pti);
321 }
322 }
323
324 /* check if update rgn contains complete nonclient area */
325 if (NcType == SIMPLEREGION)
326 {
327 RECT window;
329
330 if (IntEqualRect( &window, &update ))
331 {
332 GreDeleteObject(hRgnNonClient);
333 hRgnNonClient = HRGN_WINDOW;
334 }
335 }
336
337 GreDeleteObject(hRgnWindow);
338
339 return hRgnNonClient;
340 }
341 else
342 {
343 return Window->hrgnUpdate;
344 }
345}
static IHTMLWindow2 * window
Definition: events.c:77
BOOL FASTCALL IntGetWindowRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:121
HRGN FASTCALL IntCalcWindowRgn(PWND Wnd, BOOL Client)
Definition: painting.c:209
FORCEINLINE BOOL IntEqualRect(RECTL *lprc1, RECTL *lprc2)
Definition: winpos.h:48

Referenced by co_IntPaintWindows(), and IntBeginPaint().

◆ IntGetPaintMessage()

BOOL FASTCALL IntGetPaintMessage ( PWND  Window,
UINT  MsgFilterMin,
UINT  MsgFilterMax,
PTHREADINFO  Thread,
MSG Message,
BOOL  Remove 
)

Definition at line 1184 of file painting.c.

1191{
1192 PWND PaintWnd, StartWnd;
1193
1194 if ((MsgFilterMin != 0 || MsgFilterMax != 0) &&
1195 (MsgFilterMin > WM_PAINT || MsgFilterMax < WM_PAINT))
1196 return FALSE;
1197
1198 if (Thread->TIF_flags & TIF_SYSTEMTHREAD )
1199 {
1200 ERR("WM_PAINT is in a System Thread!\n");
1201 }
1202
1203 StartWnd = UserGetDesktopWindow();
1204 PaintWnd = IntFindWindowToRepaint(StartWnd, Thread);
1205
1206 Message->hwnd = PaintWnd ? UserHMGetHandle(PaintWnd) : NULL;
1207
1208 if (Message->hwnd == NULL && Thread->cPaintsReady)
1209 {
1210 // Find note in window.c:"PAINTING BUG".
1211 ERR("WARNING SOMETHING HAS GONE WRONG: Thread marked as containing dirty windows, but no dirty windows found! Counts %u\n",Thread->cPaintsReady);
1212 /* Hack to stop spamming the debug log ! */
1213 Thread->cPaintsReady = 0;
1214 return FALSE;
1215 }
1216
1217 if (Message->hwnd == NULL)
1218 return FALSE;
1219
1220 if (!(Window == NULL ||
1221 PaintWnd == Window ||
1222 IntIsChildWindow(Window, PaintWnd))) /* check that it is a child of the specified parent */
1223 return FALSE;
1224
1225 if (PaintWnd->state & WNDS_INTERNALPAINT)
1226 {
1227 PaintWnd->state &= ~WNDS_INTERNALPAINT;
1228 if (!PaintWnd->hrgnUpdate)
1230 }
1231 PaintWnd->state2 &= ~WNDS2_STARTPAINT;
1232 PaintWnd->state &= ~WNDS_UPDATEDIRTY;
1233
1234 Window = PaintWnd;
1235 while (Window && !UserIsDesktopWindow(Window))
1236 {
1237 // Role back and check for clip children, do not set if any.
1238 if (Window->spwndParent && !(Window->spwndParent->style & WS_CLIPCHILDREN))
1239 {
1240 PaintWnd->state2 |= WNDS2_WMPAINTSENT;
1241 }
1242 Window = Window->spwndParent;
1243 }
1244
1245 Message->wParam = Message->lParam = 0;
1246 Message->message = WM_PAINT;
1247 return TRUE;
1248}
static const WCHAR Message[]
Definition: register.c:74
#define TIF_SYSTEMTHREAD
Definition: ntuser.h:265
BOOL FASTCALL IntIsChildWindow(PWND Parent, PWND BaseWindow)
Definition: window.c:927

Referenced by co_IntPeekMessage().

◆ IntIntersectWithParents()

BOOL FASTCALL IntIntersectWithParents ( PWND  Child,
RECTL WindowRect 
)

Definition at line 35 of file painting.c.

36{
37 PWND ParentWnd;
38
39 if (Child->ExStyle & WS_EX_REDIRECTED)
40 return TRUE;
41
42 ParentWnd = Child->spwndParent;
43 while (ParentWnd != NULL)
44 {
45 if (!(ParentWnd->style & WS_VISIBLE) ||
46 (ParentWnd->style & WS_MINIMIZE) ||
47 !RECTL_bIntersectRect(WindowRect, WindowRect, &ParentWnd->rcClient) )
48 {
49 return FALSE;
50 }
51
52 if (ParentWnd->ExStyle & WS_EX_REDIRECTED)
53 return TRUE;
54
55 ParentWnd = ParentWnd->spwndParent;
56 }
57
58 return TRUE;
59}
struct _WND * spwndParent
Definition: ntuser.h:713
#define WS_EX_REDIRECTED
Definition: undocuser.h:25

Referenced by co_IntGetUpdateRgn(), co_UserGetUpdateRect(), co_UserGetUpdateRgn(), and IntValidateParents().

◆ IntInvalidateWindows()

VOID FASTCALL IntInvalidateWindows ( PWND  Wnd,
PREGION  Rgn,
ULONG  Flags 
)

Definition at line 642 of file painting.c.

643{
644 INT RgnType = NULLREGION;
645 BOOL HadPaintMessage;
646
647 TRACE("IntInvalidateWindows start Rgn %p\n",Rgn);
648
649 if ( Rgn > PRGN_WINDOW )
650 {
651 /*
652 * If the nonclient is not to be redrawn, clip the region to the client
653 * rect
654 */
655 if ((Flags & RDW_INVALIDATE) != 0 && (Flags & RDW_FRAME) == 0)
656 {
657 PREGION RgnClient;
658
659 RgnClient = IntSysCreateRectpRgnIndirect(&Wnd->rcClient);
660 if (RgnClient)
661 {
662 RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClient, RGN_AND);
663 REGION_Delete(RgnClient);
664 }
665 }
666
667 /*
668 * Clip the given region with window rectangle (or region)
669 */
670
671 if (!Wnd->hrgnClip || (Wnd->style & WS_MINIMIZE))
672 {
674 if (RgnWindow)
675 {
676 RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnWindow, RGN_AND);
677 REGION_Delete(RgnWindow);
678 }
679 }
680 else
681 {
682 PREGION RgnClip = REGION_LockRgn(Wnd->hrgnClip);
683 if (RgnClip)
684 {
686 -Wnd->rcWindow.left,
687 -Wnd->rcWindow.top);
688 RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
690 Wnd->rcWindow.left,
691 Wnd->rcWindow.top);
692 REGION_UnlockRgn(RgnClip);
693 }
694 }
695 }
696 else
697 {
698 RgnType = NULLREGION;
699 }
700
701 /*
702 * Save current state of pending updates
703 */
704
705 HadPaintMessage = IntIsWindowDirty(Wnd);
706
707 /*
708 * Update the region and flags
709 */
710
711 // The following flags are used to invalidate the window.
713 {
715 {
717 }
718
719 if (Flags & RDW_INVALIDATE )
720 {
721 PREGION RgnUpdate;
722
723 Wnd->state &= ~WNDS_NONCPAINT;
724
725 /* If not the same thread set it dirty. */
726 if (Wnd->head.pti != PsGetCurrentThreadWin32Thread())
727 {
728 Wnd->state |= WNDS_UPDATEDIRTY;
729 if (Wnd->state2 & WNDS2_WMPAINTSENT)
731 }
732
733 if (Flags & RDW_FRAME)
734 Wnd->state |= WNDS_SENDNCPAINT;
735
736 if (Flags & RDW_ERASE)
738
739 if (RgnType != NULLREGION && Rgn > PRGN_WINDOW)
740 {
741 if (Wnd->hrgnUpdate == NULL)
742 {
743 Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
745 }
746
747 if (Wnd->hrgnUpdate != HRGN_WINDOW)
748 {
749 RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
750 if (RgnUpdate)
751 {
752 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_OR);
753 REGION_UnlockRgn(RgnUpdate);
754 if (RgnType == NULLREGION)
755 {
758 Wnd->hrgnUpdate = NULL;
759 }
760 }
761 }
762 }
763
764 Flags |= RDW_ERASE|RDW_FRAME; // For children.
765
766 }
767
768 if (!HadPaintMessage && IntIsWindowDirty(Wnd))
769 {
770 MsqIncPaintCountQueue(Wnd->head.pti);
771 }
772
773 } // The following flags are used to validate the window.
775 {
777 return;
778
780 {
781 Wnd->state &= ~WNDS_INTERNALPAINT;
782 }
783
784 if (Flags & RDW_VALIDATE)
785 {
786 if (Flags & RDW_NOFRAME)
787 Wnd->state &= ~WNDS_SENDNCPAINT;
788
789 if (Flags & RDW_NOERASE)
791
792 if (Wnd->hrgnUpdate > HRGN_WINDOW && RgnType != NULLREGION && Rgn > PRGN_WINDOW)
793 {
794 PREGION RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
795
796 if (RgnUpdate)
797 {
798 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_DIFF);
799 REGION_UnlockRgn(RgnUpdate);
800
801 if (RgnType == NULLREGION)
802 {
805 Wnd->hrgnUpdate = NULL;
806 }
807 }
808 }
809 // If update is null, do not erase.
810 if (Wnd->hrgnUpdate == NULL)
811 {
813 }
814 }
815
816 if (HadPaintMessage && !IntIsWindowDirty(Wnd))
817 {
818 MsqDecPaintCountQueue(Wnd->head.pti);
819 }
820 }
821
822 /*
823 * Process children if needed
824 */
825
826 if (!(Flags & RDW_NOCHILDREN) &&
827 !(Wnd->style & WS_MINIMIZE) &&
828 ((Flags & RDW_ALLCHILDREN) || !(Wnd->style & WS_CLIPCHILDREN)))
829 {
830 PWND Child;
831
832 for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
833 {
834 if (Child->style & WS_VISIBLE)
835 {
836 /*
837 * Recursive call to update children hrgnUpdate
838 */
839 PREGION RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
840 if (RgnTemp)
841 {
842 if (Rgn > PRGN_WINDOW) IntGdiCombineRgn(RgnTemp, Rgn, 0, RGN_COPY);
843 IntInvalidateWindows(Child, ((Rgn > PRGN_WINDOW)?RgnTemp:Rgn), Flags);
844 REGION_Delete(RgnTemp);
845 }
846 }
847 }
848 }
849 TRACE("IntInvalidateWindows exit\n");
850}
VOID FASTCALL MsqIncPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:501
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
#define RDW_NOUPDATEDIRTY
Definition: painting.h:16
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2358
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2373
#define RDW_ERASE
Definition: winuser.h:1211
#define RDW_NOERASE
Definition: winuser.h:1215

Referenced by co_UserRedrawWindow(), co_WinPosSetWindowPos(), IntInvalidateWindows(), IntValidateParent(), IntValidateParents(), PaintSuspendedWindow(), and UserRedrawDesktop().

◆ IntIsWindowDirty()

BOOL FASTCALL IntIsWindowDirty ( PWND  Wnd)

Definition at line 1118 of file painting.c.

1119{
1120 return ( Wnd->style & WS_VISIBLE &&
1121 ( Wnd->hrgnUpdate != NULL ||
1122 Wnd->state & WNDS_INTERNALPAINT ) );
1123}

Referenced by IntFindWindowToRepaint(), and IntInvalidateWindows().

◆ IntIsWindowDrawable()

BOOL FASTCALL IntIsWindowDrawable ( PWND  Wnd)

Definition at line 861 of file painting.c.

862{
863 PWND WndObject;
864
865 for (WndObject = Wnd; WndObject != NULL; WndObject = WndObject->spwndParent)
866 {
867 if ( WndObject->state2 & WNDS2_INDESTROY ||
868 WndObject->state & WNDS_DESTROYED ||
869 !WndObject ||
870 !(WndObject->style & WS_VISIBLE) ||
871 ((WndObject->style & WS_MINIMIZE) && (WndObject != Wnd)))
872 {
873 return FALSE;
874 }
875 }
876
877 return TRUE;
878}
#define WNDS_DESTROYED
Definition: ntuser.h:636
#define WNDS2_INDESTROY
Definition: ntuser.h:648

Referenced by co_UserRedrawWindow(), IntScrollWindowEx(), and NtUserScrollWindowEx().

◆ IntPaintWindow()

VOID FASTCALL IntPaintWindow ( PWND  Window)

Definition at line 1177 of file painting.c.

1178{
1179 // Handle normal painting.
1181}

Referenced by IntDispatchMessage().

◆ IntPrintWindow()

BOOL FASTCALL IntPrintWindow ( PWND  pwnd,
HDC  hdcBlt,
UINT  nFlags 
)

Definition at line 1252 of file painting.c.

1256{
1257 HDC hdcSrc;
1258 INT cx, cy, xSrc, ySrc;
1259
1260 if ( nFlags & PW_CLIENTONLY)
1261 {
1262 cx = pwnd->rcClient.right - pwnd->rcClient.left;
1263 cy = pwnd->rcClient.bottom - pwnd->rcClient.top;
1264 xSrc = pwnd->rcClient.left - pwnd->rcWindow.left;
1265 ySrc = pwnd->rcClient.top - pwnd->rcWindow.top;
1266 }
1267 else
1268 {
1269 cx = pwnd->rcWindow.right - pwnd->rcWindow.left;
1270 cy = pwnd->rcWindow.bottom - pwnd->rcWindow.top;
1271 xSrc = 0;
1272 ySrc = 0;
1273 }
1274
1275 // TODO: Setup Redirection for Print.
1276 return FALSE;
1277
1278 /* Update the window just incase. */
1280
1282 /* Print window to printer context. */
1283 NtGdiBitBlt( hdcBlt,
1284 0,
1285 0,
1286 cx,
1287 cy,
1288 hdcSrc,
1289 xSrc,
1290 ySrc,
1291 SRCCOPY,
1292 0,
1293 0);
1294
1295 UserReleaseDC( pwnd, hdcSrc, FALSE);
1296
1297 // TODO: Release Redirection from Print.
1298
1299 return TRUE;
1300}
__kernel_entry W32KAPI BOOL APIENTRY NtGdiBitBlt(_In_ HDC hdcDst, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD rop4, _In_ DWORD crBackColor, _In_ FLONG fl)
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
#define SRCCOPY
Definition: wingdi.h:333
#define DCX_WINDOW
Definition: winuser.h:2113
static HDC hdcSrc
Definition: xlate.c:32

Referenced by NtUserPrintWindow().

◆ IntSendChildNCPaint()

VOID FASTCALL IntSendChildNCPaint ( PWND  pWnd)

Definition at line 370 of file painting.c.

371{
372 pWnd = pWnd->spwndChild;
373 while (pWnd)
374 {
375 if ((pWnd->hrgnUpdate == NULL) && (pWnd->state & WNDS_SENDNCPAINT))
376 {
377 PWND Next;
379
380 /* Reference, IntSendNCPaint leaves win32k */
381 UserRefObjectCo(pWnd, &Ref);
383
384 /* Make sure to grab next one before dereferencing/freeing */
385 Next = pWnd->spwndNext;
386 UserDerefObjectCo(pWnd);
387 pWnd = Next;
388 }
389 else
390 {
391 pWnd = pWnd->spwndNext;
392 }
393 }
394}

Referenced by IntBeginPaint().

◆ IntSendNCPaint()

VOID FASTCALL IntSendNCPaint ( PWND  pWnd,
HRGN  hRgn 
)

Definition at line 348 of file painting.c.

349{
350 pWnd->state &= ~WNDS_SENDNCPAINT;
351
352 if ( pWnd == GetW32ThreadInfo()->MessageQueue->spwndActive &&
353 !(pWnd->state & WNDS_ACTIVEFRAME))
354 {
355 pWnd->state |= WNDS_ACTIVEFRAME;
356 pWnd->state &= ~WNDS_NONCPAINT;
358 }
359
361 {
362 pWnd->state2 &= ~WNDS2_FORCEFULLNCPAINTCLIPRGN;
364 }
365
367}
#define WNDS2_FORCEFULLNCPAINTCLIPRGN
Definition: ntuser.h:664
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:805
#define WM_NCPAINT
Definition: winuser.h:1687

Referenced by co_IntPaintWindows(), co_WinPosSetWindowPos(), ForceNCPaintErase(), IntBeginPaint(), and IntSendChildNCPaint().

◆ IntSendSyncPaint()

VOID FASTCALL IntSendSyncPaint ( PWND  Wnd,
ULONG  Flags 
)

Definition at line 132 of file painting.c.

133{
134 PTHREADINFO ptiCur, ptiWnd;
137 BOOL bSend = TRUE;
138
139 ptiWnd = Wnd->head.pti;
141 /*
142 Not the current thread, Wnd is in send Nonclient paint also in send erase background and it is visiable.
143 */
144 if ( Wnd->head.pti != ptiCur &&
145 Wnd->state & WNDS_SENDNCPAINT &&
147 Wnd->style & WS_VISIBLE)
148 {
149 // For testing, if you see this, break out the Champagne and have a party!
150 TRACE("SendSyncPaint Wnd in State!\n");
151 if (!IsListEmpty(&ptiWnd->SentMessagesListHead))
152 {
153 // Scan sent queue messages to see if we received sync paint messages.
156 do
157 {
158 ERR("LOOP it\n");
159 if (Message->Msg.message == WM_SYNCPAINT &&
160 Message->Msg.hwnd == UserHMGetHandle(Wnd))
161 { // Already received so exit out.
162 ERR("SendSyncPaint Found one in the Sent Msg Queue!\n");
163 bSend = FALSE;
164 break;
165 }
166 Entry = Message->ListEntry.Flink;
168 }
169 while (Entry != &ptiWnd->SentMessagesListHead);
170 }
171 if (bSend)
172 {
173 TRACE("Sending WM_SYNCPAINT\n");
174 // This message has no parameters. But it does! Pass Flags along.
177 }
178 }
179
180 // Send to all the children if this is the desktop window.
181 if (UserIsDesktopWindow(Wnd))
182 {
183 if ( Flags & RDW_ALLCHILDREN ||
184 ( !(Flags & RDW_NOCHILDREN) && Wnd->style & WS_CLIPCHILDREN))
185 {
186 PWND spwndChild = Wnd->spwndChild;
187 while(spwndChild)
188 {
189 if ( spwndChild->style & WS_CHILD &&
190 spwndChild->head.pti != ptiCur)
191 {
192 spwndChild = spwndChild->spwndNext;
193 continue;
194 }
195 IntSendSyncPaint( spwndChild, Flags );
196 spwndChild = spwndChild->spwndNext;
197 }
198 }
199 }
200}
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define WNDS_SYNCPAINTPENDING
Definition: ntuser.h:628
base of all file and directory entries
Definition: entries.h:83
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LIST_ENTRY SentMessagesListHead
Definition: win32.h:100
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
VOID FASTCALL IntSendSyncPaint(PWND Wnd, ULONG Flags)
Definition: painting.c:132
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1713
#define WM_SYNCPAINT
Definition: winuser.h:1690

Referenced by IntSendSyncPaint(), and UserSyncAndPaintWindows().

◆ IntValidateParents()

BOOL FASTCALL IntValidateParents ( PWND  Child,
BOOL  Recurse 
)

Definition at line 62 of file painting.c.

63{
64 RECTL ParentRect, Rect;
65 BOOL Start, Ret = TRUE;
66 PWND ParentWnd = Child;
67 PREGION Rgn = NULL;
68
69 if (ParentWnd->style & WS_CHILD)
70 {
71 do
72 ParentWnd = ParentWnd->spwndParent;
73 while (ParentWnd->style & WS_CHILD);
74 }
75
76 // No pending nonclient paints.
77 if (!(ParentWnd->state & WNDS_SYNCPAINTPENDING)) Recurse = FALSE;
78
79 Start = TRUE;
80 ParentWnd = Child->spwndParent;
81 while (ParentWnd)
82 {
83 if (ParentWnd->style & WS_CLIPCHILDREN)
84 break;
85
86 if (ParentWnd->hrgnUpdate != 0)
87 {
88 if (Recurse)
89 {
90 Ret = FALSE;
91 break;
92 }
93 // Start with child clipping.
94 if (Start)
95 {
96 Start = FALSE;
97
98 Rect = Child->rcWindow;
99
100 if (!IntIntersectWithParents(Child, &Rect)) break;
101
103
104 if (Child->hrgnClip)
105 {
106 PREGION RgnClip = REGION_LockRgn(Child->hrgnClip);
107 IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
108 REGION_UnlockRgn(RgnClip);
109 }
110 }
111
112 ParentRect = ParentWnd->rcWindow;
113
114 if (!IntIntersectWithParents(ParentWnd, &ParentRect)) break;
115
116 IntInvalidateWindows( ParentWnd,
117 Rgn,
119 }
120 ParentWnd = ParentWnd->spwndParent;
121 }
122
123 if (Rgn) REGION_Delete(Rgn);
124
125 return Ret;
126}
@ Start
Definition: partlist.h:33

Referenced by co_IntUpdateWindows().

◆ NtUserBeginPaint()

HDC APIENTRY NtUserBeginPaint ( HWND  hWnd,
PAINTSTRUCT UnsafePs 
)

Definition at line 1608 of file painting.c.

1609{
1610 PWND Window;
1611 PAINTSTRUCT Ps;
1613 HDC hDC;
1615 HDC Ret = NULL;
1616
1617 TRACE("Enter NtUserBeginPaint\n");
1619
1621 {
1622 goto Cleanup; // Return NULL
1623 }
1624
1625 UserRefObjectCo(Window, &Ref);
1626
1627 hDC = IntBeginPaint(Window, &Ps);
1628
1629 Status = MmCopyToCaller(UnsafePs, &Ps, sizeof(PAINTSTRUCT));
1630 if (! NT_SUCCESS(Status))
1631 {
1633 goto Cleanup; // Return NULL
1634 }
1635
1636 Ret = hDC;
1637
1638Cleanup:
1640
1641 TRACE("Leave NtUserBeginPaint, ret=%p\n", Ret);
1642 UserLeave();
1643 return Ret;
1644}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static const WCHAR Cleanup[]
Definition: register.c:80
Status
Definition: gdiplustypes.h:25
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:251
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:242
HDC FASTCALL IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
Definition: painting.c:1435
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31

Referenced by BeginPaint().

◆ NtUserDrawCaption()

BOOL APIENTRY NtUserDrawCaption ( HWND  hWnd,
HDC  hDC,
LPCRECT  lpRc,
UINT  uFlags 
)

Definition at line 2450 of file painting.c.

2454{
2455 return NtUserDrawCaptionTemp(hWnd, hDC, lpRc, 0, 0, NULL, uFlags);
2456}
UINT uFlags
Definition: api.c:59
BOOL APIENTRY NtUserDrawCaptionTemp(HWND hWnd, HDC hDC, LPCRECT lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING str, UINT uFlags)
Definition: painting.c:2367

Referenced by DrawCaption(), RealUserDrawCaption(), and UserPaintCaption().

◆ NtUserDrawCaptionTemp()

BOOL APIENTRY NtUserDrawCaptionTemp ( HWND  hWnd,
HDC  hDC,
LPCRECT  lpRc,
HFONT  hFont,
HICON  hIcon,
const PUNICODE_STRING  str,
UINT  uFlags 
)

Definition at line 2367 of file painting.c.

2375{
2376 PWND pWnd = NULL;
2377 UNICODE_STRING SafeStr = {0};
2379 RECTL SafeRect;
2380 BOOL Ret;
2381
2383
2384 if (hWnd != NULL)
2385 {
2386 if(!(pWnd = UserGetWindowObject(hWnd)))
2387 {
2388 UserLeave();
2389 return FALSE;
2390 }
2391 }
2392
2393 _SEH2_TRY
2394 {
2395 ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
2396 RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
2397 if (str != NULL)
2398 {
2399 SafeStr = ProbeForReadUnicodeString(str);
2400 if (SafeStr.Length != 0)
2401 {
2402 ProbeForRead( SafeStr.Buffer,
2403 SafeStr.Length,
2404 sizeof(WCHAR));
2405 }
2406 }
2407 }
2409 {
2411 }
2412 _SEH2_END;
2413
2414 if (Status != STATUS_SUCCESS)
2415 {
2417 UserLeave();
2418 return FALSE;
2419 }
2420
2421 if (str != NULL)
2422 Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
2423 else
2424 {
2425 if ( RECTL_bIsEmptyRect(&SafeRect) && hFont == 0 && hIcon == 0 )
2426 {
2427 Ret = TRUE;
2429 {
2430 ERR("NC Caption Mode\n");
2432 goto Exit;
2433 }
2434 else if (uFlags & DC_DRAWFRAMEMD)
2435 {
2436 ERR("NC Paint Mode\n");
2437 NC_DoNCPaint(pWnd, hDC, uFlags); // Update Menus too!
2438 goto Exit;
2439 }
2440 }
2441 Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
2442 }
2443Exit:
2444 UserLeave();
2445 return Ret;
2446}
HFONT hFont
Definition: main.c:53
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
HICON hIcon
Definition: msconfig.c:44
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
const WCHAR * str
#define ProbeForReadUnicodeString(Ptr)
Definition: probe.h:77
#define STATUS_SUCCESS
Definition: shellext.h:65
static void Exit(void)
Definition: sock.c:1330
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG
Definition: typedefs.h:59
#define DC_DRAWCAPTIONMD
Definition: undocuser.h:151
#define DC_DRAWFRAMEMD
Definition: undocuser.h:153
BOOL UserDrawCaption(PWND pWnd, HDC hDc, RECTL *lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING Str, UINT uFlags)
Definition: painting.c:2185
VOID UserDrawCaptionBar(PWND pWnd, HDC hDC, INT Flags)
Definition: nonclient.c:924
LRESULT NC_DoNCPaint(PWND pWnd, HDC hDC, INT Flags)
Definition: nonclient.c:1066
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by DrawCaptionTempW(), and NtUserDrawCaption().

◆ NtUserEndPaint()

BOOL APIENTRY NtUserEndPaint ( HWND  hWnd,
CONST PAINTSTRUCT pUnsafePs 
)

Definition at line 1654 of file painting.c.

1655{
1657 PWND Window;
1658 PAINTSTRUCT Ps;
1660 BOOL Ret = FALSE;
1661
1662 TRACE("Enter NtUserEndPaint\n");
1664
1666 {
1667 goto Cleanup; // Return FALSE
1668 }
1669
1670 UserRefObjectCo(Window, &Ref); // Here for the exception.
1671
1672 _SEH2_TRY
1673 {
1674 ProbeForRead(pUnsafePs, sizeof(*pUnsafePs), 1);
1675 RtlCopyMemory(&Ps, pUnsafePs, sizeof(PAINTSTRUCT));
1676 }
1678 {
1680 }
1681 _SEH2_END
1682 if (!NT_SUCCESS(Status))
1683 {
1684 goto Cleanup; // Return FALSE
1685 }
1686
1687 Ret = IntEndPaint(Window, &Ps);
1688
1689Cleanup:
1691
1692 TRACE("Leave NtUserEndPaint, ret=%i\n", Ret);
1693 UserLeave();
1694 return Ret;
1695}
BOOL FASTCALL IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
Definition: painting.c:1532

Referenced by EndPaint().

◆ NtUserExcludeUpdateRgn()

INT APIENTRY NtUserExcludeUpdateRgn ( HDC  hDC,
HWND  hWnd 
)

Definition at line 2512 of file painting.c.

2515{
2516 INT ret = ERROR;
2517 PWND pWnd;
2518
2519 TRACE("Enter NtUserExcludeUpdateRgn\n");
2521
2522 pWnd = UserGetWindowObject(hWnd);
2523
2524 if (hDC && pWnd)
2526
2527 TRACE("Leave NtUserExcludeUpdateRgn, ret=%i\n", ret);
2528
2529 UserLeave();
2530 return ret;
2531}
INT FASTCALL co_UserExcludeUpdateRgn(HDC hDC, PWND Window)
Definition: painting.c:2459

Referenced by ExcludeUpdateRgn().

◆ NtUserFillWindow()

BOOL APIENTRY NtUserFillWindow ( HWND  hWndParent,
HWND  hWnd,
HDC  hDC,
HBRUSH  hBrush 
)

Definition at line 1704 of file painting.c.

1708{
1709 BOOL ret = FALSE;
1710 PWND pWnd, pWndParent = NULL;
1712
1713 TRACE("Enter NtUserFillWindow\n");
1715
1716 if (!hDC)
1717 {
1718 goto Exit;
1719 }
1720
1721 if (!(pWnd = UserGetWindowObject(hWnd)))
1722 {
1723 goto Exit;
1724 }
1725
1726 if (hWndParent && !(pWndParent = UserGetWindowObject(hWndParent)))
1727 {
1728 goto Exit;
1729 }
1730
1731 UserRefObjectCo(pWnd, &Ref);
1732 ret = IntFillWindow( pWndParent, pWnd, hDC, hBrush );
1733 UserDerefObjectCo(pWnd);
1734
1735Exit:
1736 TRACE("Leave NtUserFillWindow, ret=%i\n",ret);
1737 UserLeave();
1738 return ret;
1739}
BOOL FASTCALL IntFillWindow(PWND pWndParent, PWND pWnd, HDC hDC, HBRUSH hBrush)
Definition: painting.c:1555

◆ NtUserFlashWindowEx()

BOOL APIENTRY NtUserFlashWindowEx ( IN PFLASHWINFO  pfwi)

Definition at line 1745 of file painting.c.

1746{
1747 PWND pWnd;
1748 FLASHWINFO finfo = {0};
1749 BOOL Ret = FALSE;
1750
1752
1753 _SEH2_TRY
1754 {
1755 ProbeForRead(pfwi, sizeof(FLASHWINFO), 1);
1756 RtlCopyMemory(&finfo, pfwi, sizeof(FLASHWINFO));
1757 }
1759 {
1761 _SEH2_YIELD(goto Exit);
1762 }
1763 _SEH2_END
1764
1765 if (!( pWnd = ValidateHwndNoErr(finfo.hwnd)) ||
1766 finfo.cbSize != sizeof(FLASHWINFO) ||
1767 finfo.dwFlags & ~(FLASHW_ALL|FLASHW_TIMER|FLASHW_TIMERNOFG) )
1768 {
1770 goto Exit;
1771 }
1772
1773 Ret = IntFlashWindowEx(pWnd, &finfo);
1774
1775Exit:
1776 UserLeave();
1777 return Ret;
1778}
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
BOOL FASTCALL IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
Definition: painting.c:1304
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22

Referenced by FlashWindow(), and FlashWindowEx().

◆ NtUserGetUpdateRect()

BOOL APIENTRY NtUserGetUpdateRect ( HWND  hWnd,
LPRECT  UnsafeRect,
BOOL  bErase 
)

Definition at line 1955 of file painting.c.

1956{
1957 PWND Window;
1958 RECTL Rect;
1960 BOOL Ret = FALSE;
1961
1962 TRACE("Enter NtUserGetUpdateRect\n");
1964
1966 {
1967 goto Exit; // Return FALSE
1968 }
1969
1970 Ret = co_UserGetUpdateRect(Window, &Rect, bErase);
1971
1972 if (UnsafeRect != NULL)
1973 {
1974 Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECTL));
1975 if (!NT_SUCCESS(Status))
1976 {
1978 Ret = FALSE;
1979 }
1980 }
1981
1982Exit:
1983 TRACE("Leave NtUserGetUpdateRect, ret=%i\n", Ret);
1984 UserLeave();
1985 return Ret;
1986}
BOOL FASTCALL co_UserGetUpdateRect(PWND Window, PRECT pRect, BOOL bErase)
Definition: painting.c:1856

Referenced by GetUpdateRect().

◆ NtUserGetUpdateRgn()

INT APIENTRY NtUserGetUpdateRgn ( HWND  hWnd,
HRGN  hRgn,
BOOL  bErase 
)

Definition at line 1928 of file painting.c.

1929{
1930 PWND Window;
1931 INT ret = ERROR;
1932
1933 TRACE("Enter NtUserGetUpdateRgn\n");
1935
1937 if (Window)
1938 {
1939 ret = co_UserGetUpdateRgn(Window, hRgn, bErase);
1940 }
1941
1942 TRACE("Leave NtUserGetUpdateRgn, ret=%i\n", ret);
1943 UserLeave();
1944 return ret;
1945}
INT FASTCALL co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
Definition: painting.c:1784

Referenced by GetUpdateRgn().

◆ NtUserInvalidateRect()

BOOL APIENTRY NtUserInvalidateRect ( HWND  hWnd,
CONST RECT lpUnsafeRect,
BOOL  bErase 
)

Definition at line 2535 of file painting.c.

2539{
2540 UINT flags = RDW_INVALIDATE | (bErase ? RDW_ERASE : 0);
2541 if (!hWnd)
2542 {
2544 lpUnsafeRect = NULL;
2545 }
2546 return NtUserRedrawWindow(hWnd, lpUnsafeRect, NULL, flags);
2547}
GLbitfield flags
Definition: glext.h:7161
BOOL APIENTRY NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags)
Definition: painting.c:1996

Referenced by ComboWndProc_common(), and InvalidateRect().

◆ NtUserInvalidateRgn()

BOOL APIENTRY NtUserInvalidateRgn ( HWND  hWnd,
HRGN  hRgn,
BOOL  bErase 
)

Definition at line 2551 of file painting.c.

2555{
2556 if (!hWnd)
2557 {
2559 return FALSE;
2560 }
2561 return NtUserRedrawWindow(hWnd, NULL, hRgn, RDW_INVALIDATE | (bErase? RDW_ERASE : 0));
2562}
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881

Referenced by InvalidateRgn().

◆ NtUserPrintWindow()

BOOL APIENTRY NtUserPrintWindow ( HWND  hwnd,
HDC  hdcBlt,
UINT  nFlags 
)

Definition at line 2566 of file painting.c.

2570{
2571 PWND Window;
2572 BOOL Ret = FALSE;
2573
2575
2576 if (hwnd)
2577 {
2578 if (!(Window = UserGetWindowObject(hwnd)) ||
2580 {
2581 goto Exit;
2582 }
2583
2584 if ( Window )
2585 {
2586 /* Validate flags and check it as a mask for 0 or 1. */
2587 if ( (nFlags & PW_CLIENTONLY) == nFlags)
2588 Ret = IntPrintWindow( Window, hdcBlt, nFlags);
2589 else
2591 }
2592 }
2593Exit:
2594 UserLeave();
2595 return Ret;
2596}
BOOL FASTCALL IntPrintWindow(PWND pwnd, HDC hdcBlt, UINT nFlags)
Definition: painting.c:1252
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:197
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

◆ NtUserRedrawWindow()

BOOL APIENTRY NtUserRedrawWindow ( HWND  hWnd,
CONST RECT lprcUpdate,
HRGN  hrgnUpdate,
UINT  flags 
)

Definition at line 1996 of file painting.c.

2001{
2002 RECTL SafeUpdateRect;
2003 PWND Wnd;
2004 BOOL Ret = FALSE;
2007 PREGION RgnUpdate = NULL;
2008
2009 TRACE("Enter NtUserRedrawWindow\n");
2011
2013 {
2014 goto Exit; // Return FALSE
2015 }
2016
2017 if (lprcUpdate)
2018 {
2019 _SEH2_TRY
2020 {
2021 ProbeForRead(lprcUpdate, sizeof(RECTL), 1);
2022 RtlCopyMemory(&SafeUpdateRect, lprcUpdate, sizeof(RECTL));
2023 }
2025 {
2027 }
2028 _SEH2_END
2029 if (!NT_SUCCESS(Status))
2030 {
2032 goto Exit; // Return FALSE
2033 }
2034 }
2035
2039 {
2040 /* RedrawWindow fails only in case that flags are invalid */
2042 goto Exit; // Return FALSE
2043 }
2044
2045 /* We can't hold lock on GDI objects while doing roundtrips to user mode,
2046 * so it will be copied.
2047 */
2048 if (hrgnUpdate > HRGN_WINDOW)
2049 {
2050 RgnUpdate = REGION_LockRgn(hrgnUpdate);
2051 if (!RgnUpdate)
2052 {
2054 goto Exit; // Return FALSE
2055 }
2056 REGION_UnlockRgn(RgnUpdate);
2057 }
2058 else if (hrgnUpdate == HRGN_WINDOW) // Trap it out.
2059 {
2060 ERR("NTRW: Caller is passing Window Region 1\n");
2061 }
2062
2063 UserRefObjectCo(Wnd, &Ref);
2064
2065 Ret = co_UserRedrawWindow( Wnd,
2066 lprcUpdate ? &SafeUpdateRect : NULL,
2067 RgnUpdate,
2068 flags);
2069
2070 UserDerefObjectCo(Wnd);
2071
2072Exit:
2073 TRACE("Leave NtUserRedrawWindow, ret=%i\n", Ret);
2074 UserLeave();
2075 return Ret;
2076}
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1374
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583

Referenced by NtUserInvalidateRect(), NtUserInvalidateRgn(), NtUserValidateRect(), RedrawWindow(), SpiSetWallpaper(), and START_TEST().

◆ NtUserValidateRect()

BOOL APIENTRY NtUserValidateRect ( HWND  hWnd,
const RECT lpRect 
)

Definition at line 2602 of file painting.c.

2605{
2607 if (!hWnd)
2608 {
2610 lpRect = NULL;
2611 }
2612 return NtUserRedrawWindow(hWnd, lpRect, NULL, flags);
2613}

◆ PaintSuspendedWindow()

VOID FASTCALL PaintSuspendedWindow ( PWND  pwnd,
HRGN  hrgnOrig 
)

Definition at line 1018 of file painting.c.

1019{
1020 if (pwnd->hrgnUpdate)
1021 {
1022 HDC hDC;
1024 HRGN hrgnTemp;
1025 RECT Rect;
1026 INT type;
1027 PREGION prgn;
1028
1029 if (pwnd->hrgnUpdate > HRGN_WINDOW)
1030 {
1031 hrgnTemp = NtGdiCreateRectRgn(0, 0, 0, 0);
1032 type = NtGdiCombineRgn( hrgnTemp, pwnd->hrgnUpdate, 0, RGN_COPY);
1033 if (type == ERROR)
1034 {
1035 GreDeleteObject(hrgnTemp);
1036 hrgnTemp = HRGN_WINDOW;
1037 }
1038 }
1039 else
1040 {
1041 hrgnTemp = GreCreateRectRgnIndirect(&pwnd->rcWindow);
1042 }
1043
1044 if ( hrgnOrig &&
1045 hrgnTemp > HRGN_WINDOW &&
1046 NtGdiCombineRgn(hrgnTemp, hrgnTemp, hrgnOrig, RGN_AND) == NULLREGION)
1047 {
1048 GreDeleteObject(hrgnTemp);
1049 return;
1050 }
1051
1053
1054 Rect = pwnd->rcWindow;
1055 RECTL_vOffsetRect(&Rect, -pwnd->rcWindow.left, -pwnd->rcWindow.top);
1056
1057 // Clear out client area!
1059
1060 NC_DoNCPaint(pwnd, hDC, Flags); // Redraw without MENUs.
1061
1062 UserReleaseDC(pwnd, hDC, FALSE);
1063
1064 prgn = REGION_LockRgn(hrgnTemp);
1066 REGION_UnlockRgn(prgn);
1067
1068 // Set updates for this window.
1070
1071 // DCX_KEEPCLIPRGN is set. Check it anyway.
1072 if (hrgnTemp > HRGN_WINDOW && GreIsHandleValid(hrgnTemp)) GreDeleteObject(hrgnTemp);
1073 }
1074}
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
#define DC_NOSENDMSG
Definition: undocuser.h:148
#define COLOR_WINDOW
Definition: winuser.h:918
#define DC_NC
Definition: winuser.h:440

Referenced by UpdateTheadChildren().

◆ UpdateTheadChildren()

VOID FASTCALL UpdateTheadChildren ( PWND  pWnd,
HRGN  hRgn 
)

Definition at line 1077 of file painting.c.

1078{
1079 PaintSuspendedWindow( pWnd, hRgn );
1080
1081 if (!(pWnd->style & WS_CLIPCHILDREN))
1082 return;
1083
1084 pWnd = pWnd->spwndChild; // invalidate children if any.
1085 while (pWnd)
1086 {
1087 UpdateTheadChildren( pWnd, hRgn );
1088 pWnd = pWnd->spwndNext;
1089 }
1090}
VOID FASTCALL PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
Definition: painting.c:1018
VOID FASTCALL UpdateTheadChildren(PWND pWnd, HRGN hRgn)
Definition: painting.c:1077

Referenced by UpdateTheadChildren(), and UpdateThreadWindows().

◆ UpdateThreadWindows()

VOID FASTCALL UpdateThreadWindows ( PWND  pWnd,
PTHREADINFO  pti,
HRGN  hRgn 
)

Definition at line 1093 of file painting.c.

1094{
1095 PWND pwndTemp;
1096
1097 for ( pwndTemp = pWnd;
1098 pwndTemp;
1099 pwndTemp = pwndTemp->spwndNext )
1100 {
1101 if (pwndTemp->head.pti == pti)
1102 {
1104 }
1105 else
1106 {
1107 if (IsThreadSuspended(pwndTemp->head.pti) || MsqIsHung(pwndTemp->head.pti, MSQ_HUNG))
1108 {
1109 UpdateTheadChildren(pwndTemp, hRgn);
1110 }
1111 else
1113 }
1114 }
1115}
BOOL FASTCALL IsThreadSuspended(PTHREADINFO pti)
Definition: msgqueue.c:2168
BOOL FASTCALL MsqIsHung(PTHREADINFO pti, DWORD TimeOut)
Definition: msgqueue.c:2137
#define MSQ_HUNG
Definition: msgqueue.h:3

Referenced by DefWndDoSizeMove().

◆ UserDrawCaption()

BOOL UserDrawCaption ( PWND  pWnd,
HDC  hDc,
RECTL lpRc,
HFONT  hFont,
HICON  hIcon,
const PUNICODE_STRING  Str,
UINT  uFlags 
)

Definition at line 2185 of file painting.c.

2193{
2194 BOOL Ret = FALSE;
2195 HBRUSH hBgBrush, hOldBrush = NULL;
2196 RECTL Rect = *lpRc;
2197 BOOL HasIcon;
2198
2200
2201 /* Determine whether the icon needs to be displayed */
2202 if (!hIcon && pWnd != NULL)
2203 {
2204 HasIcon = (uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP) &&
2205 (pWnd->style & WS_SYSMENU) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW);
2206 }
2207 else
2208 HasIcon = (hIcon != NULL);
2209
2210 // Draw the caption background
2211 if((uFlags & DC_GRADIENT) && !(uFlags & DC_INBUTTON))
2212 {
2213 static GRADIENT_RECT gcap = {0, 1};
2214 TRIVERTEX Vertices[2];
2215 COLORREF Colors[2];
2216
2219
2222
2223 Vertices[0].x = Rect.left;
2224 Vertices[0].y = Rect.top;
2225 Vertices[0].Red = (WORD)Colors[0]<<8;
2226 Vertices[0].Green = (WORD)Colors[0] & 0xFF00;
2227 Vertices[0].Blue = (WORD)(Colors[0]>>8) & 0xFF00;
2228 Vertices[0].Alpha = 0;
2229
2230 Vertices[1].x = Rect.right;
2231 Vertices[1].y = Rect.bottom;
2232 Vertices[1].Red = (WORD)Colors[1]<<8;
2233 Vertices[1].Green = (WORD)Colors[1] & 0xFF00;
2234 Vertices[1].Blue = (WORD)(Colors[1]>>8) & 0xFF00;
2235 Vertices[1].Alpha = 0;
2236
2237 if(!GreGradientFill(hDc, Vertices, 2, &gcap, 1, GRADIENT_FILL_RECT_H))
2238 {
2239 ERR("GreGradientFill() failed!\n");
2240 goto cleanup;
2241 }
2242 }
2243 else
2244 {
2245 if(uFlags & DC_INBUTTON)
2247 else if(uFlags & DC_ACTIVE)
2249 else
2251
2252 hOldBrush = NtGdiSelectBrush(hDc, hBgBrush);
2253
2254 if(!hOldBrush)
2255 {
2256 ERR("NtGdiSelectBrush() failed!\n");
2257 goto cleanup;
2258 }
2259
2260 if(!NtGdiPatBlt(hDc, Rect.left, Rect.top,
2261 Rect.right - Rect.left,
2262 Rect.bottom - Rect.top,
2263 PATCOPY))
2264 {
2265 ERR("NtGdiPatBlt() failed!\n");
2266 goto cleanup;
2267 }
2268 }
2269
2270 /* Draw icon */
2271 if (HasIcon)
2272 {
2273 PCURICON_OBJECT pIcon = NULL;
2274
2275 if (hIcon)
2276 {
2277 pIcon = UserGetCurIconObject(hIcon);
2278 }
2279 else if (pWnd)
2280 {
2281 pIcon = NC_IconForWindow(pWnd);
2282 // FIXME: NC_IconForWindow should reference it for us */
2283 if (pIcon)
2284 UserReferenceObject(pIcon);
2285 }
2286
2287 if (pIcon)
2288 {
2291 LONG x = Rect.left - cx/2 + 1 + (Rect.bottom - Rect.top)/2; // this is really what Window does
2292 LONG y = (Rect.top + Rect.bottom - cy)/2; // center
2293 UserDrawIconEx(hDc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
2294 UserDereferenceObject(pIcon);
2295 }
2296 else
2297 {
2298 HasIcon = FALSE;
2299 }
2300 }
2301
2302 if (HasIcon)
2303 Rect.left += Rect.bottom - Rect.top;
2304
2305 if((uFlags & DC_TEXT))
2306 {
2307 BOOL Set = FALSE;
2308 Rect.left += 2;
2309
2310 if (Str)
2311 Set = UserDrawCaptionText(pWnd, hDc, Str, &Rect, uFlags, hFont);
2312 else if (pWnd != NULL) // FIXME: Windows does not do that
2313 {
2314 UNICODE_STRING ustr;
2315 ustr.Buffer = pWnd->strName.Buffer; // FIXME: LARGE_STRING truncated!
2316 ustr.Length = (USHORT)min(pWnd->strName.Length, MAXUSHORT);
2318 Set = UserDrawCaptionText(pWnd, hDc, &ustr, &Rect, uFlags, hFont);
2319 }
2320 if (pWnd)
2321 {
2322 if (Set)
2323 pWnd->state2 &= ~WNDS2_CAPTIONTEXTTRUNCATED;
2324 else
2326 }
2327 }
2328
2329 Ret = TRUE;
2330
2331cleanup:
2332 if (hOldBrush) NtGdiSelectBrush(hDc, hOldBrush);
2333
2334 return Ret;
2335}
Colors
Definition: ansiprsr.h:4
#define DC_ACTIVE
Definition: dc21x4.h:120
static void cleanup(void)
Definition: main.c:1335
unsigned short WORD
Definition: ntddk_ex.h:93
BOOL NTAPI GreGradientFill(HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode)
Definition: fillshap.c:940
#define WNDS2_CAPTIONTEXTTRUNCATED
Definition: ntuser.h:666
DWORD FASTCALL IntGetSysColor(INT nIndex)
Definition: stockobj.c:323
#define min(a, b)
Definition: monoChain.cc:55
__kernel_entry W32KAPI HBRUSH APIENTRY NtGdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbrush)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiPatBlt(_In_ HDC hdcDest, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_ DWORD dwRop)
Definition: bitblt.c:984
static BOOL Set
Definition: pageheap.c:10
#define WS_SYSMENU
Definition: pedump.c:629
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
COLOR16 Red
Definition: wingdi.h:2786
LONG y
Definition: wingdi.h:2785
COLOR16 Green
Definition: wingdi.h:2787
COLOR16 Alpha
Definition: wingdi.h:2789
COLOR16 Blue
Definition: wingdi.h:2788
LONG x
Definition: wingdi.h:2784
USHORT MaximumLength
Definition: env_spec_w32.h:370
LARGE_UNICODE_STRING strName
Definition: ntuser.h:736
#define MAXUSHORT
Definition: typedefs.h:83
BOOL UserDrawCaptionText(PWND pWnd, HDC hDc, const PUNICODE_STRING Text, const RECTL *lpRc, UINT uFlags, HFONT hFont)
Definition: painting.c:2079
VOID FASTCALL RECTL_vMakeWellOrdered(_Inout_ RECTL *prcl)
Definition: rect.c:81
PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon)
Definition: cursoricon.c:200
BOOL UserDrawIconEx(HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
Definition: cursoricon.c:1685
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:213
PCURICON_OBJECT FASTCALL NC_IconForWindow(PWND pWnd)
Definition: nonclient.c:705
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731
DWORD COLORREF
Definition: windef.h:300
#define DI_NORMAL
Definition: wingdi.h:72
#define PATCOPY
Definition: wingdi.h:335
#define DC_INBUTTON
Definition: winuser.h:431
#define COLOR_GRADIENTINACTIVECAPTION
Definition: winuser.h:945
#define COLOR_ACTIVECAPTION
Definition: winuser.h:915
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
#define SM_CYSMICON
Definition: winuser.h:1013
#define COLOR_INACTIVECAPTION
Definition: winuser.h:916
#define COLOR_GRADIENTACTIVECAPTION
Definition: winuser.h:944
#define SM_CXSMICON
Definition: winuser.h:1012
#define DC_TEXT
Definition: winuser.h:430
#define DC_ICON
Definition: winuser.h:429
#define DC_SMALLCAP
Definition: winuser.h:428
#define COLOR_3DFACE
Definition: winuser.h:929

Referenced by NC_DoNCPaint(), NtUserDrawCaptionTemp(), and UserDrawCaptionBar().

◆ UserDrawCaptionText()

BOOL UserDrawCaptionText ( PWND  pWnd,
HDC  hDc,
const PUNICODE_STRING  Text,
const RECTL lpRc,
UINT  uFlags,
HFONT  hFont 
)

Definition at line 2079 of file painting.c.

2086{
2087 HFONT hOldFont = NULL;
2088 COLORREF OldTextColor;
2089 NONCLIENTMETRICSW nclm;
2091 BOOLEAN bDeleteFont = FALSE;
2092 SIZE Size;
2093 BOOL Ret = TRUE;
2094 ULONG fit = 0, Length;
2095 RECTL r = *lpRc;
2096
2097 TRACE("UserDrawCaptionText: %wZ\n", Text);
2098
2099 nclm.cbSize = sizeof(nclm);
2100 if (!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0))
2101 {
2102 ERR("UserSystemParametersInfo() failed!\n");
2103 return FALSE;
2104 }
2105
2106 if (!hFont)
2107 {
2108 if(uFlags & DC_SMALLCAP)
2109 Status = TextIntCreateFontIndirect(&nclm.lfSmCaptionFont, &hFont);
2110 else
2111 Status = TextIntCreateFontIndirect(&nclm.lfCaptionFont, &hFont);
2112
2113 if(!NT_SUCCESS(Status))
2114 {
2115 ERR("TextIntCreateFontIndirect() failed! Status: 0x%x\n", Status);
2116 return FALSE;
2117 }
2118
2119 bDeleteFont = TRUE;
2120 }
2121
2123
2124 hOldFont = NtGdiSelectFont(hDc, hFont);
2125
2126 if(uFlags & DC_INBUTTON)
2127 OldTextColor = IntGdiSetTextColor(hDc, IntGetSysColor(COLOR_BTNTEXT));
2128 else
2129 OldTextColor = IntGdiSetTextColor(hDc,
2131
2132 // Adjust for system menu.
2133 if (pWnd && pWnd->style & WS_SYSMENU)
2134 {
2135 r.right -= UserGetSystemMetrics(SM_CYCAPTION) - 1;
2136 if ((pWnd->style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW))
2137 {
2138 r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2139 r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2140 }
2141 }
2142
2143 GreGetTextExtentExW(hDc, Text->Buffer, Text->Length/sizeof(WCHAR), r.right - r.left, &fit, 0, &Size, 0);
2144
2145 Length = (Text->Length/sizeof(WCHAR) == fit ? fit : fit+1);
2146
2147 if (Text->Length/sizeof(WCHAR) > Length)
2148 {
2149 Ret = FALSE;
2150 }
2151
2152 if (Ret)
2153 { // Faster while in setup.
2154 UserExtTextOutW( hDc,
2155 lpRc->left,
2156 lpRc->top + (lpRc->bottom - lpRc->top - Size.cy) / 2, // DT_SINGLELINE && DT_VCENTER
2158 (RECTL *)lpRc,
2159 Text->Buffer,
2160 Length);
2161 }
2162 else
2163 {
2164 DrawTextW( hDc,
2165 Text->Buffer,
2166 Text->Length/sizeof(WCHAR),
2167 (RECTL *)&r,
2169 }
2170
2171 IntGdiSetTextColor(hDc, OldTextColor);
2172
2173 if (hOldFont)
2174 NtGdiSelectFont(hDc, hOldFont);
2175
2176 if (bDeleteFont)
2178
2179 return Ret;
2180}
unsigned char BOOLEAN
char * Text
Definition: combotst.c:136
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
INT FASTCALL IntGdiSetBkMode(HDC hDC, INT backgroundMode)
Definition: dcutil.c:124
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont)
Definition: freetype.c:1991
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:16
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define WS_MINIMIZEBOX
Definition: pedump.c:631
long bottom
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
BOOL UserExtTextOutW(HDC hdc, INT x, INT y, UINT flags, PRECTL lprc, LPCWSTR lpString, UINT count)
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
BOOL FASTCALL GreGetTextExtentExW(HDC hDC, LPCWSTR String, ULONG Count, ULONG MaxExtent, PULONG Fit, PULONG Dx, LPSIZE pSize, FLONG fl)
Definition: text.c:135
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2105
#define TRANSPARENT
Definition: wingdi.h:950
#define ETO_CLIPPED
Definition: wingdi.h:648
#define DT_NOPREFIX
Definition: winuser.h:537
#define COLOR_BTNTEXT
Definition: winuser.h:933
#define COLOR_INACTIVECAPTIONTEXT
Definition: winuser.h:934
#define DT_END_ELLIPSIS
Definition: winuser.h:529
#define DT_SINGLELINE
Definition: winuser.h:540
#define SM_CXSIZE
Definition: winuser.h:991
#define DT_LEFT
Definition: winuser.h:534
#define DT_VCENTER
Definition: winuser.h:543
#define COLOR_CAPTIONTEXT
Definition: winuser.h:922
#define SM_CYCAPTION
Definition: winuser.h:963

Referenced by UserDrawCaption().

◆ UserExtTextOutW()

BOOL UserExtTextOutW ( HDC  hdc,
INT  x,
INT  y,
UINT  flags,
PRECTL  lprc,
LPCWSTR  lpString,
UINT  count 
)

◆ UserRealizePalette()

INT FASTCALL UserRealizePalette ( HDC  hdc)

Definition at line 2339 of file painting.c.

2340{
2341 HWND hWnd, hWndDesktop;
2342 DWORD Ret;
2343
2345 if (Ret) // There was a change.
2346 {
2348 if (hWnd) // Send broadcast if dc is associated with a window.
2349 { // FYI: Thread locked in CallOneParam.
2350 hWndDesktop = IntGetDesktopWindow();
2351 if ( hWndDesktop != hWnd )
2352 {
2353 PWND pWnd = UserGetWindowObject(hWndDesktop);
2354 ERR("RealizePalette Desktop.\n");
2355 hdc = UserGetWindowDC(pWnd);
2357 UserReleaseDC(pWnd,hdc,FALSE);
2358 }
2360 }
2361 }
2362 return Ret;
2363}
UINT FASTCALL IntGdiRealizePalette(HDC)
Definition: palette.c:731
HWND FASTCALL IntWindowFromDC(HDC hDc)
Definition: windc.c:894
unsigned long DWORD
Definition: ntddk_ex.h:95
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:947
BOOL FASTCALL IntPaintDesktop(HDC hDC)
Definition: desktop.c:1835
BOOL FASTCALL UserSendNotifyMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2040
#define HWND_BROADCAST
Definition: winuser.h:1204
#define WM_PALETTECHANGED
Definition: winuser.h:1877

◆ UserSyncAndPaintWindows()

VOID FASTCALL UserSyncAndPaintWindows ( PWND  pWnd,
ULONG  Flags 
)

Definition at line 620 of file painting.c.

621{
622 PWND Parent = pWnd;
623 // Find parent, if it needs to be painted, leave.
624 while(TRUE)
625 {
626 if ((Parent = Parent->spwndParent) == NULL) break;
627 if ( Parent->style & WS_CLIPCHILDREN ) break;
628 if ( Parent->hrgnUpdate != NULL || Parent->state & WNDS_INTERNALPAINT ) return;
629 }
630
631 IntSendSyncPaint(pWnd, Flags);
633}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732

Referenced by co_UserRedrawWindow(), and co_WinPosSetWindowPos().

◆ UserUpdateWindows()

VOID FASTCALL UserUpdateWindows ( PWND  pWnd,
ULONG  Flags 
)

Definition at line 598 of file painting.c.

599{
600 // If transparent and any sibling windows below needs to be painted, leave.
601 if (pWnd->ExStyle & WS_EX_TRANSPARENT)
602 {
603 PWND Next = pWnd->spwndNext;
604
605 while(Next)
606 {
607 if ( Next->head.pti == pWnd->head.pti &&
608 ( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT) )
609 {
610 return;
611 }
612
613 Next = Next->spwndNext;
614 }
615 }
617}

Referenced by co_UserRedrawWindow(), and UpdateThreadWindows().