ReactOS 0.4.15-dev-7906-g1b85a5f
painting.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Window painting function
5 * FILE: win32ss/user/ntuser/painting.c
6 * PROGRAMER: Filip Navara (xnavara@volny.cz)
7 */
8
9#include <win32k.h>
10DBG_DEFAULT_CHANNEL(UserPainting);
11
13 LPCWSTR lpString, UINT count);
14
15/* PRIVATE FUNCTIONS **********************************************************/
16
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}
60
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}
127
128/*
129 Synchronize painting to the top-level windows of other threads.
130*/
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}
201
202/*
203 * @name IntCalcWindowRgn
204 *
205 * Get a window or client region.
206 */
207
208HRGN FASTCALL
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}
243
244/*
245 * @name IntGetNCUpdateRgn
246 *
247 * Get non-client update region of a window and optionally validate it.
248 *
249 * @param Window
250 * Pointer to window to get the NC update region from.
251 * @param Validate
252 * Set to TRUE to force validating the NC update region.
253 *
254 * @return
255 * Handle to NC update region. The caller is responsible for deleting
256 * it.
257 */
258
259HRGN FASTCALL
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}
346
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}
368
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}
395
396/*
397 * IntPaintWindows
398 *
399 * Internal function used by IntRedrawWindow.
400 */
401
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}
511
512/*
513 * IntUpdateWindows
514 *
515 * Internal function used by IntRedrawWindow, simplecall.
516 */
517
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}
596
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}
618
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}
634
635/*
636 * IntInvalidateWindows
637 *
638 * Internal function used by IntRedrawWindow, UserRedrawDesktop,
639 * co_WinPosSetWindowPos, co_UserRedrawWindow.
640 */
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}
851
852/*
853 * IntIsWindowDrawable
854 *
855 * Remarks
856 * Window is drawable when it is visible and all parents are not
857 * minimized.
858 */
859
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}
879
880/*
881 * IntRedrawWindow
882 *
883 * Internal version of NtUserRedrawWindow that takes WND as
884 * first parameter.
885 */
886
889 PWND Window,
890 const RECTL* UpdateRect,
891 PREGION UpdateRgn,
892 ULONG Flags)
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}
1016
1018PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
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}
1075
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}
1091
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}
1116
1119{
1120 return ( Wnd->style & WS_VISIBLE &&
1121 ( Wnd->hrgnUpdate != NULL ||
1122 Wnd->state & WNDS_INTERNALPAINT ) );
1123}
1124
1125/*
1126 Conditions to paint any window:
1127
1128 1. Update region is not null.
1129 2. Internal paint flag is set.
1130 3. Paint count is not zero.
1131
1132 */
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}
1172
1173//
1174// Internal painting of windows.
1175//
1178{
1179 // Handle normal painting.
1181}
1182
1185 PWND Window,
1186 UINT MsgFilterMin,
1187 UINT MsgFilterMax,
1189 MSG *Message,
1190 BOOL Remove)
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}
1249
1250BOOL
1253 PWND pwnd,
1254 HDC hdcBlt,
1255 UINT nFlags)
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}
1301
1302BOOL
1304IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
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}
1432
1433// Win: xxxBeginPaint
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}
1529
1530// Win: xxxEndPaint
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}
1552
1553// Win: xxxFillWindow
1556 PWND pWnd,
1557 HDC hDC,
1558 HBRUSH hBrush)
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}
1597
1598/* PUBLIC FUNCTIONS ***********************************************************/
1599
1600/*
1601 * NtUserBeginPaint
1602 *
1603 * Status
1604 * @implemented
1605 */
1606
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}
1645
1646/*
1647 * NtUserEndPaint
1648 *
1649 * Status
1650 * @implemented
1651 */
1652
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}
1696
1697/*
1698 * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
1699 */
1700/*
1701 * @implemented
1702 */
1705 HWND hWnd,
1706 HDC hDC,
1707 HBRUSH hBrush)
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}
1740
1741/*
1742 * @implemented
1743 */
1745NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
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}
1779
1780/*
1781 GetUpdateRgn, this fails the same as the old one.
1782 */
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}
1854
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}
1919
1920/*
1921 * NtUserGetUpdateRgn
1922 *
1923 * Status
1924 * @implemented
1925 */
1926
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}
1946
1947/*
1948 * NtUserGetUpdateRect
1949 *
1950 * Status
1951 * @implemented
1952 */
1953
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}
1987
1988/*
1989 * NtUserRedrawWindow
1990 *
1991 * Status
1992 * @implemented
1993 */
1994
1997 HWND hWnd,
1998 CONST RECT *lprcUpdate,
1999 HRGN hrgnUpdate,
2000 UINT flags)
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}
2077
2078BOOL
2080 PWND pWnd,
2081 HDC hDc,
2082 const PUNICODE_STRING Text,
2083 const RECTL *lpRc,
2084 UINT uFlags,
2085 HFONT hFont)
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}
2181
2182//
2183// This draws Buttons, Icons and Text...
2184//
2186 PWND pWnd,
2187 HDC hDc,
2188 RECTL *lpRc,
2189 HFONT hFont,
2190 HICON hIcon,
2191 const PUNICODE_STRING Str,
2192 UINT uFlags)
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}
2336
2337INT
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}
2364
2365BOOL
2368 HWND hWnd,
2369 HDC hDC,
2370 LPCRECT lpRc,
2371 HFONT hFont,
2372 HICON hIcon,
2373 const PUNICODE_STRING str,
2374 UINT uFlags)
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}
2447
2448BOOL
2451 HDC hDC,
2452 LPCRECT lpRc,
2453 UINT uFlags)
2454{
2455 return NtUserDrawCaptionTemp(hWnd, hDC, lpRc, 0, 0, NULL, uFlags);
2456}
2457
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}
2509
2510INT
2513 HDC hDC,
2514 HWND hWnd)
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}
2532
2533BOOL
2536 HWND hWnd,
2537 CONST RECT *lpUnsafeRect,
2538 BOOL bErase)
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}
2548
2549BOOL
2552 HWND hWnd,
2553 HRGN hRgn,
2554 BOOL bErase)
2555{
2556 if (!hWnd)
2557 {
2559 return FALSE;
2560 }
2561 return NtUserRedrawWindow(hWnd, NULL, hRgn, RDW_INVALIDATE | (bErase? RDW_ERASE : 0));
2562}
2563
2564BOOL
2567 HWND hwnd,
2568 HDC hdcBlt,
2569 UINT nFlags)
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}
2597
2598/* ValidateRect gets redirected to NtUserValidateRect:
2599 http://blog.csdn.net/ntdll/archive/2005/10/19/509299.aspx */
2600BOOL
2603 HWND hWnd,
2604 const RECT *lpRect)
2605{
2607 if (!hWnd)
2608 {
2610 lpRect = NULL;
2611 }
2612 return NtUserRedrawWindow(hWnd, lpRect, NULL, flags);
2613}
2614
2615/* EOF */
static HDC hDC
Definition: 3dtext.c:33
#define DCX_USESTYLE
Definition: GetDCEx.c:10
static HRGN hrgn
unsigned char BOOLEAN
Type
Definition: Type.h:7
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
Colors
Definition: ansiprsr.h:4
HWND hWnd
Definition: settings.c:17
LONG NTSTATUS
Definition: precomp.h:26
HFONT hFont
Definition: main.c:53
#define HandleToUlong(h)
Definition: basetsd.h:79
#define ERR(fmt,...)
Definition: debug.h:110
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:103
UINT FASTCALL IntGdiRealizePalette(HDC)
Definition: palette.c:731
char * Text
Definition: combotst.c:136
BOOL FASTCALL GreDPtoLP(HDC, LPPOINT, INT)
Definition: dcutil.c:7
#define DC_ACTIVE
Definition: dc21x4.h:120
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
INT FASTCALL IntGdiSetBkMode(HDC hDC, INT backgroundMode)
Definition: dcutil.c:124
BOOL FASTCALL GreSetBrushOrg(HDC, INT, INT, LPPOINT)
Definition: dcutil.c:231
HWND FASTCALL IntWindowFromDC(HDC hDc)
Definition: windc.c:894
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define APIENTRY
Definition: api.h:79
UINT uFlags
Definition: api.c:59
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
PSERVERINFO gpsi
Definition: imm.c:18
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
static void cleanup(void)
Definition: main.c:1335
static const WCHAR Message[]
Definition: register.c:74
static const WCHAR Cleanup[]
Definition: register.c:80
#define pt(x, y)
Definition: drawing.c:79
void Erase(HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2, COLORREF color, LONG radius)
Definition: drawing.cpp:115
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define ERROR(name)
Definition: error_private.h: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
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
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
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2653
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont)
Definition: freetype.c:1991
RegionType
Status
Definition: gdiplustypes.h:25
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLbitfield flags
Definition: glext.h:7161
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define WNDS2_FORCEFULLNCPAINTCLIPRGN
Definition: ntuser.h:664
#define WNDS2_ENDPAINTINVALIDATE
Definition: ntuser.h:642
#define WNDS_ACTIVEFRAME
Definition: ntuser.h:611
#define WNDS_SYNCPAINTPENDING
Definition: ntuser.h:628
#define WNDS_DESTROYED
Definition: ntuser.h:636
#define WNDS_SENDNCPAINT
Definition: ntuser.h:616
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define WNDS_INTERNALPAINT
Definition: ntuser.h:617
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:805
#define WNDS2_CAPTIONTEXTTRUNCATED
Definition: ntuser.h:666
#define WNDS2_WMPAINTSENT
Definition: ntuser.h:641
#define WNDS_ERASEBACKGROUND
Definition: ntuser.h:615
#define WNDS_UPDATEDIRTY
Definition: ntuser.h:618
#define WNDS2_INDESTROY
Definition: ntuser.h:648
#define TIF_SYSTEMTHREAD
Definition: ntuser.h:265
#define WNDS_PAINTNOTPROCESSED
Definition: ntuser.h:627
#define WNDS2_STARTPAINT
Definition: ntuser.h:643
#define HRGN_WINDOW
Definition: ntuser.h:361
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:614
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
DWORD FASTCALL IntGetSysColor(INT nIndex)
Definition: stockobj.c:323
static LPMONITOREX pm
Definition: localmon.c:45
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define CLIPRGN
Definition: precomp.h:18
HDC hdc
Definition: main.c:9
static HDC
Definition: imagelist.c:92
static HICON
Definition: imagelist.c:84
static HTREEITEM hChild
Definition: treeview.c:381
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
static HRGN hRgn
Definition: mapping.c:33
static IHTMLWindow2 * window
Definition: events.c:77
#define min(a, b)
Definition: monoChain.cc:55
HICON hIcon
Definition: msconfig.c:44
VOID FASTCALL MsqDecPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:508
VOID FASTCALL MsqIncPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:501
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
unsigned int UINT
Definition: ndis.h:50
#define FASTCALL
Definition: nt_native.h:50
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
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 BOOL APIENTRY NtGdiSetRectRgn(_In_ HRGN hrgn, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: region.c:4048
__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)
__kernel_entry W32KAPI HBRUSH APIENTRY NtGdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbrush)
__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 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
__kernel_entry W32KAPI INT APIENTRY NtGdiOffsetRgn(_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:3961
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
@ GdiGetDCOrg
Definition: ntgdityp.h:80
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:16
BOOL FASTCALL IntGetWindowRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:121
ATOM AtomFlashWndState
Definition: ntuser.c:22
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:251
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:242
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
static BOOL Set
Definition: pageheap.c:10
#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 RDW_NOUPDATEDIRTY
Definition: painting.h:16
#define FLASHW_SYSTIMER
Definition: painting.h:4
#define RDW_CLIPCHILDREN
Definition: painting.h:15
#define FLASHW_MASK
Definition: painting.h:3
#define PRGN_WINDOW
Definition: painting.h:12
#define FLASHW_KILLSYSTIMER
Definition: painting.h:8
#define LOWORD(l)
Definition: pedump.c:82
#define WS_CHILD
Definition: pedump.c:617
#define CONST
Definition: pedump.c:81
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define WS_SYSMENU
Definition: pedump.c:629
#define WS_BORDER
Definition: pedump.c:625
#define WS_MINIMIZE
Definition: pedump.c:622
#define WS_VISIBLE
Definition: pedump.c:620
long LONG
Definition: pedump.c:60
#define WS_DLGFRAME
Definition: pedump.c:626
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
unsigned short USHORT
Definition: pedump.c:61
#define WS_CLIPCHILDREN
Definition: pedump.c:619
#define WS_MINIMIZEBOX
Definition: pedump.c:631
HANDLE FASTCALL UserRemoveProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#define GreCreateRectRgnIndirect(prc)
Definition: region.h:96
#define GreSetRectRgnIndirect(hRgn, prc)
Definition: region.h:99
#define IntSysCreateRectpRgnIndirect(prc)
Definition: region.h:93
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 TRACE(s)
Definition: solgame.cpp:4
Definition: client.c:28
base of all file and directory entries
Definition: entries.h:83
long bottom
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
Definition: window.c:28
UINT style
Definition: ntuser.h:580
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
Definition: region.h:8
PPROCESSINFO ppi
Definition: win32.h:88
LIST_ENTRY SentMessagesListHead
Definition: win32.h:100
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
Definition: object.h:4
Definition: ntuser.h:694
DWORD ExStyle
Definition: ntuser.h:704
HRGN hrgnClip
Definition: ntuser.h:733
PCLS pcls
Definition: ntuser.h:720
THRDESKHEAD head
Definition: ntuser.h:695
DWORD style
Definition: ntuser.h:706
DWORD state2
Definition: ntuser.h:702
struct _WND * spwndChild
Definition: ntuser.h:714
RECT rcClient
Definition: ntuser.h:717
HRGN hrgnUpdate
Definition: ntuser.h:721
LARGE_UNICODE_STRING strName
Definition: ntuser.h:736
DWORD state
Definition: ntuser.h:701
struct _WND * spwndNext
Definition: ntuser.h:711
RECT rcWindow
Definition: ntuser.h:716
struct _WND * spwndParent
Definition: ntuser.h:713
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
static int UpdateRect(TreeListData *pData, unsigned uItem, unsigned uSub)
Definition: treelist.c:1529
#define DWORD_PTR
Definition: treelist.c:76
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint32_t DWORD_PTR
Definition: typedefs.h:65
int32_t INT
Definition: typedefs.h:58
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define MAXUSHORT
Definition: typedefs.h:83
#define IN
Definition: typedefs.h:39
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define HIWORD(l)
Definition: typedefs.h:247
#define DC_NOSENDMSG
Definition: undocuser.h:148
#define DCX_KEEPCLIPRGN
Definition: undocuser.h:68
#define DC_DRAWCAPTIONMD
Definition: undocuser.h:151
#define WS_EX_REDIRECTED
Definition: undocuser.h:25
#define DC_DRAWFRAMEMD
Definition: undocuser.h:153
VOID FASTCALL IntSendChildNCPaint(PWND pWnd)
Definition: painting.c:370
BOOL FASTCALL IntPrintWindow(PWND pwnd, HDC hdcBlt, UINT nFlags)
Definition: painting.c:1252
INT FASTCALL UserRealizePalette(HDC hdc)
Definition: painting.c:2339
BOOL FASTCALL IntFillWindow(PWND pWndParent, PWND pWnd, HDC hDC, HBRUSH hBrush)
Definition: painting.c:1555
VOID FASTCALL IntSendSyncPaint(PWND Wnd, ULONG Flags)
Definition: painting.c:132
INT APIENTRY NtUserGetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
Definition: painting.c:1928
BOOL FASTCALL IntIsWindowDrawable(PWND Wnd)
Definition: painting.c:861
VOID FASTCALL PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
Definition: painting.c:1018
VOID FASTCALL IntPaintWindow(PWND Window)
Definition: painting.c:1177
VOID FASTCALL UpdateTheadChildren(PWND pWnd, HRGN hRgn)
Definition: painting.c:1077
VOID FASTCALL UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:620
INT FASTCALL co_UserExcludeUpdateRgn(HDC hDC, PWND Window)
Definition: painting.c:2459
BOOL UserDrawCaptionText(PWND pWnd, HDC hDc, const PUNICODE_STRING Text, const RECTL *lpRc, UINT uFlags, HFONT hFont)
Definition: painting.c:2079
HRGN FASTCALL IntGetNCUpdateRgn(PWND Window, BOOL Validate)
Definition: painting.c:260
BOOL FASTCALL IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
Definition: painting.c:1304
BOOL FASTCALL IntValidateParents(PWND Child, BOOL Recurse)
Definition: painting.c:62
VOID FASTCALL UserUpdateWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:598
BOOL UserDrawCaption(PWND pWnd, HDC hDc, RECTL *lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING Str, UINT uFlags)
Definition: painting.c:2185
BOOL APIENTRY NtUserDrawCaptionTemp(HWND hWnd, HDC hDC, LPCRECT lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING str, UINT uFlags)
Definition: painting.c:2367
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
HDC FASTCALL IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
Definition: painting.c:1435
BOOL FASTCALL IntIntersectWithParents(PWND Child, RECTL *WindowRect)
Definition: painting.c:35
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
BOOL APIENTRY NtUserDrawCaption(HWND hWnd, HDC hDC, LPCRECT lpRc, UINT uFlags)
Definition: painting.c:2450
PWND FASTCALL IntFindWindowToRepaint(PWND Window, PTHREADINFO Thread)
Definition: painting.c:1134
VOID FASTCALL UpdateThreadWindows(PWND pWnd, PTHREADINFO pti, HRGN hRgn)
Definition: painting.c:1093
BOOL APIENTRY NtUserPrintWindow(HWND hwnd, HDC hdcBlt, UINT nFlags)
Definition: painting.c:2566
BOOL FASTCALL IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
Definition: painting.c:1532
BOOL APIENTRY NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags)
Definition: painting.c:1996
VOID FASTCALL co_IntUpdateWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:519
BOOL UserExtTextOutW(HDC hdc, INT x, INT y, UINT flags, PRECTL lprc, LPCWSTR lpString, UINT count)
BOOL APIENTRY NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
Definition: painting.c:1955
HRGN FASTCALL IntCalcWindowRgn(PWND Wnd, BOOL Client)
Definition: painting.c:209
BOOL FASTCALL IntIsWindowDirty(PWND Wnd)
Definition: painting.c:1118
BOOL FASTCALL IntGetPaintMessage(PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, PTHREADINFO Thread, MSG *Message, BOOL Remove)
Definition: painting.c:1184
BOOL APIENTRY NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
Definition: painting.c:1745
BOOL APIENTRY NtUserInvalidateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
Definition: painting.c:2551
INT APIENTRY NtUserExcludeUpdateRgn(HDC hDC, HWND hWnd)
Definition: painting.c:2512
BOOL FASTCALL co_UserGetUpdateRect(PWND Window, PRECT pRect, BOOL bErase)
Definition: painting.c:1856
INT FASTCALL co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
Definition: painting.c:1784
HDC APIENTRY NtUserBeginPaint(HWND hWnd, PAINTSTRUCT *UnsafePs)
Definition: painting.c:1608
BOOL APIENTRY NtUserValidateRect(HWND hWnd, const RECT *lpRect)
Definition: painting.c:2602
BOOL APIENTRY NtUserInvalidateRect(HWND hWnd, CONST RECT *lpUnsafeRect, BOOL bErase)
Definition: painting.c:2535
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:642
BOOL APIENTRY NtUserFillWindow(HWND hWndParent, HWND hWnd, HDC hDC, HBRUSH hBrush)
Definition: painting.c:1704
BOOL APIENTRY NtUserEndPaint(HWND hWnd, CONST PAINTSTRUCT *pUnsafePs)
Definition: painting.c:1654
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:947
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:14
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
@ Start
Definition: partlist.h:33
int ret
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:536
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
BOOL NTAPI GreIsHandleValid(HGDIOBJ hobj)
Definition: gdiobj.c:1146
VOID FASTCALL RECTL_vMakeWellOrdered(_Inout_ RECTL *prcl)
Definition: rect.c:81
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
FORCEINLINE BOOL RECTL_bIsEmptyRect(_In_ const RECTL *prcl)
Definition: rect.h:44
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2449
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2358
BOOL FASTCALL IntGdiSetRegionOwner(HRGN hRgn, DWORD OwnerMask)
Definition: region.c:2459
INT APIENTRY IntGdiGetRgnBox(HRGN hRgn, PRECTL pRect)
Definition: region.c:2561
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2373
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
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 co_UserHideCaret(PWND Window OPTIONAL)
Definition: caret.c:226
BOOL FASTCALL co_UserShowCaret(PWND Window OPTIONAL)
Definition: caret.c:262
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:1687
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1374
BOOL FASTCALL IntPaintDesktop(HDC hDC)
Definition: desktop.c:1835
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:197
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:194
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1713
BOOL FASTCALL UserSendNotifyMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2040
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1445
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:213
HBRUSH FASTCALL GetControlColor(PWND pwndParent, PWND pwnd, HDC hdc, UINT CtlMsg)
Definition: misc.c:154
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
PCURICON_OBJECT FASTCALL NC_IconForWindow(PWND pWnd)
Definition: nonclient.c:705
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
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731
HANDLE FASTCALL UserGetProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
Definition: prop.c:46
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2105
#define USERTAG_WINDOWLIST
Definition: tags.h:298
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
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:274
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:176
BOOL FASTCALL IntIsChildWindow(PWND Parent, PWND BaseWindow)
Definition: window.c:927
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:92
#define IntWndBelongsToThread(WndObj, W32Thread)
Definition: window.h:32
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
UINT_PTR WPARAM
Definition: windef.h:207
DWORD COLORREF
Definition: windef.h:300
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
#define RGN_DIFF
Definition: wingdi.h:358
#define NULLREGION
Definition: wingdi.h:361
#define DI_NORMAL
Definition: wingdi.h:72
#define TRANSPARENT
Definition: wingdi.h:950
#define RGN_COPY
Definition: wingdi.h:357
#define RGN_AND
Definition: wingdi.h:356
#define SRCCOPY
Definition: wingdi.h:333
#define ETO_CLIPPED
Definition: wingdi.h:648
#define PATCOPY
Definition: wingdi.h:335
#define SIMPLEREGION
Definition: wingdi.h:362
#define RGN_OR
Definition: wingdi.h:359
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
FORCEINLINE BOOL IntEqualRect(RECTL *lprc1, RECTL *lprc2)
Definition: winpos.h:48
#define WM_PAINT
Definition: winuser.h:1620
#define WM_ERASEBKGND
Definition: winuser.h:1625
#define DT_NOPREFIX
Definition: winuser.h:537
#define COLOR_BTNTEXT
Definition: winuser.h:933
#define COLOR_INACTIVECAPTIONTEXT
Definition: winuser.h:934
#define DC_INBUTTON
Definition: winuser.h:431
#define COLOR_WINDOW
Definition: winuser.h:918
#define DCX_CACHE
Definition: winuser.h:2114
#define COLOR_GRADIENTINACTIVECAPTION
Definition: winuser.h:945
#define DCX_WINDOW
Definition: winuser.h:2113
#define DT_END_ELLIPSIS
Definition: winuser.h:529
#define WM_SYNCPAINT
Definition: winuser.h:1690
#define HWND_BROADCAST
Definition: winuser.h:1204
#define DT_SINGLELINE
Definition: winuser.h:540
#define WM_PALETTECHANGED
Definition: winuser.h:1877
#define COLOR_ACTIVECAPTION
Definition: winuser.h:915
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1217
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
#define SM_CYSMICON
Definition: winuser.h:1013
#define COLOR_INACTIVECAPTION
Definition: winuser.h:916
#define RDW_UPDATENOW
Definition: winuser.h:1220
#define RDW_ERASE
Definition: winuser.h:1211
#define RDW_NOCHILDREN
Definition: winuser.h:1222
#define COLOR_GRADIENTACTIVECAPTION
Definition: winuser.h:944
#define SM_CXSIZE
Definition: winuser.h:991
#define WM_CTLCOLORMSGBOX
Definition: winuser.h:1766
#define DC_NC
Definition: winuser.h:440
#define SM_CXSMICON
Definition: winuser.h:1012
#define DT_LEFT
Definition: winuser.h:534
#define DCX_INTERSECTRGN
Definition: winuser.h:2122
#define WM_NCACTIVATE
Definition: winuser.h:1688
#define RDW_ALLCHILDREN
Definition: winuser.h:1221
#define RDW_ERASENOW
Definition: winuser.h:1219
#define RDW_FRAME
Definition: winuser.h:1212
#define DC_TEXT
Definition: winuser.h:430
#define DT_VCENTER
Definition: winuser.h:543
_In_ int _Inout_ LPRECT lprc
Definition: winuser.h:4466
#define CS_OWNDC
Definition: winuser.h:655
#define DC_ICON
Definition: winuser.h:429
#define RDW_NOFRAME
Definition: winuser.h:1216
#define DC_SMALLCAP
Definition: winuser.h:428
#define CTLCOLOR_MAX
Definition: winuser.h:958
#define RDW_INTERNALPAINT
Definition: winuser.h:1213
#define RDW_NOERASE
Definition: winuser.h:1215
#define COLOR_CAPTIONTEXT
Definition: winuser.h:922
#define CS_PARENTDC
Definition: winuser.h:656
#define RDW_VALIDATE
Definition: winuser.h:1218
#define SM_CYCAPTION
Definition: winuser.h:963
#define RDW_INVALIDATE
Definition: winuser.h:1214
#define WM_NCPAINT
Definition: winuser.h:1687
#define COLOR_3DFACE
Definition: winuser.h:929
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_In_ BOOLEAN Remove
Definition: psfuncs.h:110
static HDC hdcSrc
Definition: xlate.c:32
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185