ReactOS 0.4.15-dev-8348-gc1b9bb5
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 /* Nothing to paint, just return */
702 if ((RgnType == NULLREGION && (Flags & RDW_INVALIDATE)) || RgnType == ERROR)
703 {
704 return;
705 }
706
707 /*
708 * Save current state of pending updates
709 */
710
711 HadPaintMessage = IntIsWindowDirty(Wnd);
712
713 /*
714 * Update the region and flags
715 */
716
717 // The following flags are used to invalidate the window.
719 {
721 {
723 }
724
725 if (Flags & RDW_INVALIDATE )
726 {
727 PREGION RgnUpdate;
728
729 Wnd->state &= ~WNDS_NONCPAINT;
730
731 /* If not the same thread set it dirty. */
732 if (Wnd->head.pti != PsGetCurrentThreadWin32Thread())
733 {
734 Wnd->state |= WNDS_UPDATEDIRTY;
735 if (Wnd->state2 & WNDS2_WMPAINTSENT)
737 }
738
739 if (Flags & RDW_FRAME)
740 Wnd->state |= WNDS_SENDNCPAINT;
741
742 if (Flags & RDW_ERASE)
744
745 if (RgnType != NULLREGION && Rgn > PRGN_WINDOW)
746 {
747 if (Wnd->hrgnUpdate == NULL)
748 {
749 Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
751 }
752
753 if (Wnd->hrgnUpdate != HRGN_WINDOW)
754 {
755 RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
756 if (RgnUpdate)
757 {
758 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_OR);
759 REGION_UnlockRgn(RgnUpdate);
760 if (RgnType == NULLREGION)
761 {
764 Wnd->hrgnUpdate = NULL;
765 }
766 }
767 }
768 }
769
770 Flags |= RDW_ERASE|RDW_FRAME; // For children.
771
772 }
773
774 if (!HadPaintMessage && IntIsWindowDirty(Wnd))
775 {
776 MsqIncPaintCountQueue(Wnd->head.pti);
777 }
778
779 } // The following flags are used to validate the window.
781 {
783 return;
784
786 {
787 Wnd->state &= ~WNDS_INTERNALPAINT;
788 }
789
790 if (Flags & RDW_VALIDATE)
791 {
792 if (Flags & RDW_NOFRAME)
793 Wnd->state &= ~WNDS_SENDNCPAINT;
794
795 if (Flags & RDW_NOERASE)
797
798 if (Wnd->hrgnUpdate > HRGN_WINDOW && RgnType != NULLREGION && Rgn > PRGN_WINDOW)
799 {
800 PREGION RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
801
802 if (RgnUpdate)
803 {
804 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_DIFF);
805 REGION_UnlockRgn(RgnUpdate);
806
807 if (RgnType == NULLREGION)
808 {
811 Wnd->hrgnUpdate = NULL;
812 }
813 }
814 }
815 // If update is null, do not erase.
816 if (Wnd->hrgnUpdate == NULL)
817 {
819 }
820 }
821
822 if (HadPaintMessage && !IntIsWindowDirty(Wnd))
823 {
824 MsqDecPaintCountQueue(Wnd->head.pti);
825 }
826 }
827
828 /*
829 * Process children if needed
830 */
831
832 if (!(Flags & RDW_NOCHILDREN) &&
833 !(Wnd->style & WS_MINIMIZE) &&
834 ((Flags & RDW_ALLCHILDREN) || !(Wnd->style & WS_CLIPCHILDREN)))
835 {
836 PWND Child;
837
838 for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
839 {
840 if (Child->style & WS_VISIBLE)
841 {
842 /*
843 * Recursive call to update children hrgnUpdate
844 */
845 PREGION RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
846 if (RgnTemp)
847 {
848 if (Rgn > PRGN_WINDOW) IntGdiCombineRgn(RgnTemp, Rgn, 0, RGN_COPY);
849 IntInvalidateWindows(Child, ((Rgn > PRGN_WINDOW)?RgnTemp:Rgn), Flags);
850 REGION_Delete(RgnTemp);
851 }
852 }
853 }
854 }
855 TRACE("IntInvalidateWindows exit\n");
856}
857
858/*
859 * IntIsWindowDrawable
860 *
861 * Remarks
862 * Window is drawable when it is visible and all parents are not
863 * minimized.
864 */
865
868{
869 PWND WndObject;
870
871 for (WndObject = Wnd; WndObject != NULL; WndObject = WndObject->spwndParent)
872 {
873 if ( WndObject->state2 & WNDS2_INDESTROY ||
874 WndObject->state & WNDS_DESTROYED ||
875 !WndObject ||
876 !(WndObject->style & WS_VISIBLE) ||
877 ((WndObject->style & WS_MINIMIZE) && (WndObject != Wnd)))
878 {
879 return FALSE;
880 }
881 }
882
883 return TRUE;
884}
885
886/*
887 * IntRedrawWindow
888 *
889 * Internal version of NtUserRedrawWindow that takes WND as
890 * first parameter.
891 */
892
895 PWND Window,
896 const RECTL* UpdateRect,
897 PREGION UpdateRgn,
898 ULONG Flags)
899{
900 PREGION TmpRgn = NULL;
901 TRACE("co_UserRedrawWindow start Rgn %p\n",UpdateRgn);
902
903 /*
904 * Step 1.
905 * Validation of passed parameters.
906 */
907
909 {
910 return TRUE; // Just do nothing!!!
911 }
912
913 if (Window == NULL)
914 {
916 }
917
918 /*
919 * Step 2.
920 * Transform the parameters UpdateRgn and UpdateRect into
921 * a region hRgn specified in screen coordinates.
922 */
923
924 if (Flags & (RDW_INVALIDATE | RDW_VALIDATE)) // Both are OKAY!
925 {
926 /* We can't hold lock on GDI objects while doing roundtrips to user mode,
927 * so use a copy instead */
928 if (UpdateRgn)
929 {
930 TmpRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
931
932 if (UpdateRgn > PRGN_WINDOW)
933 {
934 IntGdiCombineRgn(TmpRgn, UpdateRgn, NULL, RGN_COPY);
935 }
936
938 {
939 REGION_bOffsetRgn(TmpRgn, Window->rcClient.left, Window->rcClient.top);
940 }
941 }
942 else
943 {
944 if (UpdateRect != NULL)
945 {
947 {
949 }
950 else
951 {
952 TmpRgn = IntSysCreateRectpRgn(Window->rcClient.left + UpdateRect->left,
953 Window->rcClient.top + UpdateRect->top,
954 Window->rcClient.left + UpdateRect->right,
955 Window->rcClient.top + UpdateRect->bottom);
956 }
957 }
958 else
959 {
962 {
963 if (!RECTL_bIsEmptyRect(&Window->rcWindow))
964 TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
965 }
966 else
967 {
968 if (!RECTL_bIsEmptyRect(&Window->rcClient))
969 TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcClient);
970 }
971 }
972 }
973 }
974
975 /* Fixes test RDW_INTERNALPAINT behavior */
976 if (TmpRgn == NULL)
977 {
978 TmpRgn = PRGN_WINDOW; // Need a region so the bits can be set!!!
979 }
980
981 /*
982 * Step 3.
983 * Adjust the window update region depending on hRgn and flags.
984 */
985
987 TmpRgn != NULL)
988 {
990 }
991
992 /*
993 * Step 4.
994 * Repaint and erase windows if needed.
995 */
996
997 if (Flags & RDW_UPDATENOW)
998 {
1000 }
1001 else if (Flags & RDW_ERASENOW)
1002 {
1003 if ((Flags & (RDW_NOCHILDREN|RDW_ALLCHILDREN)) == 0)
1005
1007 }
1008
1009 /*
1010 * Step 5.
1011 * Cleanup ;-)
1012 */
1013
1014 if (TmpRgn > PRGN_WINDOW)
1015 {
1016 REGION_Delete(TmpRgn);
1017 }
1018 TRACE("co_UserRedrawWindow exit\n");
1019
1020 return TRUE;
1021}
1022
1024PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
1025{
1026 if (pwnd->hrgnUpdate)
1027 {
1028 HDC hDC;
1030 HRGN hrgnTemp;
1031 RECT Rect;
1032 INT type;
1033 PREGION prgn;
1034
1035 if (pwnd->hrgnUpdate > HRGN_WINDOW)
1036 {
1037 hrgnTemp = NtGdiCreateRectRgn(0, 0, 0, 0);
1038 type = NtGdiCombineRgn( hrgnTemp, pwnd->hrgnUpdate, 0, RGN_COPY);
1039 if (type == ERROR)
1040 {
1041 GreDeleteObject(hrgnTemp);
1042 hrgnTemp = HRGN_WINDOW;
1043 }
1044 }
1045 else
1046 {
1047 hrgnTemp = GreCreateRectRgnIndirect(&pwnd->rcWindow);
1048 }
1049
1050 if ( hrgnOrig &&
1051 hrgnTemp > HRGN_WINDOW &&
1052 NtGdiCombineRgn(hrgnTemp, hrgnTemp, hrgnOrig, RGN_AND) == NULLREGION)
1053 {
1054 GreDeleteObject(hrgnTemp);
1055 return;
1056 }
1057
1059
1060 Rect = pwnd->rcWindow;
1061 RECTL_vOffsetRect(&Rect, -pwnd->rcWindow.left, -pwnd->rcWindow.top);
1062
1063 // Clear out client area!
1065
1066 NC_DoNCPaint(pwnd, hDC, Flags); // Redraw without MENUs.
1067
1068 UserReleaseDC(pwnd, hDC, FALSE);
1069
1070 prgn = REGION_LockRgn(hrgnTemp);
1072 REGION_UnlockRgn(prgn);
1073
1074 // Set updates for this window.
1076
1077 // DCX_KEEPCLIPRGN is set. Check it anyway.
1078 if (hrgnTemp > HRGN_WINDOW && GreIsHandleValid(hrgnTemp)) GreDeleteObject(hrgnTemp);
1079 }
1080}
1081
1084{
1085 PaintSuspendedWindow( pWnd, hRgn );
1086
1087 if (!(pWnd->style & WS_CLIPCHILDREN))
1088 return;
1089
1090 pWnd = pWnd->spwndChild; // invalidate children if any.
1091 while (pWnd)
1092 {
1093 UpdateTheadChildren( pWnd, hRgn );
1094 pWnd = pWnd->spwndNext;
1095 }
1096}
1097
1100{
1101 PWND pwndTemp;
1102
1103 for ( pwndTemp = pWnd;
1104 pwndTemp;
1105 pwndTemp = pwndTemp->spwndNext )
1106 {
1107 if (pwndTemp->head.pti == pti)
1108 {
1110 }
1111 else
1112 {
1113 if (IsThreadSuspended(pwndTemp->head.pti) || MsqIsHung(pwndTemp->head.pti, MSQ_HUNG))
1114 {
1115 UpdateTheadChildren(pwndTemp, hRgn);
1116 }
1117 else
1119 }
1120 }
1121}
1122
1125{
1126 return ( Wnd->style & WS_VISIBLE &&
1127 ( Wnd->hrgnUpdate != NULL ||
1128 Wnd->state & WNDS_INTERNALPAINT ) );
1129}
1130
1131/*
1132 Conditions to paint any window:
1133
1134 1. Update region is not null.
1135 2. Internal paint flag is set.
1136 3. Paint count is not zero.
1137
1138 */
1141{
1142 PWND hChild;
1143 PWND TempWindow;
1144
1145 for (; Window != NULL; Window = Window->spwndNext)
1146 {
1148 {
1150 {
1151 /* Make sure all non-transparent siblings are already drawn. */
1152 if (Window->ExStyle & WS_EX_TRANSPARENT)
1153 {
1154 for (TempWindow = Window->spwndNext; TempWindow != NULL;
1155 TempWindow = TempWindow->spwndNext)
1156 {
1157 if (!(TempWindow->ExStyle & WS_EX_TRANSPARENT) &&
1158 IntWndBelongsToThread(TempWindow, Thread) &&
1159 IntIsWindowDirty(TempWindow))
1160 {
1161 return TempWindow;
1162 }
1163 }
1164 }
1165 return Window;
1166 }
1167 }
1168 /* find a child of the specified window that needs repainting */
1169 if (Window->spwndChild)
1170 {
1172 if (hChild != NULL)
1173 return hChild;
1174 }
1175 }
1176 return Window;
1177}
1178
1179//
1180// Internal painting of windows.
1181//
1184{
1185 // Handle normal painting.
1187}
1188
1191 PWND Window,
1192 UINT MsgFilterMin,
1193 UINT MsgFilterMax,
1195 MSG *Message,
1196 BOOL Remove)
1197{
1198 PWND PaintWnd, StartWnd;
1199
1200 if ((MsgFilterMin != 0 || MsgFilterMax != 0) &&
1201 (MsgFilterMin > WM_PAINT || MsgFilterMax < WM_PAINT))
1202 return FALSE;
1203
1204 if (Thread->TIF_flags & TIF_SYSTEMTHREAD )
1205 {
1206 ERR("WM_PAINT is in a System Thread!\n");
1207 }
1208
1209 StartWnd = UserGetDesktopWindow();
1210 PaintWnd = IntFindWindowToRepaint(StartWnd, Thread);
1211
1212 Message->hwnd = PaintWnd ? UserHMGetHandle(PaintWnd) : NULL;
1213
1214 if (Message->hwnd == NULL && Thread->cPaintsReady)
1215 {
1216 // Find note in window.c:"PAINTING BUG".
1217 ERR("WARNING SOMETHING HAS GONE WRONG: Thread marked as containing dirty windows, but no dirty windows found! Counts %u\n",Thread->cPaintsReady);
1218 /* Hack to stop spamming the debug log ! */
1219 Thread->cPaintsReady = 0;
1220 return FALSE;
1221 }
1222
1223 if (Message->hwnd == NULL)
1224 return FALSE;
1225
1226 if (!(Window == NULL ||
1227 PaintWnd == Window ||
1228 IntIsChildWindow(Window, PaintWnd))) /* check that it is a child of the specified parent */
1229 return FALSE;
1230
1231 if (PaintWnd->state & WNDS_INTERNALPAINT)
1232 {
1233 PaintWnd->state &= ~WNDS_INTERNALPAINT;
1234 if (!PaintWnd->hrgnUpdate)
1236 }
1237 PaintWnd->state2 &= ~WNDS2_STARTPAINT;
1238 PaintWnd->state &= ~WNDS_UPDATEDIRTY;
1239
1240 Window = PaintWnd;
1241 while (Window && !UserIsDesktopWindow(Window))
1242 {
1243 // Role back and check for clip children, do not set if any.
1244 if (Window->spwndParent && !(Window->spwndParent->style & WS_CLIPCHILDREN))
1245 {
1246 PaintWnd->state2 |= WNDS2_WMPAINTSENT;
1247 }
1248 Window = Window->spwndParent;
1249 }
1250
1251 Message->wParam = Message->lParam = 0;
1252 Message->message = WM_PAINT;
1253 return TRUE;
1254}
1255
1256BOOL
1259 PWND pwnd,
1260 HDC hdcBlt,
1261 UINT nFlags)
1262{
1263 HDC hdcSrc;
1264 INT cx, cy, xSrc, ySrc;
1265
1266 if ( nFlags & PW_CLIENTONLY)
1267 {
1268 cx = pwnd->rcClient.right - pwnd->rcClient.left;
1269 cy = pwnd->rcClient.bottom - pwnd->rcClient.top;
1270 xSrc = pwnd->rcClient.left - pwnd->rcWindow.left;
1271 ySrc = pwnd->rcClient.top - pwnd->rcWindow.top;
1272 }
1273 else
1274 {
1275 cx = pwnd->rcWindow.right - pwnd->rcWindow.left;
1276 cy = pwnd->rcWindow.bottom - pwnd->rcWindow.top;
1277 xSrc = 0;
1278 ySrc = 0;
1279 }
1280
1281 // TODO: Setup Redirection for Print.
1282 return FALSE;
1283
1284 /* Update the window just incase. */
1286
1288 /* Print window to printer context. */
1289 NtGdiBitBlt( hdcBlt,
1290 0,
1291 0,
1292 cx,
1293 cy,
1294 hdcSrc,
1295 xSrc,
1296 ySrc,
1297 SRCCOPY,
1298 0,
1299 0);
1300
1301 UserReleaseDC( pwnd, hdcSrc, FALSE);
1302
1303 // TODO: Release Redirection from Print.
1304
1305 return TRUE;
1306}
1307
1308BOOL
1310IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
1311{
1312 DWORD_PTR FlashState;
1313 UINT uCount = pfwi->uCount;
1314 BOOL Activate = FALSE, Ret = FALSE;
1315
1316 ASSERT(pfwi);
1317
1318 FlashState = (DWORD_PTR)UserGetProp(pWnd, AtomFlashWndState, TRUE);
1319
1320 if (FlashState == FLASHW_FINISHED)
1321 {
1322 // Cycle has finished, kill timer and set this to Stop.
1323 FlashState |= FLASHW_KILLSYSTIMER;
1324 pfwi->dwFlags = FLASHW_STOP;
1325 }
1326 else
1327 {
1328 if (FlashState)
1329 {
1330 if (pfwi->dwFlags == FLASHW_SYSTIMER)
1331 {
1332 // Called from system timer, restore flags, counts and state.
1333 pfwi->dwFlags = LOWORD(FlashState);
1334 uCount = HIWORD(FlashState);
1335 FlashState = MAKELONG(LOWORD(FlashState),0);
1336 }
1337 else
1338 {
1339 // Clean out the trash! Fix SeaMonkey crash after restart.
1340 FlashState = 0;
1341 }
1342 }
1343
1344 if (FlashState == 0)
1345 { // First time in cycle, setup flash state.
1346 if ( pWnd->state & WNDS_ACTIVEFRAME ||
1347 (pfwi->dwFlags & FLASHW_CAPTION && pWnd->style & (WS_BORDER|WS_DLGFRAME)))
1348 {
1349 FlashState = FLASHW_STARTED|FLASHW_ACTIVE;
1350 }
1351 }
1352
1353 // Set previous window state.
1354 Ret = !!(FlashState & FLASHW_ACTIVE);
1355
1356 if ( (pfwi->dwFlags & FLASHW_TIMERNOFG) == FLASHW_TIMERNOFG &&
1357 gpqForeground == pWnd->head.pti->MessageQueue )
1358 {
1359 // Flashing until foreground, set this to Stop.
1360 pfwi->dwFlags = FLASHW_STOP;
1361 }
1362 }
1363
1364 // Toggle activate flag.
1365 if ( pfwi->dwFlags == FLASHW_STOP )
1366 {
1367 if (gpqForeground && gpqForeground->spwndActive == pWnd)
1368 Activate = TRUE;
1369 else
1370 Activate = FALSE;
1371 }
1372 else
1373 {
1374 Activate = (FlashState & FLASHW_ACTIVE) == 0;
1375 }
1376
1377 if ( pfwi->dwFlags == FLASHW_STOP || pfwi->dwFlags & FLASHW_CAPTION )
1378 {
1379 co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCACTIVATE, Activate, 0);
1380 }
1381
1382 // FIXME: Check for a Stop Sign here.
1383 if ( pfwi->dwFlags & FLASHW_TRAY )
1384 {
1385 // Need some shell work here too.
1386 TRACE("FIXME: Flash window no Tray support!\n");
1387 }
1388
1389 if ( pfwi->dwFlags == FLASHW_STOP )
1390 {
1391 if (FlashState & FLASHW_KILLSYSTIMER)
1392 {
1394 }
1395
1397 }
1398 else
1399 { // Have a count and started, set timer.
1400 if ( uCount )
1401 {
1402 FlashState |= FLASHW_COUNT;
1403
1404 if (!(Activate ^ !!(FlashState & FLASHW_STARTED)))
1405 uCount--;
1406
1407 if (!(FlashState & FLASHW_KILLSYSTIMER))
1408 pfwi->dwFlags |= FLASHW_TIMER;
1409 }
1410
1411 if (pfwi->dwFlags & FLASHW_TIMER)
1412 {
1413 FlashState |= FLASHW_KILLSYSTIMER;
1414
1415 IntSetTimer( pWnd,
1417 pfwi->dwTimeout ? pfwi->dwTimeout : gpsi->dtCaretBlink,
1419 TMRF_SYSTEM );
1420 }
1421
1422 if (FlashState & FLASHW_COUNT && uCount == 0)
1423 {
1424 // Keep spinning? Nothing else to do.
1425 FlashState = FLASHW_FINISHED;
1426 }
1427 else
1428 {
1429 // Save state and flags so this can be restored next time through.
1430 FlashState ^= (FlashState ^ -!!(Activate)) & FLASHW_ACTIVE;
1431 FlashState ^= (FlashState ^ pfwi->dwFlags) & (FLASHW_MASK & ~FLASHW_TIMER);
1432 }
1433 FlashState = MAKELONG(LOWORD(FlashState),uCount);
1434 UserSetProp(pWnd, AtomFlashWndState, (HANDLE)FlashState, TRUE);
1435 }
1436 return Ret;
1437}
1438
1439// Win: xxxBeginPaint
1442{
1443 RECT Rect;
1444 INT type;
1445 BOOL Erase = FALSE;
1446
1448
1449 Window->state2 |= WNDS2_STARTPAINT;
1450 Window->state &= ~WNDS_PAINTNOTPROCESSED;
1451
1452 if (Window->state & WNDS_SENDNCPAINT)
1453 {
1454 HRGN hRgn;
1455 // Application can keep update dirty.
1456 do
1457 {
1458 Window->state &= ~WNDS_UPDATEDIRTY;
1462 {
1463 /* NOTE: The region can already be deleted! */
1465 }
1466 }
1467 while(Window->state & WNDS_UPDATEDIRTY);
1468 }
1469 else
1470 {
1471 Window->state &= ~WNDS_UPDATEDIRTY;
1472 }
1473
1474 RtlZeroMemory(Ps, sizeof(PAINTSTRUCT));
1475
1476 if (Window->state2 & WNDS2_ENDPAINTINVALIDATE)
1477 {
1478 ERR("BP: Another thread invalidated this window\n");
1479 }
1480
1481 Ps->hdc = UserGetDCEx( Window,
1482 Window->hrgnUpdate,
1484 if (!Ps->hdc)
1485 {
1486 return NULL;
1487 }
1488
1489 // If set, always clear flags out due to the conditions later on for sending the message.
1490 if (Window->state & WNDS_SENDERASEBACKGROUND)
1491 {
1493 Erase = TRUE;
1494 }
1495
1496 if (Window->hrgnUpdate != NULL)
1497 {
1498 MsqDecPaintCountQueue(Window->head.pti);
1500 /* The region is part of the dc now and belongs to the process! */
1501 Window->hrgnUpdate = NULL;
1502 }
1503 else
1504 {
1505 if (Window->state & WNDS_INTERNALPAINT)
1506 MsqDecPaintCountQueue(Window->head.pti);
1507 }
1508
1509 type = GdiGetClipBox(Ps->hdc, &Ps->rcPaint);
1510
1512
1513 Window->state &= ~WNDS_INTERNALPAINT;
1514
1515 if ( Erase && // Set to erase,
1516 type != NULLREGION && // don't erase if the clip box is empty,
1517 (!(Window->pcls->style & CS_PARENTDC) || // not parent dc or
1518 RECTL_bIntersectRect( &Rect, &Rect, &Ps->rcPaint) ) ) // intersecting.
1519 {
1521 if ( Ps->fErase )
1522 {
1524 }
1525 }
1526 else
1527 {
1528 Ps->fErase = FALSE;
1529 }
1530
1532
1533 return Ps->hdc;
1534}
1535
1536// Win: xxxEndPaint
1539{
1540 HDC hdc = NULL;
1541
1542 hdc = Ps->hdc;
1543
1544 UserReleaseDC(Wnd, hdc, TRUE);
1545
1547 {
1548 ERR("EP: Another thread invalidated this window\n");
1549 Wnd->state2 &= ~WNDS2_ENDPAINTINVALIDATE;
1550 }
1551
1553
1554 co_UserShowCaret(Wnd);
1555
1556 return TRUE;
1557}
1558
1559// Win: xxxFillWindow
1562 PWND pWnd,
1563 HDC hDC,
1564 HBRUSH hBrush)
1565{
1566 RECT Rect, Rect1;
1567 INT type;
1568
1569 if (!pWndParent)
1570 pWndParent = pWnd;
1571
1572 type = GdiGetClipBox(hDC, &Rect);
1573
1574 IntGetClientRect(pWnd, &Rect1);
1575
1576 if ( type != NULLREGION && // Clip box is not empty,
1577 (!(pWnd->pcls->style & CS_PARENTDC) || // not parent dc or
1578 RECTL_bIntersectRect( &Rect, &Rect, &Rect1) ) ) // intersecting.
1579 {
1580 POINT ppt;
1581 INT x = 0, y = 0;
1582
1583 if (!UserIsDesktopWindow(pWndParent))
1584 {
1585 x = pWndParent->rcClient.left - pWnd->rcClient.left;
1586 y = pWndParent->rcClient.top - pWnd->rcClient.top;
1587 }
1588
1589 GreSetBrushOrg(hDC, x, y, &ppt);
1590
1591 if ( hBrush < (HBRUSH)CTLCOLOR_MAX )
1592 hBrush = GetControlColor( pWndParent, pWnd, hDC, HandleToUlong(hBrush) + WM_CTLCOLORMSGBOX);
1593
1594 FillRect(hDC, &Rect, hBrush);
1595
1596 GreSetBrushOrg(hDC, ppt.x, ppt.y, NULL);
1597
1598 return TRUE;
1599 }
1600 else
1601 return FALSE;
1602}
1603
1604/* PUBLIC FUNCTIONS ***********************************************************/
1605
1606/*
1607 * NtUserBeginPaint
1608 *
1609 * Status
1610 * @implemented
1611 */
1612
1615{
1616 PWND Window;
1617 PAINTSTRUCT Ps;
1619 HDC hDC;
1621 HDC Ret = NULL;
1622
1623 TRACE("Enter NtUserBeginPaint\n");
1625
1627 {
1628 goto Cleanup; // Return NULL
1629 }
1630
1631 UserRefObjectCo(Window, &Ref);
1632
1633 hDC = IntBeginPaint(Window, &Ps);
1634
1635 Status = MmCopyToCaller(UnsafePs, &Ps, sizeof(PAINTSTRUCT));
1636 if (! NT_SUCCESS(Status))
1637 {
1639 goto Cleanup; // Return NULL
1640 }
1641
1642 Ret = hDC;
1643
1644Cleanup:
1646
1647 TRACE("Leave NtUserBeginPaint, ret=%p\n", Ret);
1648 UserLeave();
1649 return Ret;
1650}
1651
1652/*
1653 * NtUserEndPaint
1654 *
1655 * Status
1656 * @implemented
1657 */
1658
1661{
1663 PWND Window;
1664 PAINTSTRUCT Ps;
1666 BOOL Ret = FALSE;
1667
1668 TRACE("Enter NtUserEndPaint\n");
1670
1672 {
1673 goto Cleanup; // Return FALSE
1674 }
1675
1676 UserRefObjectCo(Window, &Ref); // Here for the exception.
1677
1678 _SEH2_TRY
1679 {
1680 ProbeForRead(pUnsafePs, sizeof(*pUnsafePs), 1);
1681 RtlCopyMemory(&Ps, pUnsafePs, sizeof(PAINTSTRUCT));
1682 }
1684 {
1686 }
1687 _SEH2_END
1688 if (!NT_SUCCESS(Status))
1689 {
1690 goto Cleanup; // Return FALSE
1691 }
1692
1693 Ret = IntEndPaint(Window, &Ps);
1694
1695Cleanup:
1697
1698 TRACE("Leave NtUserEndPaint, ret=%i\n", Ret);
1699 UserLeave();
1700 return Ret;
1701}
1702
1703/*
1704 * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
1705 */
1706/*
1707 * @implemented
1708 */
1711 HWND hWnd,
1712 HDC hDC,
1713 HBRUSH hBrush)
1714{
1715 BOOL ret = FALSE;
1716 PWND pWnd, pWndParent = NULL;
1718
1719 TRACE("Enter NtUserFillWindow\n");
1721
1722 if (!hDC)
1723 {
1724 goto Exit;
1725 }
1726
1727 if (!(pWnd = UserGetWindowObject(hWnd)))
1728 {
1729 goto Exit;
1730 }
1731
1732 if (hWndParent && !(pWndParent = UserGetWindowObject(hWndParent)))
1733 {
1734 goto Exit;
1735 }
1736
1737 UserRefObjectCo(pWnd, &Ref);
1738 ret = IntFillWindow( pWndParent, pWnd, hDC, hBrush );
1739 UserDerefObjectCo(pWnd);
1740
1741Exit:
1742 TRACE("Leave NtUserFillWindow, ret=%i\n",ret);
1743 UserLeave();
1744 return ret;
1745}
1746
1747/*
1748 * @implemented
1749 */
1751NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
1752{
1753 PWND pWnd;
1754 FLASHWINFO finfo = {0};
1755 BOOL Ret = FALSE;
1756
1758
1759 _SEH2_TRY
1760 {
1761 ProbeForRead(pfwi, sizeof(FLASHWINFO), 1);
1762 RtlCopyMemory(&finfo, pfwi, sizeof(FLASHWINFO));
1763 }
1765 {
1767 _SEH2_YIELD(goto Exit);
1768 }
1769 _SEH2_END
1770
1771 if (!( pWnd = ValidateHwndNoErr(finfo.hwnd)) ||
1772 finfo.cbSize != sizeof(FLASHWINFO) ||
1773 finfo.dwFlags & ~(FLASHW_ALL|FLASHW_TIMER|FLASHW_TIMERNOFG) )
1774 {
1776 goto Exit;
1777 }
1778
1779 Ret = IntFlashWindowEx(pWnd, &finfo);
1780
1781Exit:
1782 UserLeave();
1783 return Ret;
1784}
1785
1786/*
1787 GetUpdateRgn, this fails the same as the old one.
1788 */
1791{
1792 int RegionType;
1793 BOOL Type;
1794 RECTL Rect;
1795
1797
1798 if (bErase)
1799 {
1801 UserRefObjectCo(Window, &Ref);
1804 }
1805
1806 Window->state &= ~WNDS_UPDATEDIRTY;
1807
1808 if (Window->hrgnUpdate == NULL)
1809 {
1810 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1811 return NULLREGION;
1812 }
1813
1814 Rect = Window->rcClient;
1816
1817 if (Window->hrgnUpdate == HRGN_WINDOW)
1818 {
1819 // Trap it out.
1820 ERR("GURn: Caller is passing Window Region 1\n");
1821 if (!Type)
1822 {
1823 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1824 return NULLREGION;
1825 }
1826
1828
1830 {
1832 -Window->rcClient.left,
1833 -Window->rcClient.top);
1834 }
1836 }
1837 else
1838 {
1839 HRGN hrgnTemp = GreCreateRectRgnIndirect(&Rect);
1840
1841 RegionType = NtGdiCombineRgn(hRgn, hrgnTemp, Window->hrgnUpdate, RGN_AND);
1842
1844 {
1845 if (hrgnTemp) GreDeleteObject(hrgnTemp);
1846 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1847 return RegionType;
1848 }
1849
1851 {
1853 -Window->rcClient.left,
1854 -Window->rcClient.top);
1855 }
1856 if (hrgnTemp) GreDeleteObject(hrgnTemp);
1857 }
1858 return RegionType;
1859}
1860
1863{
1865 BOOL Ret = TRUE;
1866
1867 if (bErase)
1868 {
1870 UserRefObjectCo(Window, &Ref);
1873 }
1874
1875 Window->state &= ~WNDS_UPDATEDIRTY;
1876
1877 if (Window->hrgnUpdate == NULL)
1878 {
1879 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1880 Ret = FALSE;
1881 }
1882 else
1883 {
1884 /* Get the update region bounding box. */
1885 if (Window->hrgnUpdate == HRGN_WINDOW)
1886 {
1887 *pRect = Window->rcClient;
1888 ERR("GURt: Caller is retrieving Window Region 1\n");
1889 }
1890 else
1891 {
1892 RegionType = IntGdiGetRgnBox(Window->hrgnUpdate, pRect);
1893
1895 RECTL_bIntersectRect(pRect, pRect, &Window->rcClient);
1896 }
1897
1898 if (IntIntersectWithParents(Window, pRect))
1899 {
1901 {
1902 RECTL_vOffsetRect(pRect,
1903 -Window->rcClient.left,
1904 -Window->rcClient.top);
1905 }
1906 if (Window->pcls->style & CS_OWNDC)
1907 {
1908 HDC hdc;
1909 //DWORD layout;
1911 //layout = NtGdiSetLayout(hdc, -1, 0);
1912 //IntMapWindowPoints( 0, Window, (LPPOINT)pRect, 2 );
1913 GreDPtoLP( hdc, (LPPOINT)pRect, 2 );
1914 //NtGdiSetLayout(hdc, -1, layout);
1916 }
1917 }
1918 else
1919 {
1920 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1921 }
1922 }
1923 return Ret;
1924}
1925
1926/*
1927 * NtUserGetUpdateRgn
1928 *
1929 * Status
1930 * @implemented
1931 */
1932
1935{
1936 PWND Window;
1937 INT ret = ERROR;
1938
1939 TRACE("Enter NtUserGetUpdateRgn\n");
1941
1943 if (Window)
1944 {
1945 ret = co_UserGetUpdateRgn(Window, hRgn, bErase);
1946 }
1947
1948 TRACE("Leave NtUserGetUpdateRgn, ret=%i\n", ret);
1949 UserLeave();
1950 return ret;
1951}
1952
1953/*
1954 * NtUserGetUpdateRect
1955 *
1956 * Status
1957 * @implemented
1958 */
1959
1962{
1963 PWND Window;
1964 RECTL Rect;
1966 BOOL Ret = FALSE;
1967
1968 TRACE("Enter NtUserGetUpdateRect\n");
1970
1972 {
1973 goto Exit; // Return FALSE
1974 }
1975
1976 Ret = co_UserGetUpdateRect(Window, &Rect, bErase);
1977
1978 if (UnsafeRect != NULL)
1979 {
1980 Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECTL));
1981 if (!NT_SUCCESS(Status))
1982 {
1984 Ret = FALSE;
1985 }
1986 }
1987
1988Exit:
1989 TRACE("Leave NtUserGetUpdateRect, ret=%i\n", Ret);
1990 UserLeave();
1991 return Ret;
1992}
1993
1994/*
1995 * NtUserRedrawWindow
1996 *
1997 * Status
1998 * @implemented
1999 */
2000
2003 HWND hWnd,
2004 CONST RECT *lprcUpdate,
2005 HRGN hrgnUpdate,
2006 UINT flags)
2007{
2008 RECTL SafeUpdateRect;
2009 PWND Wnd;
2010 BOOL Ret = FALSE;
2013 PREGION RgnUpdate = NULL;
2014
2015 TRACE("Enter NtUserRedrawWindow\n");
2017
2019 {
2020 goto Exit; // Return FALSE
2021 }
2022
2023 if (lprcUpdate)
2024 {
2025 _SEH2_TRY
2026 {
2027 ProbeForRead(lprcUpdate, sizeof(RECTL), 1);
2028 RtlCopyMemory(&SafeUpdateRect, lprcUpdate, sizeof(RECTL));
2029 }
2031 {
2033 }
2034 _SEH2_END
2035 if (!NT_SUCCESS(Status))
2036 {
2038 goto Exit; // Return FALSE
2039 }
2040 }
2041
2045 {
2046 /* RedrawWindow fails only in case that flags are invalid */
2048 goto Exit; // Return FALSE
2049 }
2050
2051 /* We can't hold lock on GDI objects while doing roundtrips to user mode,
2052 * so it will be copied.
2053 */
2054 if (hrgnUpdate > HRGN_WINDOW)
2055 {
2056 RgnUpdate = REGION_LockRgn(hrgnUpdate);
2057 if (!RgnUpdate)
2058 {
2060 goto Exit; // Return FALSE
2061 }
2062 REGION_UnlockRgn(RgnUpdate);
2063 }
2064 else if (hrgnUpdate == HRGN_WINDOW) // Trap it out.
2065 {
2066 ERR("NTRW: Caller is passing Window Region 1\n");
2067 }
2068
2069 UserRefObjectCo(Wnd, &Ref);
2070
2071 Ret = co_UserRedrawWindow( Wnd,
2072 lprcUpdate ? &SafeUpdateRect : NULL,
2073 RgnUpdate,
2074 flags);
2075
2076 UserDerefObjectCo(Wnd);
2077
2078Exit:
2079 TRACE("Leave NtUserRedrawWindow, ret=%i\n", Ret);
2080 UserLeave();
2081 return Ret;
2082}
2083
2084BOOL
2086 PWND pWnd,
2087 HDC hDc,
2088 const PUNICODE_STRING Text,
2089 const RECTL *lpRc,
2090 UINT uFlags,
2091 HFONT hFont)
2092{
2093 HFONT hOldFont = NULL;
2094 COLORREF OldTextColor;
2095 NONCLIENTMETRICSW nclm;
2097 BOOLEAN bDeleteFont = FALSE;
2098 SIZE Size;
2099 BOOL Ret = TRUE;
2100 ULONG fit = 0, Length;
2101 RECTL r = *lpRc;
2102
2103 TRACE("UserDrawCaptionText: %wZ\n", Text);
2104
2105 nclm.cbSize = sizeof(nclm);
2106 if (!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0))
2107 {
2108 ERR("UserSystemParametersInfo() failed!\n");
2109 return FALSE;
2110 }
2111
2112 if (!hFont)
2113 {
2114 if(uFlags & DC_SMALLCAP)
2115 Status = TextIntCreateFontIndirect(&nclm.lfSmCaptionFont, &hFont);
2116 else
2117 Status = TextIntCreateFontIndirect(&nclm.lfCaptionFont, &hFont);
2118
2119 if(!NT_SUCCESS(Status))
2120 {
2121 ERR("TextIntCreateFontIndirect() failed! Status: 0x%x\n", Status);
2122 return FALSE;
2123 }
2124
2125 bDeleteFont = TRUE;
2126 }
2127
2129
2130 hOldFont = NtGdiSelectFont(hDc, hFont);
2131
2132 if(uFlags & DC_INBUTTON)
2133 OldTextColor = IntGdiSetTextColor(hDc, IntGetSysColor(COLOR_BTNTEXT));
2134 else
2135 OldTextColor = IntGdiSetTextColor(hDc,
2137
2138 // Adjust for system menu.
2139 if (pWnd && pWnd->style & WS_SYSMENU)
2140 {
2141 r.right -= UserGetSystemMetrics(SM_CYCAPTION) - 1;
2142 if ((pWnd->style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW))
2143 {
2144 r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2145 r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2146 }
2147 }
2148
2149 GreGetTextExtentExW(hDc, Text->Buffer, Text->Length/sizeof(WCHAR), r.right - r.left, &fit, 0, &Size, 0);
2150
2151 Length = (Text->Length/sizeof(WCHAR) == fit ? fit : fit+1);
2152
2153 if (Text->Length/sizeof(WCHAR) > Length)
2154 {
2155 Ret = FALSE;
2156 }
2157
2158 if (Ret)
2159 { // Faster while in setup.
2160 UserExtTextOutW( hDc,
2161 lpRc->left,
2162 lpRc->top + (lpRc->bottom - lpRc->top - Size.cy) / 2, // DT_SINGLELINE && DT_VCENTER
2164 (RECTL *)lpRc,
2165 Text->Buffer,
2166 Length);
2167 }
2168 else
2169 {
2170 DrawTextW( hDc,
2171 Text->Buffer,
2172 Text->Length/sizeof(WCHAR),
2173 (RECTL *)&r,
2175 }
2176
2177 IntGdiSetTextColor(hDc, OldTextColor);
2178
2179 if (hOldFont)
2180 NtGdiSelectFont(hDc, hOldFont);
2181
2182 if (bDeleteFont)
2184
2185 return Ret;
2186}
2187
2188//
2189// This draws Buttons, Icons and Text...
2190//
2192 PWND pWnd,
2193 HDC hDc,
2194 RECTL *lpRc,
2195 HFONT hFont,
2196 HICON hIcon,
2197 const PUNICODE_STRING Str,
2198 UINT uFlags)
2199{
2200 BOOL Ret = FALSE;
2201 HBRUSH hBgBrush, hOldBrush = NULL;
2202 RECTL Rect = *lpRc;
2203 BOOL HasIcon;
2204
2206
2207 /* Determine whether the icon needs to be displayed */
2208 if (!hIcon && pWnd != NULL)
2209 {
2210 HasIcon = (uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP) &&
2211 (pWnd->style & WS_SYSMENU) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW);
2212 }
2213 else
2214 HasIcon = (hIcon != NULL);
2215
2216 // Draw the caption background
2217 if((uFlags & DC_GRADIENT) && !(uFlags & DC_INBUTTON))
2218 {
2219 static GRADIENT_RECT gcap = {0, 1};
2220 TRIVERTEX Vertices[2];
2221 COLORREF Colors[2];
2222
2225
2228
2229 Vertices[0].x = Rect.left;
2230 Vertices[0].y = Rect.top;
2231 Vertices[0].Red = (WORD)Colors[0]<<8;
2232 Vertices[0].Green = (WORD)Colors[0] & 0xFF00;
2233 Vertices[0].Blue = (WORD)(Colors[0]>>8) & 0xFF00;
2234 Vertices[0].Alpha = 0;
2235
2236 Vertices[1].x = Rect.right;
2237 Vertices[1].y = Rect.bottom;
2238 Vertices[1].Red = (WORD)Colors[1]<<8;
2239 Vertices[1].Green = (WORD)Colors[1] & 0xFF00;
2240 Vertices[1].Blue = (WORD)(Colors[1]>>8) & 0xFF00;
2241 Vertices[1].Alpha = 0;
2242
2243 if(!GreGradientFill(hDc, Vertices, 2, &gcap, 1, GRADIENT_FILL_RECT_H))
2244 {
2245 ERR("GreGradientFill() failed!\n");
2246 goto cleanup;
2247 }
2248 }
2249 else
2250 {
2251 if(uFlags & DC_INBUTTON)
2253 else if(uFlags & DC_ACTIVE)
2255 else
2257
2258 hOldBrush = NtGdiSelectBrush(hDc, hBgBrush);
2259
2260 if(!hOldBrush)
2261 {
2262 ERR("NtGdiSelectBrush() failed!\n");
2263 goto cleanup;
2264 }
2265
2266 if(!NtGdiPatBlt(hDc, Rect.left, Rect.top,
2267 Rect.right - Rect.left,
2268 Rect.bottom - Rect.top,
2269 PATCOPY))
2270 {
2271 ERR("NtGdiPatBlt() failed!\n");
2272 goto cleanup;
2273 }
2274 }
2275
2276 /* Draw icon */
2277 if (HasIcon)
2278 {
2279 PCURICON_OBJECT pIcon = NULL;
2280
2281 if (hIcon)
2282 {
2283 pIcon = UserGetCurIconObject(hIcon);
2284 }
2285 else if (pWnd)
2286 {
2287 pIcon = NC_IconForWindow(pWnd);
2288 // FIXME: NC_IconForWindow should reference it for us */
2289 if (pIcon)
2290 UserReferenceObject(pIcon);
2291 }
2292
2293 if (pIcon)
2294 {
2297 LONG x = Rect.left - cx/2 + 1 + (Rect.bottom - Rect.top)/2; // this is really what Window does
2298 LONG y = (Rect.top + Rect.bottom - cy)/2; // center
2299 UserDrawIconEx(hDc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
2300 UserDereferenceObject(pIcon);
2301 }
2302 else
2303 {
2304 HasIcon = FALSE;
2305 }
2306 }
2307
2308 if (HasIcon)
2309 Rect.left += Rect.bottom - Rect.top;
2310
2311 if((uFlags & DC_TEXT))
2312 {
2313 BOOL Set = FALSE;
2314 Rect.left += 2;
2315
2316 if (Str)
2317 Set = UserDrawCaptionText(pWnd, hDc, Str, &Rect, uFlags, hFont);
2318 else if (pWnd != NULL) // FIXME: Windows does not do that
2319 {
2320 UNICODE_STRING ustr;
2321 ustr.Buffer = pWnd->strName.Buffer; // FIXME: LARGE_STRING truncated!
2322 ustr.Length = (USHORT)min(pWnd->strName.Length, MAXUSHORT);
2324 Set = UserDrawCaptionText(pWnd, hDc, &ustr, &Rect, uFlags, hFont);
2325 }
2326 if (pWnd)
2327 {
2328 if (Set)
2329 pWnd->state2 &= ~WNDS2_CAPTIONTEXTTRUNCATED;
2330 else
2332 }
2333 }
2334
2335 Ret = TRUE;
2336
2337cleanup:
2338 if (hOldBrush) NtGdiSelectBrush(hDc, hOldBrush);
2339
2340 return Ret;
2341}
2342
2343INT
2346{
2347 HWND hWnd, hWndDesktop;
2348 DWORD Ret;
2349
2351 if (Ret) // There was a change.
2352 {
2354 if (hWnd) // Send broadcast if dc is associated with a window.
2355 { // FYI: Thread locked in CallOneParam.
2356 hWndDesktop = IntGetDesktopWindow();
2357 if ( hWndDesktop != hWnd )
2358 {
2359 PWND pWnd = UserGetWindowObject(hWndDesktop);
2360 ERR("RealizePalette Desktop.\n");
2361 hdc = UserGetWindowDC(pWnd);
2363 UserReleaseDC(pWnd,hdc,FALSE);
2364 }
2366 }
2367 }
2368 return Ret;
2369}
2370
2371BOOL
2374 HWND hWnd,
2375 HDC hDC,
2376 LPCRECT lpRc,
2377 HFONT hFont,
2378 HICON hIcon,
2379 const PUNICODE_STRING str,
2380 UINT uFlags)
2381{
2382 PWND pWnd = NULL;
2383 UNICODE_STRING SafeStr = {0};
2385 RECTL SafeRect;
2386 BOOL Ret;
2387
2389
2390 if (hWnd != NULL)
2391 {
2392 if(!(pWnd = UserGetWindowObject(hWnd)))
2393 {
2394 UserLeave();
2395 return FALSE;
2396 }
2397 }
2398
2399 _SEH2_TRY
2400 {
2401 ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
2402 RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
2403 if (str != NULL)
2404 {
2405 SafeStr = ProbeForReadUnicodeString(str);
2406 if (SafeStr.Length != 0)
2407 {
2408 ProbeForRead( SafeStr.Buffer,
2409 SafeStr.Length,
2410 sizeof(WCHAR));
2411 }
2412 }
2413 }
2415 {
2417 }
2418 _SEH2_END;
2419
2420 if (Status != STATUS_SUCCESS)
2421 {
2423 UserLeave();
2424 return FALSE;
2425 }
2426
2427 if (str != NULL)
2428 Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
2429 else
2430 {
2431 if ( RECTL_bIsEmptyRect(&SafeRect) && hFont == 0 && hIcon == 0 )
2432 {
2433 Ret = TRUE;
2435 {
2436 ERR("NC Caption Mode\n");
2438 goto Exit;
2439 }
2440 else if (uFlags & DC_DRAWFRAMEMD)
2441 {
2442 ERR("NC Paint Mode\n");
2443 NC_DoNCPaint(pWnd, hDC, uFlags); // Update Menus too!
2444 goto Exit;
2445 }
2446 }
2447 Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
2448 }
2449Exit:
2450 UserLeave();
2451 return Ret;
2452}
2453
2454BOOL
2457 HDC hDC,
2458 LPCRECT lpRc,
2459 UINT uFlags)
2460{
2461 return NtUserDrawCaptionTemp(hWnd, hDC, lpRc, 0, 0, NULL, uFlags);
2462}
2463
2466{
2467 POINT pt;
2468 RECT rc;
2469
2470 if (Window->hrgnUpdate)
2471 {
2472 if (Window->hrgnUpdate == HRGN_WINDOW)
2473 {
2474 return NtGdiIntersectClipRect(hDC, 0, 0, 0, 0);
2475 }
2476 else
2477 {
2478 INT ret = ERROR;
2479 HRGN hrgn = NtGdiCreateRectRgn(0,0,0,0);
2480
2481 if ( hrgn && GreGetDCPoint( hDC, GdiGetDCOrg, &pt) )
2482 {
2484 {
2485 NtGdiOffsetRgn(hrgn, pt.x, pt.y);
2486 }
2487 else
2488 {
2489 HRGN hrgnScreen;
2491 hrgnScreen = NtGdiCreateRectRgn(0,0,0,0);
2492 NtGdiCombineRgn(hrgnScreen, hrgnScreen, pm->hrgnMonitor, RGN_OR);
2493
2494 NtGdiCombineRgn(hrgn, hrgnScreen, NULL, RGN_COPY);
2495
2496 GreDeleteObject(hrgnScreen);
2497 }
2498
2499 NtGdiCombineRgn(hrgn, hrgn, Window->hrgnUpdate, RGN_DIFF);
2500
2501 NtGdiOffsetRgn(hrgn, -pt.x, -pt.y);
2502
2504
2506 }
2507 return ret;
2508 }
2509 }
2510 else
2511 {
2512 return GdiGetClipBox( hDC, &rc);
2513 }
2514}
2515
2516INT
2519 HDC hDC,
2520 HWND hWnd)
2521{
2522 INT ret = ERROR;
2523 PWND pWnd;
2524
2525 TRACE("Enter NtUserExcludeUpdateRgn\n");
2527
2528 pWnd = UserGetWindowObject(hWnd);
2529
2530 if (hDC && pWnd)
2532
2533 TRACE("Leave NtUserExcludeUpdateRgn, ret=%i\n", ret);
2534
2535 UserLeave();
2536 return ret;
2537}
2538
2539BOOL
2542 HWND hWnd,
2543 CONST RECT *lpUnsafeRect,
2544 BOOL bErase)
2545{
2546 UINT flags = RDW_INVALIDATE | (bErase ? RDW_ERASE : 0);
2547 if (!hWnd)
2548 {
2550 lpUnsafeRect = NULL;
2551 }
2552 return NtUserRedrawWindow(hWnd, lpUnsafeRect, NULL, flags);
2553}
2554
2555BOOL
2558 HWND hWnd,
2559 HRGN hRgn,
2560 BOOL bErase)
2561{
2562 if (!hWnd)
2563 {
2565 return FALSE;
2566 }
2567 return NtUserRedrawWindow(hWnd, NULL, hRgn, RDW_INVALIDATE | (bErase? RDW_ERASE : 0));
2568}
2569
2570BOOL
2573 HWND hwnd,
2574 HDC hdcBlt,
2575 UINT nFlags)
2576{
2577 PWND Window;
2578 BOOL Ret = FALSE;
2579
2581
2582 if (hwnd)
2583 {
2584 if (!(Window = UserGetWindowObject(hwnd)) ||
2586 {
2587 goto Exit;
2588 }
2589
2590 if ( Window )
2591 {
2592 /* Validate flags and check it as a mask for 0 or 1. */
2593 if ( (nFlags & PW_CLIENTONLY) == nFlags)
2594 Ret = IntPrintWindow( Window, hdcBlt, nFlags);
2595 else
2597 }
2598 }
2599Exit:
2600 UserLeave();
2601 return Ret;
2602}
2603
2604/* ValidateRect gets redirected to NtUserValidateRect:
2605 http://blog.csdn.net/ntdll/archive/2005/10/19/509299.aspx */
2606BOOL
2609 HWND hWnd,
2610 const RECT *lpRect)
2611{
2613 if (!hWnd)
2614 {
2616 lpRect = NULL;
2617 }
2618 return NtUserRedrawWindow(hWnd, lpRect, NULL, flags);
2619}
2620
2621/* 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 ERR(fmt,...)
Definition: precomp.h:57
#define HandleToUlong(h)
Definition: basetsd.h:79
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:106
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:33
#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:2668
return pTarget Start()
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:807
#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:2174
BOOL FASTCALL MsqIsHung(PTHREADINFO pti, DWORD TimeOut)
Definition: msgqueue.c:2143
#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:992
__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:258
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:249
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:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#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:1258
INT FASTCALL UserRealizePalette(HDC hdc)
Definition: painting.c:2345
BOOL FASTCALL IntFillWindow(PWND pWndParent, PWND pWnd, HDC hDC, HBRUSH hBrush)
Definition: painting.c:1561
VOID FASTCALL IntSendSyncPaint(PWND Wnd, ULONG Flags)
Definition: painting.c:132
INT APIENTRY NtUserGetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
Definition: painting.c:1934
BOOL FASTCALL IntIsWindowDrawable(PWND Wnd)
Definition: painting.c:867
VOID FASTCALL PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
Definition: painting.c:1024
VOID FASTCALL IntPaintWindow(PWND Window)
Definition: painting.c:1183
VOID FASTCALL UpdateTheadChildren(PWND pWnd, HRGN hRgn)
Definition: painting.c:1083
VOID FASTCALL UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:620
INT FASTCALL co_UserExcludeUpdateRgn(HDC hDC, PWND Window)
Definition: painting.c:2465
BOOL UserDrawCaptionText(PWND pWnd, HDC hDc, const PUNICODE_STRING Text, const RECTL *lpRc, UINT uFlags, HFONT hFont)
Definition: painting.c:2085
HRGN FASTCALL IntGetNCUpdateRgn(PWND Window, BOOL Validate)
Definition: painting.c:260
BOOL FASTCALL IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
Definition: painting.c:1310
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:2191
BOOL APIENTRY NtUserDrawCaptionTemp(HWND hWnd, HDC hDC, LPCRECT lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING str, UINT uFlags)
Definition: painting.c:2373
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:1441
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:894
BOOL APIENTRY NtUserDrawCaption(HWND hWnd, HDC hDC, LPCRECT lpRc, UINT uFlags)
Definition: painting.c:2456
PWND FASTCALL IntFindWindowToRepaint(PWND Window, PTHREADINFO Thread)
Definition: painting.c:1140
VOID FASTCALL UpdateThreadWindows(PWND pWnd, PTHREADINFO pti, HRGN hRgn)
Definition: painting.c:1099
BOOL APIENTRY NtUserPrintWindow(HWND hwnd, HDC hdcBlt, UINT nFlags)
Definition: painting.c:2572
BOOL FASTCALL IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
Definition: painting.c:1538
BOOL APIENTRY NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags)
Definition: painting.c:2002
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:1961
HRGN FASTCALL IntCalcWindowRgn(PWND Wnd, BOOL Client)
Definition: painting.c:209
BOOL FASTCALL IntIsWindowDirty(PWND Wnd)
Definition: painting.c:1124
BOOL FASTCALL IntGetPaintMessage(PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, PTHREADINFO Thread, MSG *Message, BOOL Remove)
Definition: painting.c:1190
BOOL APIENTRY NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
Definition: painting.c:1751
BOOL APIENTRY NtUserInvalidateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
Definition: painting.c:2557
INT APIENTRY NtUserExcludeUpdateRgn(HDC hDC, HWND hWnd)
Definition: painting.c:2518
BOOL FASTCALL co_UserGetUpdateRect(PWND Window, PRECT pRect, BOOL bErase)
Definition: painting.c:1862
INT FASTCALL co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
Definition: painting.c:1790
HDC APIENTRY NtUserBeginPaint(HWND hWnd, PAINTSTRUCT *UnsafePs)
Definition: painting.c:1614
BOOL APIENTRY NtUserValidateRect(HWND hWnd, const RECT *lpRect)
Definition: painting.c:2608
BOOL APIENTRY NtUserInvalidateRect(HWND hWnd, CONST RECT *lpUnsafeRect, BOOL bErase)
Definition: painting.c:2541
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:1710
BOOL APIENTRY NtUserEndPaint(HWND hWnd, CONST PAINTSTRUCT *pUnsafePs)
Definition: painting.c:1660
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)
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:1689
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:214
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