ReactOS  0.4.15-dev-3299-gbe8e5fc
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>
10 DBG_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.
154  Entry = ptiWnd->SentMessagesListHead.Flink;
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 
208 HRGN 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 
259 HRGN 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;
357  hRgn = HRGN_WINDOW;
358  }
359 
361  {
363  hRgn = HRGN_WINDOW;
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;
406  HWND hWnd = Wnd->head.h;
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 
441  if (Wnd->state & WNDS_SENDERASEBACKGROUND)
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) &&
483  ( Flags & RDW_ALLCHILDREN ||
484  (Flags & RDW_CLIPCHILDREN && Wnd->style & WS_CLIPCHILDREN) ) )
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);
504  UserDerefObjectCo(Wnd);
505  }
506  }
508  }
509  }
510 }
511 
512 /*
513  * IntUpdateWindows
514  *
515  * Internal function used by IntRedrawWindow, simplecall.
516  */
517 
520 {
521  HWND hWnd = Wnd->head.h;
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 
544  Wnd->state2 |= WNDS2_WMPAINTSENT;
546 
547  if (Wnd->state & WNDS_PAINTNOTPROCESSED)
548  {
550  UserRefObjectCo(Wnd, &Ref);
552  UserDerefObjectCo(Wnd);
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) &&
564  (Flags & RDW_ALLCHILDREN) &&
565  !UserIsDesktopWindow(Wnd))
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  {
673  PREGION RgnWindow = IntSysCreateRectpRgnIndirect(&Wnd->rcWindow);
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  {
685  REGION_bOffsetRgn(Rgn,
686  -Wnd->rcWindow.left,
687  -Wnd->rcWindow.top);
688  RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
689  REGION_bOffsetRgn(Rgn,
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  {
714  if (Flags & RDW_INTERNALPAINT)
715  {
716  Wnd->state |= WNDS_INTERNALPAINT;
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  {
776  if (Wnd->state & WNDS_UPDATEDIRTY && !(Flags & RDW_NOUPDATEDIRTY))
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 
931  if (Window != UserGetDesktopWindow())
932  {
933  REGION_bOffsetRgn(TmpRgn, Window->rcClient.left, Window->rcClient.top);
934  }
935  }
936  else
937  {
938  if (UpdateRect != NULL)
939  {
940  if (Window == UserGetDesktopWindow())
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 
1017 VOID FASTCALL
1018 PaintSuspendedWindow(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 
1076 VOID FASTCALL
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 
1092 VOID FASTCALL
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 
1117 BOOL FASTCALL
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  */
1133 PWND FASTCALL
1135 {
1136  PWND hChild;
1137  PWND TempWindow;
1138 
1139  for (; Window != NULL; Window = Window->spwndNext)
1140  {
1142  {
1143  if (IntIsWindowDirty(Window))
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  {
1165  hChild = IntFindWindowToRepaint(Window->spwndChild, Thread);
1166  if (hChild != NULL)
1167  return hChild;
1168  }
1169  }
1170  return Window;
1171 }
1172 
1173 //
1174 // Internal painting of windows.
1175 //
1176 VOID FASTCALL
1178 {
1179  // Handle normal painting.
1181 }
1182 
1183 BOOL FASTCALL
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 
1250 BOOL
1251 FASTCALL
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 
1302 BOOL
1303 FASTCALL
1304 IntFlashWindowEx(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 HDC FASTCALL
1435 {
1436  RECT Rect;
1437  INT type;
1438  BOOL Erase = FALSE;
1439 
1441 
1442  Window->state2 |= WNDS2_STARTPAINT;
1443  Window->state &= ~WNDS_PAINTNOTPROCESSED;
1444 
1445  if (Window->state & WNDS_SENDNCPAINT)
1446  {
1447  HRGN hRgn;
1448  // Application can keep update dirty.
1449  do
1450  {
1451  Window->state &= ~WNDS_UPDATEDIRTY;
1455  {
1456  /* NOTE: The region can already be deleted! */
1458  }
1459  }
1460  while(Window->state & WNDS_UPDATEDIRTY);
1461  }
1462  else
1463  {
1464  Window->state &= ~WNDS_UPDATEDIRTY;
1465  }
1466 
1467  RtlZeroMemory(Ps, sizeof(PAINTSTRUCT));
1468 
1469  if (Window->state2 & WNDS2_ENDPAINTINVALIDATE)
1470  {
1471  ERR("BP: Another thread invalidated this window\n");
1472  }
1473 
1474  Ps->hdc = UserGetDCEx( Window,
1475  Window->hrgnUpdate,
1477  if (!Ps->hdc)
1478  {
1479  return NULL;
1480  }
1481 
1482  // If set, always clear flags out due to the conditions later on for sending the message.
1483  if (Window->state & WNDS_SENDERASEBACKGROUND)
1484  {
1486  Erase = TRUE;
1487  }
1488 
1489  if (Window->hrgnUpdate != NULL)
1490  {
1491  MsqDecPaintCountQueue(Window->head.pti);
1493  /* The region is part of the dc now and belongs to the process! */
1494  Window->hrgnUpdate = NULL;
1495  }
1496  else
1497  {
1498  if (Window->state & WNDS_INTERNALPAINT)
1499  MsqDecPaintCountQueue(Window->head.pti);
1500  }
1501 
1502  type = GdiGetClipBox(Ps->hdc, &Ps->rcPaint);
1503 
1505 
1506  Window->state &= ~WNDS_INTERNALPAINT;
1507 
1508  if ( Erase && // Set to erase,
1509  type != NULLREGION && // don't erase if the clip box is empty,
1510  (!(Window->pcls->style & CS_PARENTDC) || // not parent dc or
1511  RECTL_bIntersectRect( &Rect, &Rect, &Ps->rcPaint) ) ) // intersecting.
1512  {
1514  if ( Ps->fErase )
1515  {
1517  }
1518  }
1519  else
1520  {
1521  Ps->fErase = FALSE;
1522  }
1523 
1525 
1526  return Ps->hdc;
1527 }
1528 
1529 BOOL FASTCALL
1531 {
1532  HDC hdc = NULL;
1533 
1534  hdc = Ps->hdc;
1535 
1536  UserReleaseDC(Wnd, hdc, TRUE);
1537 
1538  if (Wnd->state2 & WNDS2_ENDPAINTINVALIDATE)
1539  {
1540  ERR("EP: Another thread invalidated this window\n");
1542  }
1543 
1545 
1546  co_UserShowCaret(Wnd);
1547 
1548  return TRUE;
1549 }
1550 
1551 BOOL FASTCALL
1552 IntFillWindow(PWND pWndParent,
1553  PWND pWnd,
1554  HDC hDC,
1555  HBRUSH hBrush)
1556 {
1557  RECT Rect, Rect1;
1558  INT type;
1559 
1560  if (!pWndParent)
1561  pWndParent = pWnd;
1562 
1563  type = GdiGetClipBox(hDC, &Rect);
1564 
1565  IntGetClientRect(pWnd, &Rect1);
1566 
1567  if ( type != NULLREGION && // Clip box is not empty,
1568  (!(pWnd->pcls->style & CS_PARENTDC) || // not parent dc or
1569  RECTL_bIntersectRect( &Rect, &Rect, &Rect1) ) ) // intersecting.
1570  {
1571  POINT ppt;
1572  INT x = 0, y = 0;
1573 
1574  if (!UserIsDesktopWindow(pWndParent))
1575  {
1576  x = pWndParent->rcClient.left - pWnd->rcClient.left;
1577  y = pWndParent->rcClient.top - pWnd->rcClient.top;
1578  }
1579 
1580  GreSetBrushOrg(hDC, x, y, &ppt);
1581 
1582  if ( hBrush < (HBRUSH)CTLCOLOR_MAX )
1583  hBrush = GetControlColor( pWndParent, pWnd, hDC, HandleToUlong(hBrush) + WM_CTLCOLORMSGBOX);
1584 
1585  FillRect(hDC, &Rect, hBrush);
1586 
1587  GreSetBrushOrg(hDC, ppt.x, ppt.y, NULL);
1588 
1589  return TRUE;
1590  }
1591  else
1592  return FALSE;
1593 }
1594 
1595 /* PUBLIC FUNCTIONS ***********************************************************/
1596 
1597 /*
1598  * NtUserBeginPaint
1599  *
1600  * Status
1601  * @implemented
1602  */
1603 
1604 HDC APIENTRY
1606 {
1607  PWND Window = NULL;
1608  PAINTSTRUCT Ps;
1609  NTSTATUS Status;
1610  HDC hDC;
1613 
1614  TRACE("Enter NtUserBeginPaint\n");
1616 
1617  if (!(Window = UserGetWindowObject(hWnd)))
1618  {
1619  RETURN( NULL);
1620  }
1621 
1622  UserRefObjectCo(Window, &Ref);
1623 
1624  hDC = IntBeginPaint(Window, &Ps);
1625 
1626  Status = MmCopyToCaller(UnsafePs, &Ps, sizeof(PAINTSTRUCT));
1627  if (! NT_SUCCESS(Status))
1628  {
1630  RETURN(NULL);
1631  }
1632 
1633  RETURN(hDC);
1634 
1635 CLEANUP:
1637 
1638  TRACE("Leave NtUserBeginPaint, ret=%p\n",_ret_);
1639  UserLeave();
1640  END_CLEANUP;
1641 
1642 }
1643 
1644 /*
1645  * NtUserEndPaint
1646  *
1647  * Status
1648  * @implemented
1649  */
1650 
1651 BOOL APIENTRY
1653 {
1655  PWND Window = NULL;
1656  PAINTSTRUCT Ps;
1659 
1660  TRACE("Enter NtUserEndPaint\n");
1662 
1663  if (!(Window = UserGetWindowObject(hWnd)))
1664  {
1665  RETURN(FALSE);
1666  }
1667 
1668  UserRefObjectCo(Window, &Ref); // Here for the exception.
1669 
1670  _SEH2_TRY
1671  {
1672  ProbeForRead(pUnsafePs, sizeof(*pUnsafePs), 1);
1673  RtlCopyMemory(&Ps, pUnsafePs, sizeof(PAINTSTRUCT));
1674  }
1676  {
1678  }
1679  _SEH2_END
1680  if (!NT_SUCCESS(Status))
1681  {
1682  RETURN(FALSE);
1683  }
1684 
1685  RETURN(IntEndPaint(Window, &Ps));
1686 
1687 CLEANUP:
1689 
1690  TRACE("Leave NtUserEndPaint, ret=%i\n",_ret_);
1691  UserLeave();
1692  END_CLEANUP;
1693 }
1694 
1695 /*
1696  * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
1697  */
1698 /*
1699  * @implemented
1700  */
1701 BOOL APIENTRY
1703  HWND hWnd,
1704  HDC hDC,
1705  HBRUSH hBrush)
1706 {
1707  BOOL ret = FALSE;
1708  PWND pWnd, pWndParent = NULL;
1710 
1711  TRACE("Enter NtUserFillWindow\n");
1713 
1714  if (!hDC)
1715  {
1716  goto Exit;
1717  }
1718 
1719  if (!(pWnd = UserGetWindowObject(hWnd)))
1720  {
1721  goto Exit;
1722  }
1723 
1724  if (hWndParent && !(pWndParent = UserGetWindowObject(hWndParent)))
1725  {
1726  goto Exit;
1727  }
1728 
1729  UserRefObjectCo(pWnd, &Ref);
1730  ret = IntFillWindow( pWndParent, pWnd, hDC, hBrush );
1731  UserDerefObjectCo(pWnd);
1732 
1733 Exit:
1734  TRACE("Leave NtUserFillWindow, ret=%i\n",ret);
1735  UserLeave();
1736  return ret;
1737 }
1738 
1739 /*
1740  * @implemented
1741  */
1742 BOOL APIENTRY
1743 NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
1744 {
1745  PWND pWnd;
1746  FLASHWINFO finfo = {0};
1747  BOOL Ret = FALSE;
1748 
1750 
1751  _SEH2_TRY
1752  {
1753  ProbeForRead(pfwi, sizeof(FLASHWINFO), 1);
1754  RtlCopyMemory(&finfo, pfwi, sizeof(FLASHWINFO));
1755  }
1757  {
1759  _SEH2_YIELD(goto Exit);
1760  }
1761  _SEH2_END
1762 
1763  if (!( pWnd = ValidateHwndNoErr(finfo.hwnd)) ||
1764  finfo.cbSize != sizeof(FLASHWINFO) ||
1765  finfo.dwFlags & ~(FLASHW_ALL|FLASHW_TIMER|FLASHW_TIMERNOFG) )
1766  {
1768  goto Exit;
1769  }
1770 
1771  Ret = IntFlashWindowEx(pWnd, &finfo);
1772 
1773 Exit:
1774  UserLeave();
1775  return Ret;
1776 }
1777 
1778 /*
1779  GetUpdateRgn, this fails the same as the old one.
1780  */
1781 INT FASTCALL
1783 {
1784  int RegionType;
1785  BOOL Type;
1786  RECTL Rect;
1787 
1789 
1790  if (bErase)
1791  {
1793  UserRefObjectCo(Window, &Ref);
1796  }
1797 
1798  Window->state &= ~WNDS_UPDATEDIRTY;
1799 
1800  if (Window->hrgnUpdate == NULL)
1801  {
1802  NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1803  return NULLREGION;
1804  }
1805 
1806  Rect = Window->rcClient;
1808 
1809  if (Window->hrgnUpdate == HRGN_WINDOW)
1810  {
1811  // Trap it out.
1812  ERR("GURn: Caller is passing Window Region 1\n");
1813  if (!Type)
1814  {
1815  NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1816  return NULLREGION;
1817  }
1818 
1820 
1822  {
1824  -Window->rcClient.left,
1825  -Window->rcClient.top);
1826  }
1828  }
1829  else
1830  {
1831  HRGN hrgnTemp = GreCreateRectRgnIndirect(&Rect);
1832 
1833  RegionType = NtGdiCombineRgn(hRgn, hrgnTemp, Window->hrgnUpdate, RGN_AND);
1834 
1835  if (RegionType == ERROR || RegionType == NULLREGION)
1836  {
1837  if (hrgnTemp) GreDeleteObject(hrgnTemp);
1838  NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1839  return RegionType;
1840  }
1841 
1843  {
1845  -Window->rcClient.left,
1846  -Window->rcClient.top);
1847  }
1848  if (hrgnTemp) GreDeleteObject(hrgnTemp);
1849  }
1850  return RegionType;
1851 }
1852 
1853 BOOL FASTCALL
1855 {
1856  INT RegionType;
1857  BOOL Ret = TRUE;
1858 
1859  if (bErase)
1860  {
1862  UserRefObjectCo(Window, &Ref);
1865  }
1866 
1867  Window->state &= ~WNDS_UPDATEDIRTY;
1868 
1869  if (Window->hrgnUpdate == NULL)
1870  {
1871  pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1872  Ret = FALSE;
1873  }
1874  else
1875  {
1876  /* Get the update region bounding box. */
1877  if (Window->hrgnUpdate == HRGN_WINDOW)
1878  {
1879  *pRect = Window->rcClient;
1880  ERR("GURt: Caller is retrieving Window Region 1\n");
1881  }
1882  else
1883  {
1884  RegionType = IntGdiGetRgnBox(Window->hrgnUpdate, pRect);
1885 
1886  if (RegionType != ERROR && RegionType != NULLREGION)
1887  RECTL_bIntersectRect(pRect, pRect, &Window->rcClient);
1888  }
1889 
1890  if (IntIntersectWithParents(Window, pRect))
1891  {
1893  {
1894  RECTL_vOffsetRect(pRect,
1895  -Window->rcClient.left,
1896  -Window->rcClient.top);
1897  }
1898  if (Window->pcls->style & CS_OWNDC)
1899  {
1900  HDC hdc;
1901  //DWORD layout;
1903  //layout = NtGdiSetLayout(hdc, -1, 0);
1904  //IntMapWindowPoints( 0, Window, (LPPOINT)pRect, 2 );
1905  GreDPtoLP( hdc, (LPPOINT)pRect, 2 );
1906  //NtGdiSetLayout(hdc, -1, layout);
1908  }
1909  }
1910  else
1911  {
1912  pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1913  }
1914  }
1915  return Ret;
1916 }
1917 
1918 /*
1919  * NtUserGetUpdateRgn
1920  *
1921  * Status
1922  * @implemented
1923  */
1924 
1925 INT APIENTRY
1927 {
1929  PWND Window;
1930  INT ret;
1931 
1932  TRACE("Enter NtUserGetUpdateRgn\n");
1934 
1935  if (!(Window = UserGetWindowObject(hWnd)))
1936  {
1937  RETURN(ERROR);
1938  }
1939 
1940  ret = co_UserGetUpdateRgn(Window, hRgn, bErase);
1941 
1942  RETURN(ret);
1943 
1944 CLEANUP:
1945  TRACE("Leave NtUserGetUpdateRgn, ret=%i\n",_ret_);
1946  UserLeave();
1947  END_CLEANUP;
1948 }
1949 
1950 /*
1951  * NtUserGetUpdateRect
1952  *
1953  * Status
1954  * @implemented
1955  */
1956 
1957 BOOL APIENTRY
1959 {
1960  PWND Window;
1961  RECTL Rect;
1962  NTSTATUS Status;
1963  BOOL Ret;
1965 
1966  TRACE("Enter NtUserGetUpdateRect\n");
1968 
1969  if (!(Window = UserGetWindowObject(hWnd)))
1970  {
1971  RETURN(FALSE);
1972  }
1973 
1974  Ret = co_UserGetUpdateRect(Window, &Rect, bErase);
1975 
1976  if (UnsafeRect != NULL)
1977  {
1978  Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECTL));
1979  if (!NT_SUCCESS(Status))
1980  {
1982  RETURN(FALSE);
1983  }
1984  }
1985 
1986  RETURN(Ret);
1987 
1988 CLEANUP:
1989  TRACE("Leave NtUserGetUpdateRect, ret=%i\n",_ret_);
1990  UserLeave();
1991  END_CLEANUP;
1992 }
1993 
1994 /*
1995  * NtUserRedrawWindow
1996  *
1997  * Status
1998  * @implemented
1999  */
2000 
2001 BOOL APIENTRY
2003  HWND hWnd,
2004  CONST RECT *lprcUpdate,
2005  HRGN hrgnUpdate,
2006  UINT flags)
2007 {
2008  RECTL SafeUpdateRect;
2009  PWND Wnd;
2010  BOOL Ret;
2013  PREGION RgnUpdate = NULL;
2015 
2016  TRACE("Enter NtUserRedrawWindow\n");
2018 
2019  if (!(Wnd = UserGetWindowObject(hWnd ? hWnd : IntGetDesktopWindow())))
2020  {
2021  RETURN( FALSE);
2022  }
2023 
2024  if (lprcUpdate)
2025  {
2026  _SEH2_TRY
2027  {
2028  ProbeForRead(lprcUpdate, sizeof(RECTL), 1);
2029  RtlCopyMemory(&SafeUpdateRect, lprcUpdate, sizeof(RECTL));
2030  }
2032  {
2034  }
2035  _SEH2_END
2036  if (!NT_SUCCESS(Status))
2037  {
2039  RETURN( FALSE);
2040  }
2041  }
2042 
2046  {
2047  /* RedrawWindow fails only in case that flags are invalid */
2049  RETURN( FALSE);
2050  }
2051 
2052  /* We can't hold lock on GDI objects while doing roundtrips to user mode,
2053  * so it will be copied.
2054  */
2055  if (hrgnUpdate > HRGN_WINDOW)
2056  {
2057  RgnUpdate = REGION_LockRgn(hrgnUpdate);
2058  if (!RgnUpdate)
2059  {
2061  RETURN(FALSE);
2062  }
2063  REGION_UnlockRgn(RgnUpdate);
2064  }
2065  else if (hrgnUpdate == HRGN_WINDOW) // Trap it out.
2066  {
2067  ERR("NTRW: Caller is passing Window Region 1\n");
2068  }
2069 
2070  UserRefObjectCo(Wnd, &Ref);
2071 
2072  Ret = co_UserRedrawWindow( Wnd,
2073  lprcUpdate ? &SafeUpdateRect : NULL,
2074  RgnUpdate,
2075  flags);
2076 
2077  UserDerefObjectCo(Wnd);
2078 
2079  RETURN( Ret);
2080 
2081 CLEANUP:
2082  TRACE("Leave NtUserRedrawWindow, ret=%i\n",_ret_);
2083  UserLeave();
2084  END_CLEANUP;
2085 }
2086 
2087 BOOL
2089  PWND pWnd,
2090  HDC hDc,
2091  const PUNICODE_STRING Text,
2092  const RECTL *lpRc,
2093  UINT uFlags,
2094  HFONT hFont)
2095 {
2096  HFONT hOldFont = NULL;
2097  COLORREF OldTextColor;
2098  NONCLIENTMETRICSW nclm;
2099  NTSTATUS Status;
2100  BOOLEAN bDeleteFont = FALSE;
2101  SIZE Size;
2102  BOOL Ret = TRUE;
2103  ULONG fit = 0, Length;
2104  RECTL r = *lpRc;
2105 
2106  TRACE("UserDrawCaptionText: %wZ\n", Text);
2107 
2108  nclm.cbSize = sizeof(nclm);
2109  if (!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0))
2110  {
2111  ERR("UserSystemParametersInfo() failed!\n");
2112  return FALSE;
2113  }
2114 
2115  if (!hFont)
2116  {
2117  if(uFlags & DC_SMALLCAP)
2118  Status = TextIntCreateFontIndirect(&nclm.lfSmCaptionFont, &hFont);
2119  else
2120  Status = TextIntCreateFontIndirect(&nclm.lfCaptionFont, &hFont);
2121 
2122  if(!NT_SUCCESS(Status))
2123  {
2124  ERR("TextIntCreateFontIndirect() failed! Status: 0x%x\n", Status);
2125  return FALSE;
2126  }
2127 
2128  bDeleteFont = TRUE;
2129  }
2130 
2132 
2133  hOldFont = NtGdiSelectFont(hDc, hFont);
2134 
2135  if(uFlags & DC_INBUTTON)
2136  OldTextColor = IntGdiSetTextColor(hDc, IntGetSysColor(COLOR_BTNTEXT));
2137  else
2138  OldTextColor = IntGdiSetTextColor(hDc,
2140 
2141  // Adjust for system menu.
2142  if (pWnd && pWnd->style & WS_SYSMENU)
2143  {
2144  r.right -= UserGetSystemMetrics(SM_CYCAPTION) - 1;
2145  if ((pWnd->style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW))
2146  {
2147  r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2148  r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2149  }
2150  }
2151 
2152  GreGetTextExtentExW(hDc, Text->Buffer, Text->Length/sizeof(WCHAR), r.right - r.left, &fit, 0, &Size, 0);
2153 
2154  Length = (Text->Length/sizeof(WCHAR) == fit ? fit : fit+1);
2155 
2156  if (Text->Length/sizeof(WCHAR) > Length)
2157  {
2158  Ret = FALSE;
2159  }
2160 
2161  if (Ret)
2162  { // Faster while in setup.
2163  UserExtTextOutW( hDc,
2164  lpRc->left,
2165  lpRc->top + (lpRc->bottom - lpRc->top - Size.cy) / 2, // DT_SINGLELINE && DT_VCENTER
2166  ETO_CLIPPED,
2167  (RECTL *)lpRc,
2168  Text->Buffer,
2169  Length);
2170  }
2171  else
2172  {
2173  DrawTextW( hDc,
2174  Text->Buffer,
2175  Text->Length/sizeof(WCHAR),
2176  (RECTL *)&r,
2178  }
2179 
2180  IntGdiSetTextColor(hDc, OldTextColor);
2181 
2182  if (hOldFont)
2183  NtGdiSelectFont(hDc, hOldFont);
2184 
2185  if (bDeleteFont)
2187 
2188  return Ret;
2189 }
2190 
2191 //
2192 // This draws Buttons, Icons and Text...
2193 //
2195  PWND pWnd,
2196  HDC hDc,
2197  RECTL *lpRc,
2198  HFONT hFont,
2199  HICON hIcon,
2200  const PUNICODE_STRING Str,
2201  UINT uFlags)
2202 {
2203  BOOL Ret = FALSE;
2204  HBRUSH hBgBrush, hOldBrush = NULL;
2205  RECTL Rect = *lpRc;
2206  BOOL HasIcon;
2207 
2208  RECTL_vMakeWellOrdered(lpRc);
2209 
2210  /* Determine whether the icon needs to be displayed */
2211  if (!hIcon && pWnd != NULL)
2212  {
2213  HasIcon = (uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP) &&
2214  (pWnd->style & WS_SYSMENU) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW);
2215  }
2216  else
2217  HasIcon = (hIcon != NULL);
2218 
2219  // Draw the caption background
2220  if((uFlags & DC_GRADIENT) && !(uFlags & DC_INBUTTON))
2221  {
2222  static GRADIENT_RECT gcap = {0, 1};
2223  TRIVERTEX Vertices[2];
2224  COLORREF Colors[2];
2225 
2228 
2231 
2232  Vertices[0].x = Rect.left;
2233  Vertices[0].y = Rect.top;
2234  Vertices[0].Red = (WORD)Colors[0]<<8;
2235  Vertices[0].Green = (WORD)Colors[0] & 0xFF00;
2236  Vertices[0].Blue = (WORD)(Colors[0]>>8) & 0xFF00;
2237  Vertices[0].Alpha = 0;
2238 
2239  Vertices[1].x = Rect.right;
2240  Vertices[1].y = Rect.bottom;
2241  Vertices[1].Red = (WORD)Colors[1]<<8;
2242  Vertices[1].Green = (WORD)Colors[1] & 0xFF00;
2243  Vertices[1].Blue = (WORD)(Colors[1]>>8) & 0xFF00;
2244  Vertices[1].Alpha = 0;
2245 
2246  if(!GreGradientFill(hDc, Vertices, 2, &gcap, 1, GRADIENT_FILL_RECT_H))
2247  {
2248  ERR("GreGradientFill() failed!\n");
2249  goto cleanup;
2250  }
2251  }
2252  else
2253  {
2254  if(uFlags & DC_INBUTTON)
2255  hBgBrush = IntGetSysColorBrush(COLOR_3DFACE);
2256  else if(uFlags & DC_ACTIVE)
2258  else
2260 
2261  hOldBrush = NtGdiSelectBrush(hDc, hBgBrush);
2262 
2263  if(!hOldBrush)
2264  {
2265  ERR("NtGdiSelectBrush() failed!\n");
2266  goto cleanup;
2267  }
2268 
2269  if(!NtGdiPatBlt(hDc, Rect.left, Rect.top,
2270  Rect.right - Rect.left,
2271  Rect.bottom - Rect.top,
2272  PATCOPY))
2273  {
2274  ERR("NtGdiPatBlt() failed!\n");
2275  goto cleanup;
2276  }
2277  }
2278 
2279  /* Draw icon */
2280  if (HasIcon)
2281  {
2282  PCURICON_OBJECT pIcon = NULL;
2283 
2284  if (hIcon)
2285  {
2286  pIcon = UserGetCurIconObject(hIcon);
2287  }
2288  else if (pWnd)
2289  {
2290  pIcon = NC_IconForWindow(pWnd);
2291  // FIXME: NC_IconForWindow should reference it for us */
2292  if (pIcon)
2293  UserReferenceObject(pIcon);
2294  }
2295 
2296  if (pIcon)
2297  {
2300  LONG x = Rect.left - cx/2 + 1 + (Rect.bottom - Rect.top)/2; // this is really what Window does
2301  LONG y = (Rect.top + Rect.bottom - cy)/2; // center
2302  UserDrawIconEx(hDc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
2303  UserDereferenceObject(pIcon);
2304  }
2305  else
2306  {
2307  HasIcon = FALSE;
2308  }
2309  }
2310 
2311  if (HasIcon)
2312  Rect.left += Rect.bottom - Rect.top;
2313 
2314  if((uFlags & DC_TEXT))
2315  {
2316  BOOL Set = FALSE;
2317  Rect.left += 2;
2318 
2319  if (Str)
2320  Set = UserDrawCaptionText(pWnd, hDc, Str, &Rect, uFlags, hFont);
2321  else if (pWnd != NULL) // FIXME: Windows does not do that
2322  {
2323  UNICODE_STRING ustr;
2324  ustr.Buffer = pWnd->strName.Buffer; // FIXME: LARGE_STRING truncated!
2325  ustr.Length = (USHORT)min(pWnd->strName.Length, MAXUSHORT);
2327  Set = UserDrawCaptionText(pWnd, hDc, &ustr, &Rect, uFlags, hFont);
2328  }
2329  if (pWnd)
2330  {
2331  if (Set)
2333  else
2335  }
2336  }
2337 
2338  Ret = TRUE;
2339 
2340 cleanup:
2341  if (hOldBrush) NtGdiSelectBrush(hDc, hOldBrush);
2342 
2343  return Ret;
2344 }
2345 
2346 INT
2347 FASTCALL
2349 {
2350  HWND hWnd, hWndDesktop;
2351  DWORD Ret;
2352 
2353  Ret = IntGdiRealizePalette(hdc);
2354  if (Ret) // There was a change.
2355  {
2357  if (hWnd) // Send broadcast if dc is associated with a window.
2358  { // FYI: Thread locked in CallOneParam.
2359  hWndDesktop = IntGetDesktopWindow();
2360  if ( hWndDesktop != hWnd )
2361  {
2362  PWND pWnd = UserGetWindowObject(hWndDesktop);
2363  ERR("RealizePalette Desktop.");
2364  hdc = UserGetWindowDC(pWnd);
2366  UserReleaseDC(pWnd,hdc,FALSE);
2367  }
2369  }
2370  }
2371  return Ret;
2372 }
2373 
2374 BOOL
2375 APIENTRY
2377  HWND hWnd,
2378  HDC hDC,
2379  LPCRECT lpRc,
2380  HFONT hFont,
2381  HICON hIcon,
2382  const PUNICODE_STRING str,
2383  UINT uFlags)
2384 {
2385  PWND pWnd = NULL;
2386  UNICODE_STRING SafeStr = {0};
2388  RECTL SafeRect;
2389  BOOL Ret;
2390 
2392 
2393  if (hWnd != NULL)
2394  {
2395  if(!(pWnd = UserGetWindowObject(hWnd)))
2396  {
2397  UserLeave();
2398  return FALSE;
2399  }
2400  }
2401 
2402  _SEH2_TRY
2403  {
2404  ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
2405  RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
2406  if (str != NULL)
2407  {
2408  SafeStr = ProbeForReadUnicodeString(str);
2409  if (SafeStr.Length != 0)
2410  {
2411  ProbeForRead( SafeStr.Buffer,
2412  SafeStr.Length,
2413  sizeof(WCHAR));
2414  }
2415  }
2416  }
2418  {
2420  }
2421  _SEH2_END;
2422 
2423  if (Status != STATUS_SUCCESS)
2424  {
2426  UserLeave();
2427  return FALSE;
2428  }
2429 
2430  if (str != NULL)
2431  Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
2432  else
2433  {
2434  if ( RECTL_bIsEmptyRect(&SafeRect) && hFont == 0 && hIcon == 0 )
2435  {
2436  Ret = TRUE;
2437  if (uFlags & DC_DRAWCAPTIONMD)
2438  {
2439  ERR("NC Caption Mode\n");
2440  UserDrawCaptionBar(pWnd, hDC, uFlags);
2441  goto Exit;
2442  }
2443  else if (uFlags & DC_DRAWFRAMEMD)
2444  {
2445  ERR("NC Paint Mode\n");
2446  NC_DoNCPaint(pWnd, hDC, uFlags); // Update Menus too!
2447  goto Exit;
2448  }
2449  }
2450  Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
2451  }
2452 Exit:
2453  UserLeave();
2454  return Ret;
2455 }
2456 
2457 BOOL
2458 APIENTRY
2460  HDC hDC,
2461  LPCRECT lpRc,
2462  UINT uFlags)
2463 {
2464  return NtUserDrawCaptionTemp(hWnd, hDC, lpRc, 0, 0, NULL, uFlags);
2465 }
2466 
2467 INT FASTCALL
2469 {
2470  POINT pt;
2471  RECT rc;
2472 
2473  if (Window->hrgnUpdate)
2474  {
2475  if (Window->hrgnUpdate == HRGN_WINDOW)
2476  {
2477  return NtGdiIntersectClipRect(hDC, 0, 0, 0, 0);
2478  }
2479  else
2480  {
2481  INT ret = ERROR;
2482  HRGN hrgn = NtGdiCreateRectRgn(0,0,0,0);
2483 
2484  if ( hrgn && GreGetDCPoint( hDC, GdiGetDCOrg, &pt) )
2485  {
2487  {
2488  NtGdiOffsetRgn(hrgn, pt.x, pt.y);
2489  }
2490  else
2491  {
2492  HRGN hrgnScreen;
2494  hrgnScreen = NtGdiCreateRectRgn(0,0,0,0);
2495  NtGdiCombineRgn(hrgnScreen, hrgnScreen, pm->hrgnMonitor, RGN_OR);
2496 
2497  NtGdiCombineRgn(hrgn, hrgnScreen, NULL, RGN_COPY);
2498 
2499  GreDeleteObject(hrgnScreen);
2500  }
2501 
2502  NtGdiCombineRgn(hrgn, hrgn, Window->hrgnUpdate, RGN_DIFF);
2503 
2504  NtGdiOffsetRgn(hrgn, -pt.x, -pt.y);
2505 
2507 
2509  }
2510  return ret;
2511  }
2512  }
2513  else
2514  {
2515  return GdiGetClipBox( hDC, &rc);
2516  }
2517 }
2518 
2519 INT
2520 APIENTRY
2522  HDC hDC,
2523  HWND hWnd)
2524 {
2525  INT ret = ERROR;
2526  PWND pWnd;
2527 
2528  TRACE("Enter NtUserExcludeUpdateRgn\n");
2530 
2531  pWnd = UserGetWindowObject(hWnd);
2532 
2533  if (hDC && pWnd)
2534  ret = co_UserExcludeUpdateRgn(hDC, pWnd);
2535 
2536  TRACE("Leave NtUserExcludeUpdateRgn, ret=%i\n", ret);
2537 
2538  UserLeave();
2539  return ret;
2540 }
2541 
2542 BOOL
2543 APIENTRY
2545  HWND hWnd,
2546  CONST RECT *lpUnsafeRect,
2547  BOOL bErase)
2548 {
2549  UINT flags = RDW_INVALIDATE | (bErase ? RDW_ERASE : 0);
2550  if (!hWnd)
2551  {
2553  lpUnsafeRect = NULL;
2554  }
2555  return NtUserRedrawWindow(hWnd, lpUnsafeRect, NULL, flags);
2556 }
2557 
2558 BOOL
2559 APIENTRY
2561  HWND hWnd,
2562  HRGN hRgn,
2563  BOOL bErase)
2564 {
2565  if (!hWnd)
2566  {
2568  return FALSE;
2569  }
2570  return NtUserRedrawWindow(hWnd, NULL, hRgn, RDW_INVALIDATE | (bErase? RDW_ERASE : 0));
2571 }
2572 
2573 BOOL
2574 APIENTRY
2576  HWND hwnd,
2577  HDC hdcBlt,
2578  UINT nFlags)
2579 {
2580  PWND Window;
2581  BOOL Ret = FALSE;
2582 
2584 
2585  if (hwnd)
2586  {
2587  if (!(Window = UserGetWindowObject(hwnd)) ||
2589  {
2590  goto Exit;
2591  }
2592 
2593  if ( Window )
2594  {
2595  /* Validate flags and check it as a mask for 0 or 1. */
2596  if ( (nFlags & PW_CLIENTONLY) == nFlags)
2597  Ret = IntPrintWindow( Window, hdcBlt, nFlags);
2598  else
2600  }
2601  }
2602 Exit:
2603  UserLeave();
2604  return Ret;
2605 }
2606 
2607 /* ValidateRect gets redirected to NtUserValidateRect:
2608  http://blog.csdn.net/ntdll/archive/2005/10/19/509299.aspx */
2609 BOOL
2610 APIENTRY
2612  HWND hWnd,
2613  const RECT *lpRect)
2614 {
2616  if (!hWnd)
2617  {
2619  lpRect = NULL;
2620  }
2621  return NtUserRedrawWindow(hWnd, lpRect, NULL, flags);
2622 }
2623 
2624 /* EOF */
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1203
#define WM_SYNCPAINT
Definition: winuser.h:1673
#define RDW_NOCHILDREN
Definition: winuser.h:1208
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:12
UINT_PTR FASTCALL IntSetTimer(PWND Window, UINT_PTR IDEvent, UINT Elapse, TIMERPROC TimerFunc, INT Type)
Definition: timer.c:177
BOOL FASTCALL IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
Definition: painting.c:1304
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define IN
Definition: typedefs.h:39
DWORD ExStyle
Definition: ntuser.h:674
static HICON
Definition: imagelist.c:84
BOOL UserDrawIconEx(HDC hDc, INT xLeft, INT yTop, PCURICON_OBJECT pIcon, INT cxWidth, INT cyHeight, UINT istepIfAniCur, HBRUSH hbrFlickerFreeDraw, UINT diFlags)
Definition: cursoricon.c:1688
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
INT FASTCALL co_UserExcludeUpdateRgn(HDC hDC, PWND Window)
Definition: painting.c:2468
Definition: client.c:28
PWND FASTCALL IntFindWindowToRepaint(PWND Window, PTHREADINFO Thread)
Definition: painting.c:1134
#define CLEANUP
Definition: ntuser.h:5
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
BOOL NTAPI GreIsHandleValid(HGDIOBJ hobj)
Definition: gdiobj.c:1146
VOID FASTCALL UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:620
_In_ int _Inout_ LPRECT lprc
Definition: winuser.h:4441
BOOL FASTCALL IntPrintWindow(PWND pwnd, HDC hdcBlt, UINT nFlags)
Definition: painting.c:1252
BOOL FASTCALL MsqIsHung(PTHREADINFO pti, DWORD TimeOut)
Definition: msgqueue.c:2194
__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
long y
Definition: polytest.cpp:48
BOOL FASTCALL IntGetPaintMessage(PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, PTHREADINFO Thread, MSG *Message, BOOL Remove)
Definition: painting.c:1184
#define DWORD_PTR
Definition: treelist.c:76
__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
struct _Entry Entry
Definition: kefuncs.h:627
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
BOOL APIENTRY NtUserInvalidateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
Definition: painting.c:2560
PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon)
Definition: cursoricon.c:200
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
BOOL APIENTRY NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags)
Definition: painting.c:2002
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:220
long x
Definition: polytest.cpp:48
#define IntWndBelongsToThread(WndObj, W32Thread)
Definition: window.h:31
#define PRGN_WINDOW
Definition: painting.h:12
static HTREEITEM hChild
Definition: treeview.c:381
#define TRUE
Definition: types.h:120
#define pt(x, y)
Definition: drawing.c:79
NTSTATUS FASTCALL TextIntCreateFontIndirect(CONST LPLOGFONTW lf, HFONT *NewFont)
Definition: freetype.c:2051
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
VOID FASTCALL IntSendSyncPaint(PWND Wnd, ULONG Flags)
Definition: painting.c:132
#define ERROR(name)
Definition: error_private.h:53
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:13
__kernel_entry W32KAPI INT APIENTRY NtGdiExtSelectClipRgn(_In_ HDC hdc, _In_opt_ HRGN hrgn, _In_ INT iMode)
GLuint GLuint GLsizei count
Definition: gl.h:1545
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1827
#define WNDS_SENDNCPAINT
Definition: ntuser.h:590
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
static LPMONITOREX pm
Definition: localmon.c:45
BOOL FASTCALL IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
Definition: timer.c:573
LONG NTSTATUS
Definition: precomp.h:26
BOOL FASTCALL UserSendNotifyMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2037
#define HandleToUlong(h)
Definition: basetsd.h:79
VOID FASTCALL IntSendNCPaint(PWND pWnd, HRGN hRgn)
Definition: painting.c:348
static HDC
Definition: imagelist.c:92
HWND hWnd
Definition: settings.c:17
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
#define NULLREGION
Definition: wingdi.h:361
#define FLASHW_SYSTIMER
Definition: painting.h:4
LONG top
Definition: windef.h:307
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:25
long bottom
Definition: polytest.cpp:53
#define MSQ_HUNG
Definition: msgqueue.h:3
static HRGN hRgn
Definition: mapping.c:33
#define DCX_USESTYLE
Definition: GetDCEx.c:10
#define WS_DLGFRAME
Definition: pedump.c:626
INT FASTCALL IntGdiSetBkMode(HDC hDC, INT backgroundMode)
Definition: dcutil.c:124
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define COLOR_INACTIVECAPTION
Definition: winuser.h:906
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
#define COLOR_CAPTIONTEXT
Definition: winuser.h:912
HDC FASTCALL UserGetWindowDC(PWND Wnd)
Definition: windc.c:946
#define SM_CYSMICON
Definition: winuser.h:1003
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:610
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
UINT_PTR WPARAM
Definition: windef.h:207
BOOL FASTCALL REGION_bOffsetRgn(_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:2727
#define WS_CHILD
Definition: pedump.c:617
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical 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:728
RECT rcClient
Definition: ntuser.h:687
BOOL APIENTRY NtUserValidateRect(HWND hWnd, const RECT *lpRect)
Definition: painting.c:2611
#define RDW_FRAME
Definition: winuser.h:1198
LONG left
Definition: windef.h:306
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:91
VOID FASTCALL PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
Definition: painting.c:1018
UINT uFlags
Definition: api.c:59
#define CS_OWNDC
Definition: winuser.h:650
static HDC hdcSrc
Definition: xlate.c:32
#define WNDS2_STARTPAINT
Definition: ntuser.h:617
#define WS_CLIPCHILDREN
Definition: pedump.c:619
LONG right
Definition: windef.h:308
#define DT_NOPREFIX
Definition: winuser.h:537
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2377
#define FASTCALL
Definition: nt_native.h:50
#define TIF_SYSTEMTHREAD
Definition: ntuser.h:247
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
#define COLOR_WINDOW
Definition: winuser.h:908
PSERVERINFO gpsi
Definition: main.c:27
int32_t INT
Definition: typedefs.h:58
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define DCX_INTERSECTRGN
Definition: winuser.h:2105
HFONT hFont
Definition: main.c:53
#define RETURN(x)
static BOOL Set
Definition: pageheap.c:10
#define DCX_WINDOW
Definition: winuser.h:2096
BOOL APIENTRY NtUserDrawCaptionTemp(HWND hWnd, HDC hDC, LPCRECT lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING str, UINT uFlags)
Definition: painting.c:2376
_SEH2_TRY
Definition: create.c:4226
__kernel_entry W32KAPI HBRUSH APIENTRY NtGdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbrush)
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:782
#define DC_ICON
Definition: winuser.h:429
PPROCESSINFO ppi
Definition: win32.h:89
#define FLASHW_KILLSYSTIMER
Definition: painting.h:8
#define RGN_AND
Definition: wingdi.h:356
#define WNDS_PAINTNOTPROCESSED
Definition: ntuser.h:601
#define WM_NCPAINT
Definition: winuser.h:1670
HBRUSH FASTCALL GetControlColor(PWND pwndParent, PWND pwnd, HDC hdc, UINT CtlMsg)
Definition: misc.c:145
Definition: window.c:28
LONG y
Definition: wingdi.h:2785
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
Definition: region.c:2426
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
#define COLOR_3DFACE
Definition: winuser.h:919
#define COLOR_GRADIENTINACTIVECAPTION
Definition: winuser.h:935
UINT style
Definition: ntuser.h:554
#define DC_NC
Definition: winuser.h:440
#define FALSE
Definition: types.h:117
#define DT_LEFT
Definition: winuser.h:534
#define WM_NCACTIVATE
Definition: winuser.h:1671
#define WS_MINIMIZE
Definition: pedump.c:622
BOOL UserDrawCaptionText(PWND pWnd, HDC hDc, const PUNICODE_STRING Text, const RECTL *lpRc, UINT uFlags, HFONT hFont)
Definition: painting.c:2088
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:533
#define RDW_NOUPDATEDIRTY
Definition: painting.h:16
unsigned int BOOL
Definition: ntddk_ex.h:94
VOID FASTCALL UserUpdateWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:598
long LONG
Definition: pedump.c:60
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:38
LIST_ENTRY SentMessagesListHead
Definition: win32.h:101
BOOL FASTCALL IntIsWindowDrawable(PWND Wnd)
Definition: painting.c:861
BOOL FASTCALL GreDPtoLP(HDC, LPPOINT, INT)
Definition: dcutil.c:7
HRGN FASTCALL IntGetNCUpdateRgn(PWND Window, BOOL Validate)
Definition: painting.c:260
long top
Definition: polytest.cpp:53
#define TRANSPARENT
Definition: wingdi.h:950
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:585
LRESULT NC_DoNCPaint(PWND pWnd, HDC hDC, INT Flags)
Definition: nonclient.c:1042
#define GreCreateRectRgnIndirect(prc)
Definition: region.h:96
INT FASTCALL UserRealizePalette(HDC hdc)
Definition: painting.c:2348
THRDESKHEAD head
Definition: ntuser.h:665
const WCHAR * str
Definition: object.h:3
#define DC_DRAWFRAMEMD
Definition: undocuser.h:152
#define MAKELONG(a, b)
Definition: typedefs.h:249
unsigned char BOOLEAN
#define DT_END_ELLIPSIS
Definition: winuser.h:529
BOOL APIENTRY NtUserEndPaint(HWND hWnd, CONST PAINTSTRUCT *pUnsafePs)
Definition: painting.c:1652
VOID CALLBACK SystemTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
Definition: timer.c:280
#define DCX_KEEPCLIPRGN
Definition: undocuser.h:67
HRGN hrgnClip
Definition: ntuser.h:703
#define HRGN_WINDOW
Definition: ntuser.h:335
#define COLOR_ACTIVECAPTION
Definition: winuser.h:905
#define RGN_OR
Definition: wingdi.h:359
__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)
BOOL FASTCALL IntPaintDesktop(HDC hDC)
Definition: desktop.c:1795
#define WM_CTLCOLORMSGBOX
Definition: winuser.h:1749
INT FASTCALL co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
Definition: painting.c:1782
COLORREF FASTCALL IntGdiSetTextColor(HDC hDC, COLORREF color)
Definition: dcutil.c:172
__kernel_entry W32KAPI BOOL APIENTRY NtGdiSetRectRgn(_In_ HRGN hrgn, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: region.c:4068
_In_ BOOLEAN Remove
Definition: psfuncs.h:110
HWND FASTCALL IntWindowFromDC(HDC hDc)
Definition: windc.c:893
BOOL NTAPI GreGradientFill(HDC hdc, PTRIVERTEX pVertex, ULONG nVertex, PVOID pMesh, ULONG nMesh, ULONG ulMode)
Definition: fillshap.c:871
#define ETO_CLIPPED
Definition: wingdi.h:648
struct _WND * spwndNext
Definition: ntuser.h:681
Definition: region.h:7
HDC APIENTRY NtUserBeginPaint(HWND hWnd, PAINTSTRUCT *UnsafePs)
Definition: painting.c:1605
#define DT_VCENTER
Definition: winuser.h:543
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
LARGE_UNICODE_STRING strName
Definition: ntuser.h:706
long left
Definition: polytest.cpp:53
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
#define WS_EX_REDIRECTED
Definition: undocuser.h:25
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
INT FASTCALL IntGdiCombineRgn(PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
Definition: region.c:2506
PCURICON_OBJECT FASTCALL NC_IconForWindow(PWND pWnd)
Definition: nonclient.c:681
BOOL FASTCALL IntFillWindow(PWND pWndParent, PWND pWnd, HDC hDC, HBRUSH hBrush)
Definition: painting.c:1552
#define DC_ACTIVE
Definition: winuser.h:427
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:180
BOOL FASTCALL IntIntersectWithParents(PWND Child, RECTL *WindowRect)
Definition: painting.c:35
#define IntSysCreateRectpRgnIndirect(prc)
Definition: region.h:93
INT APIENTRY NtUserGetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
Definition: painting.c:1926
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:245
Status
Definition: gdiplustypes.h:24
#define UserHMGetHandle(obj)
Definition: ntuser.h:213
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define FLASHW_FINISHED
Definition: painting.h:5
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define SM_CYCAPTION
Definition: winuser.h:953
#define ASSERT(a)
Definition: mode.c:44
#define TMRF_SYSTEM
Definition: timer.h:20
void Erase(HDC hdc, LONG x1, LONG y1, LONG x2, LONG y2, COLORREF color, LONG radius)
Definition: drawing.cpp:117
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
LONG x
Definition: wingdi.h:2784
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
DWORD COLORREF
Definition: windef.h:300
static void Exit(void)
Definition: sock.c:1331
#define RDW_ERASE
Definition: winuser.h:1197
Colors
Definition: ansiprsr.h:4
BOOL FASTCALL IntGdiSetRegionOwner(HRGN hRgn, DWORD OwnerMask)
Definition: region.c:2478
VOID FASTCALL co_IntPaintWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:403
#define WNDS2_ENDPAINTINVALIDATE
Definition: ntuser.h:616
INT APIENTRY NtUserExcludeUpdateRgn(HDC hDC, HWND hWnd)
Definition: painting.c:2521
HANDLE FASTCALL UserGetProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
Definition: prop.c:46
#define WM_PALETTECHANGED
Definition: winuser.h:1860
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
HRGN hrgnUpdate
Definition: ntuser.h:691
unsigned short WORD
Definition: ntddk_ex.h:93
Type
Definition: Type.h:6
BOOL FASTCALL IntValidateParents(PWND Child, BOOL Recurse)
Definition: painting.c:62
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD FASTCALL IntGetSysColor(INT nIndex)
Definition: stockobj.c:323
#define DECLARE_RETURN(type)
Definition: ntuser.h:3
VOID FASTCALL co_IntUpdateWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:519
_In_opt_ PFILE_OBJECT _In_opt_ PETHREAD Thread
Definition: fltkernel.h:2652
#define GreSetRectRgnIndirect(hRgn, prc)
Definition: region.h:99
#define COLOR_GRADIENTACTIVECAPTION
Definition: winuser.h:934
HDC FASTCALL IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
Definition: painting.c:1434
#define CLIPRGN
Definition: precomp.h:18
INT APIENTRY IntGdiGetRgnBox(HRGN hRgn, PRECTL pRect)
Definition: region.c:2580
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:157
BOOL APIENTRY NtUserFillWindow(HWND hWndParent, HWND hWnd, HDC hDC, HBRUSH hBrush)
Definition: painting.c:1702
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:223
Definition: partlist.h:33
int Window
Definition: x11stubs.h:26
GLbitfield flags
Definition: glext.h:7161
#define WM_PAINT
Definition: winuser.h:1603
#define SM_CXSMICON
Definition: winuser.h:1002
VOID FASTCALL MsqDecPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:508
CHAR Message[80]
Definition: alive.c:5
__kernel_entry W32KAPI INT APIENTRY NtGdiOffsetRgn(_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:3981
BOOL APIENTRY NtUserPrintWindow(HWND hwnd, HDC hdcBlt, UINT nFlags)
Definition: painting.c:2575
#define ID_EVENT_SYSTIMER_FLASHWIN
Definition: timer.h:28
BOOL UserExtTextOutW(HDC hdc, INT x, INT y, UINT flags, PRECTL lprc, LPCWSTR lpString, UINT count)
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1353
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:642
#define RDW_VALIDATE
Definition: winuser.h:1204
int ret
#define WNDS_SYNCPAINTPENDING
Definition: ntuser.h:602
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define WNDS2_WMPAINTSENT
Definition: ntuser.h:615
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1446
HDC hdc
Definition: main.c:9
#define RDW_INTERNALPAINT
Definition: winuser.h:1199
#define FLASHW_ACTIVE
Definition: painting.h:9
BOOL APIENTRY GreGetDCPoint(HDC hDC, UINT iPoint, PPOINTL Point)
Definition: coord.c:1291
static HRGN hrgn
Definition: win.c:55
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define COLOR_INACTIVECAPTIONTEXT
Definition: winuser.h:924
#define DI_NORMAL
Definition: wingdi.h:72
#define RDW_NOERASE
Definition: winuser.h:1201
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:255
#define WNDS_ACTIVEFRAME
Definition: ntuser.h:585
RECT rcWindow
Definition: ntuser.h:686
BOOL FASTCALL co_UserShowCaret(PWND Window OPTIONAL)
Definition: caret.c:272
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
VOID FASTCALL IntSendChildNCPaint(PWND pWnd)
Definition: painting.c:370
PWND FASTCALL ValidateHwndNoErr(HWND hwnd)
Definition: utils.c:146
Definition: typedefs.h:119
static IHTMLWindow2 * window
Definition: events.c:77
uint32_t DWORD_PTR
Definition: typedefs.h:65
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:36
#define RDW_NOFRAME
Definition: winuser.h:1202
#define WNDS2_FORCEFULLNCPAINTCLIPRGN
Definition: ntuser.h:638
__kernel_entry W32KAPI INT APIENTRY NtGdiCombineRgn(_In_ HRGN hrgnDst, _In_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ INT iMode)
BOOL FASTCALL GreSetBrushOrg(HDC, INT, INT, LPPOINT)
Definition: dcutil.c:231
#define CTLCOLOR_MAX
Definition: winuser.h:948
#define PATCOPY
Definition: wingdi.h:335
#define RGN_COPY
Definition: wingdi.h:357
#define SIMPLEREGION
Definition: wingdi.h:362
#define ERR(fmt,...)
Definition: debug.h:110
Definition: ntuser.h:663
VOID FASTCALL UpdateThreadWindows(PWND pWnd, PTHREADINFO pti, HRGN hRgn)
Definition: painting.c:1093
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:253
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1342
static HDC hDC
Definition: 3dtext.c:33
VOID UserDrawCaptionBar(PWND pWnd, HDC hDC, INT Flags)
Definition: nonclient.c:900
#define DCX_CACHE
Definition: winuser.h:2097
#define DT_SINGLELINE
Definition: winuser.h:540
BOOL APIENTRY NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
Definition: painting.c:1958
#define DC_NOSENDMSG
Definition: undocuser.h:147
_SEH2_END
Definition: create.c:4400
#define WS_BORDER
Definition: pedump.c:625
COLOR16 Alpha
Definition: wingdi.h:2789
#define DC_SMALLCAP
Definition: winuser.h:428
#define WS_MINIMIZEBOX
Definition: pedump.c:631
BOOL FASTCALL IsThreadSuspended(PTHREADINFO pti)
Definition: msgqueue.c:2225
#define RGN_DIFF
Definition: wingdi.h:358
unsigned short USHORT
Definition: pedump.c:61
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
HICON hIcon
Definition: msconfig.c:44
#define RDW_ALLCHILDREN
Definition: winuser.h:1207
FORCEINLINE BOOL IntEqualRect(RECTL *lprc1, RECTL *lprc2)
Definition: winpos.h:48
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1710
DWORD state
Definition: ntuser.h:671
VOID FASTCALL UpdateTheadChildren(PWND pWnd, HRGN hRgn)
Definition: painting.c:1077
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
BOOL FASTCALL IntIsWindowDirty(PWND Wnd)
Definition: painting.c:1118
#define min(a, b)
Definition: monoChain.cc:55
BOOL FASTCALL IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
Definition: painting.c:1530
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
__kernel_entry W32KAPI INT APIENTRY NtGdiGetRandomRgn(_In_ HDC hdc, _In_ HRGN hrgn, _In_ INT iRgn)
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:917
#define WNDS_NONCPAINT
Definition: ntuser.h:587
VOID FASTCALL IntPaintWindow(PWND Window)
Definition: painting.c:1177
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
UINT FASTCALL IntGdiRealizePalette(HDC)
Definition: palette.c:731
#define WNDS_INTERNALPAINT
Definition: ntuser.h:591
#define FLASHW_STARTED
Definition: painting.h:6
#define MAXUSHORT
Definition: typedefs.h:83
#define ProbeForReadUnicodeString(Ptr)
Definition: probe.h:77
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:588
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
#define WNDS_UPDATEDIRTY
Definition: ntuser.h:592
VOID FASTCALL MsqIncPaintCountQueue(PTHREADINFO pti)
Definition: msgqueue.c:501
#define WNDS2_CAPTIONTEXTTRUNCATED
Definition: ntuser.h:640
#define RDW_UPDATENOW
Definition: winuser.h:1206
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2392
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
_Out_opt_ int * cx
Definition: commctrl.h:585
#define RDW_ERASENOW
Definition: winuser.h:1205
COLOR16 Red
Definition: wingdi.h:2786
COLOR16 Blue
Definition: wingdi.h:2788
#define SM_CXSIZE
Definition: winuser.h:981
#define RDW_CLIPCHILDREN
Definition: painting.h:15
struct _WND * spwndParent
Definition: ntuser.h:683
HRGN FASTCALL IntCalcWindowRgn(PWND Wnd, BOOL Client)
Definition: painting.c:209
#define WNDS_ERASEBACKGROUND
Definition: ntuser.h:589
#define HIWORD(l)
Definition: typedefs.h:247
FORCEINLINE BOOL RECTL_bIsEmptyRect(_In_ const RECTL *prcl)
Definition: rect.h:44
unsigned int ULONG
Definition: retypes.h:1
DWORD state2
Definition: ntuser.h:672
BOOL APIENTRY NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
Definition: painting.c:1743
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
LONG bottom
Definition: windef.h:309
#define FLASHW_MASK
Definition: painting.h:3
char * cleanup(char *str)
Definition: wpickclick.c:99
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define COLOR_BTNTEXT
Definition: winuser.h:923
#define FLASHW_COUNT
Definition: painting.h:7
BOOL FASTCALL IntIsChildWindow(PWND Parent, PWND BaseWindow)
Definition: window.c:882
BOOL FASTCALL co_UserHideCaret(PWND Window OPTIONAL)
Definition: caret.c:237
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2088
COLOR16 Green
Definition: wingdi.h:2787
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
static int UpdateRect(TreeListData *pData, unsigned uItem, unsigned uSub)
Definition: treelist.c:1529
#define STATUS_SUCCESS
Definition: shellext.h:65
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define WM_ERASEBKGND
Definition: winuser.h:1608
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define USERTAG_WINDOWLIST
Definition: tags.h:297
RegionType
DBG_DEFAULT_CHANNEL(UserPainting)
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
struct _WND * spwndChild
Definition: ntuser.h:684
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_SYSMENU
Definition: pedump.c:629
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define HWND_BROADCAST
Definition: winuser.h:1190
BOOL FASTCALL co_UserGetUpdateRect(PWND Window, PRECT pRect, BOOL bErase)
Definition: painting.c:1854
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2468
HANDLE FASTCALL UserRemoveProp(_In_ PWND Window, _In_ ATOM Atom, _In_ BOOLEAN SystemProp)
#define WNDS_DESTROYED
Definition: ntuser.h:610
ATOM AtomFlashWndState
Definition: ntuser.c:22
VOID FASTCALL RECTL_vMakeWellOrdered(_Inout_ RECTL *prcl)
Definition: rect.c:81
#define LOWORD(l)
Definition: pedump.c:82
BOOL APIENTRY NtUserInvalidateRect(HWND hWnd, CONST RECT *lpUnsafeRect, BOOL bErase)
Definition: painting.c:2544
BOOL FASTCALL GreGetTextExtentExW(HDC hDC, LPCWSTR String, ULONG Count, ULONG MaxExtent, PULONG Fit, PULONG Dx, LPSIZE pSize, FLONG fl)
Definition: text.c:135
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
#define CONST
Definition: pedump.c:81
#define DC_TEXT
Definition: winuser.h:430
#define SRCCOPY
Definition: wingdi.h:333
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
base of all file and directory entries
Definition: entries.h:82
#define CS_PARENTDC
Definition: winuser.h:651
#define APIENTRY
Definition: api.h:79
struct Rect Rect
#define DC_DRAWCAPTIONMD
Definition: undocuser.h:150
#define END_CLEANUP
Definition: ntuser.h:6
#define WNDS2_INDESTROY
Definition: ntuser.h:622
char * Text
Definition: combotst.c:136
#define RDW_INVALIDATE
Definition: winuser.h:1200
BOOL UserDrawCaption(PWND pWnd, HDC hDc, RECTL *lpRc, HFONT hFont, HICON hIcon, const PUNICODE_STRING Str, UINT uFlags)
Definition: painting.c:2194
BOOL APIENTRY NtUserDrawCaption(HWND hWnd, HDC hDC, LPCRECT lpRc, UINT uFlags)
Definition: painting.c:2459
INT WINAPI DrawTextW(HDC hdc, LPCWSTR str, INT count, LPRECT rect, UINT flags)
Definition: defwnd.c:17
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:697
PCLS pcls
Definition: ntuser.h:690
DWORD style
Definition: ntuser.h:676
BOOL FASTCALL IntGetWindowRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:120
#define DC_INBUTTON
Definition: winuser.h:431