6a8b2a9bf73c8d161e7bc5adf13e845ad1ae3f4b
[reactos.git] / win32ss / user / ntuser / painting.c
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
12 /* PRIVATE FUNCTIONS **********************************************************/
13
14 /**
15 * @name IntIntersectWithParents
16 *
17 * Intersect window rectangle with all parent client rectangles.
18 *
19 * @param Child
20 * Pointer to child window to start intersecting from.
21 * @param WindowRect
22 * Pointer to rectangle that we want to intersect in screen
23 * coordinates on input and intersected rectangle on output (if TRUE
24 * is returned).
25 *
26 * @return
27 * If any parent is minimized or invisible or the resulting rectangle
28 * is empty then FALSE is returned. Otherwise TRUE is returned.
29 */
30
31 BOOL FASTCALL
32 IntIntersectWithParents(PWND Child, RECTL *WindowRect)
33 {
34 PWND ParentWnd;
35
36 if (Child->ExStyle & WS_EX_REDIRECTED)
37 return TRUE;
38
39 ParentWnd = Child->spwndParent;
40 while (ParentWnd != NULL)
41 {
42 if (!(ParentWnd->style & WS_VISIBLE) ||
43 (ParentWnd->style & WS_MINIMIZE) ||
44 !RECTL_bIntersectRect(WindowRect, WindowRect, &ParentWnd->rcClient) )
45 {
46 return FALSE;
47 }
48
49 if (ParentWnd->ExStyle & WS_EX_REDIRECTED)
50 return TRUE;
51
52 ParentWnd = ParentWnd->spwndParent;
53 }
54
55 return TRUE;
56 }
57
58 BOOL FASTCALL
59 IntValidateParents(PWND Child, BOOL Recurse)
60 {
61 RECTL ParentRect, Rect;
62 BOOL Start, Ret = TRUE;
63 PWND ParentWnd = Child;
64 PREGION Rgn = NULL;
65
66 if (ParentWnd->style & WS_CHILD)
67 {
68 do
69 ParentWnd = ParentWnd->spwndParent;
70 while (ParentWnd->style & WS_CHILD);
71 }
72
73 // No pending nonclient paints.
74 if (!(ParentWnd->state & WNDS_SYNCPAINTPENDING)) Recurse = FALSE;
75
76 Start = TRUE;
77 ParentWnd = Child->spwndParent;
78 while (ParentWnd)
79 {
80 if (ParentWnd->style & WS_CLIPCHILDREN)
81 break;
82
83 if (ParentWnd->hrgnUpdate != 0)
84 {
85 if (Recurse)
86 {
87 Ret = FALSE;
88 break;
89 }
90 // Start with child clipping.
91 if (Start)
92 {
93 Start = FALSE;
94
95 Rect = Child->rcWindow;
96
97 if (!IntIntersectWithParents(Child, &Rect)) break;
98
99 Rgn = IntSysCreateRectpRgnIndirect(&Rect);
100
101 if (Child->hrgnClip)
102 {
103 PREGION RgnClip = REGION_LockRgn(Child->hrgnClip);
104 IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
105 REGION_UnlockRgn(RgnClip);
106 }
107 }
108
109 ParentRect = ParentWnd->rcWindow;
110
111 if (!IntIntersectWithParents(ParentWnd, &ParentRect)) break;
112
113 IntInvalidateWindows( ParentWnd,
114 Rgn,
115 RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOUPDATEDIRTY);
116 }
117 ParentWnd = ParentWnd->spwndParent;
118 }
119
120 if (Rgn) REGION_Delete(Rgn);
121
122 return Ret;
123 }
124
125 /*
126 Synchronize painting to the top-level windows of other threads.
127 */
128 VOID FASTCALL
129 IntSendSyncPaint(PWND Wnd, ULONG Flags)
130 {
131 PTHREADINFO ptiCur, ptiWnd;
132 PUSER_SENT_MESSAGE Message;
133 PLIST_ENTRY Entry;
134 BOOL bSend = TRUE;
135
136 ptiWnd = Wnd->head.pti;
137 ptiCur = PsGetCurrentThreadWin32Thread();
138 /*
139 Not the current thread, Wnd is in send Nonclient paint also in send erase background and it is visiable.
140 */
141 if ( Wnd->head.pti != ptiCur &&
142 Wnd->state & WNDS_SENDNCPAINT &&
143 Wnd->state & WNDS_SENDERASEBACKGROUND &&
144 Wnd->style & WS_VISIBLE)
145 {
146 // For testing, if you see this, break out the Champagne and have a party!
147 TRACE("SendSyncPaint Wnd in State!\n");
148 if (!IsListEmpty(&ptiWnd->SentMessagesListHead))
149 {
150 // Scan sent queue messages to see if we received sync paint messages.
151 Entry = ptiWnd->SentMessagesListHead.Flink;
152 Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
153 do
154 {
155 ERR("LOOP it\n");
156 if (Message->Msg.message == WM_SYNCPAINT &&
157 Message->Msg.hwnd == UserHMGetHandle(Wnd))
158 { // Already received so exit out.
159 ERR("SendSyncPaint Found one in the Sent Msg Queue!\n");
160 bSend = FALSE;
161 break;
162 }
163 Entry = Message->ListEntry.Flink;
164 Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
165 }
166 while (Entry != &ptiWnd->SentMessagesListHead);
167 }
168 if (bSend)
169 {
170 TRACE("Sending WM_SYNCPAINT\n");
171 // This message has no parameters. But it does! Pass Flags along.
172 co_IntSendMessageNoWait(UserHMGetHandle(Wnd), WM_SYNCPAINT, Flags, 0);
173 Wnd->state |= WNDS_SYNCPAINTPENDING;
174 }
175 }
176
177 // Send to all the children if this is the desktop window.
178 if (UserIsDesktopWindow(Wnd))
179 {
180 if ( Flags & RDW_ALLCHILDREN ||
181 ( !(Flags & RDW_NOCHILDREN) && Wnd->style & WS_CLIPCHILDREN))
182 {
183 PWND spwndChild = Wnd->spwndChild;
184 while(spwndChild)
185 {
186 if ( spwndChild->style & WS_CHILD &&
187 spwndChild->head.pti != ptiCur)
188 {
189 spwndChild = spwndChild->spwndNext;
190 continue;
191 }
192 IntSendSyncPaint( spwndChild, Flags );
193 spwndChild = spwndChild->spwndNext;
194 }
195 }
196 }
197 }
198
199 /*
200 * @name IntCalcWindowRgn
201 *
202 * Get a window or client region.
203 */
204
205 HRGN FASTCALL
206 IntCalcWindowRgn(PWND Wnd, BOOL Client)
207 {
208 HRGN hRgnWindow;
209
210 if (Client)
211 {
212 hRgnWindow = NtGdiCreateRectRgn(
213 Wnd->rcClient.left,
214 Wnd->rcClient.top,
215 Wnd->rcClient.right,
216 Wnd->rcClient.bottom);
217 }
218 else
219 {
220 hRgnWindow = NtGdiCreateRectRgn(
221 Wnd->rcWindow.left,
222 Wnd->rcWindow.top,
223 Wnd->rcWindow.right,
224 Wnd->rcWindow.bottom);
225 }
226
227 if (Wnd->hrgnClip != NULL && !(Wnd->style & WS_MINIMIZE))
228 {
229 NtGdiOffsetRgn(hRgnWindow,
230 -Wnd->rcWindow.left,
231 -Wnd->rcWindow.top);
232 NtGdiCombineRgn(hRgnWindow, hRgnWindow, Wnd->hrgnClip, RGN_AND);
233 NtGdiOffsetRgn(hRgnWindow,
234 Wnd->rcWindow.left,
235 Wnd->rcWindow.top);
236 }
237
238 return hRgnWindow;
239 }
240
241 /*
242 * @name IntGetNCUpdateRgn
243 *
244 * Get non-client update region of a window and optionally validate it.
245 *
246 * @param Window
247 * Pointer to window to get the NC update region from.
248 * @param Validate
249 * Set to TRUE to force validating the NC update region.
250 *
251 * @return
252 * Handle to NC update region. The caller is responsible for deleting
253 * it.
254 */
255
256 HRGN FASTCALL
257 IntGetNCUpdateRgn(PWND Window, BOOL Validate)
258 {
259 HRGN hRgnNonClient;
260 HRGN hRgnWindow;
261 UINT RgnType, NcType;
262 RECT update;
263
264 if (Window->hrgnUpdate != NULL &&
265 Window->hrgnUpdate != HRGN_WINDOW)
266 {
267 hRgnNonClient = IntCalcWindowRgn(Window, FALSE);
268
269 /*
270 * If region creation fails it's safe to fallback to whole
271 * window region.
272 */
273 if (hRgnNonClient == NULL)
274 {
275 return HRGN_WINDOW;
276 }
277
278 hRgnWindow = IntCalcWindowRgn(Window, TRUE);
279 if (hRgnWindow == NULL)
280 {
281 GreDeleteObject(hRgnNonClient);
282 return HRGN_WINDOW;
283 }
284
285 NcType = IntGdiGetRgnBox(hRgnNonClient, &update);
286
287 RgnType = NtGdiCombineRgn(hRgnNonClient, hRgnNonClient, hRgnWindow, RGN_DIFF);
288
289 if (RgnType == ERROR)
290 {
291 GreDeleteObject(hRgnWindow);
292 GreDeleteObject(hRgnNonClient);
293 return HRGN_WINDOW;
294 }
295 else if (RgnType == NULLREGION)
296 {
297 GreDeleteObject(hRgnWindow);
298 GreDeleteObject(hRgnNonClient);
299 Window->state &= ~WNDS_UPDATEDIRTY;
300 return NULL;
301 }
302
303 /*
304 * Remove the nonclient region from the standard update region if
305 * we were asked for it.
306 */
307
308 if (Validate)
309 {
310 if (NtGdiCombineRgn(Window->hrgnUpdate, Window->hrgnUpdate, hRgnWindow, RGN_AND) == NULLREGION)
311 {
312 IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
313 GreDeleteObject(Window->hrgnUpdate);
314 Window->state &= ~WNDS_UPDATEDIRTY;
315 Window->hrgnUpdate = NULL;
316 if (!(Window->state & WNDS_INTERNALPAINT))
317 MsqDecPaintCountQueue(Window->head.pti);
318 }
319 }
320
321 /* check if update rgn contains complete nonclient area */
322 if (NcType == SIMPLEREGION)
323 {
324 RECT window;
325 IntGetWindowRect( Window, &window );
326
327 if (IntEqualRect( &window, &update ))
328 {
329 GreDeleteObject(hRgnNonClient);
330 hRgnNonClient = HRGN_WINDOW;
331 }
332 }
333
334 GreDeleteObject(hRgnWindow);
335
336 return hRgnNonClient;
337 }
338 else
339 {
340 return Window->hrgnUpdate;
341 }
342 }
343
344 VOID FASTCALL
345 IntSendNCPaint(PWND pWnd, HRGN hRgn)
346 {
347 pWnd->state &= ~WNDS_SENDNCPAINT;
348
349 if ( pWnd == GetW32ThreadInfo()->MessageQueue->spwndActive &&
350 !(pWnd->state & WNDS_ACTIVEFRAME))
351 {
352 pWnd->state |= WNDS_ACTIVEFRAME;
353 pWnd->state &= ~WNDS_NONCPAINT;
354 hRgn = HRGN_WINDOW;
355 }
356
357 if (pWnd->state2 & WNDS2_FORCEFULLNCPAINTCLIPRGN)
358 {
359 pWnd->state2 &= ~WNDS2_FORCEFULLNCPAINTCLIPRGN;
360 hRgn = HRGN_WINDOW;
361 }
362
363 if (hRgn) co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCPAINT, (WPARAM)hRgn, 0);
364 }
365
366 VOID FASTCALL
367 IntSendChildNCPaint(PWND pWnd)
368 {
369 for (pWnd = pWnd->spwndChild; pWnd; pWnd = pWnd->spwndNext)
370 {
371 if ((pWnd->hrgnUpdate == NULL) && (pWnd->state & WNDS_SENDNCPAINT))
372 {
373 USER_REFERENCE_ENTRY Ref;
374 UserRefObjectCo(pWnd, &Ref);
375 IntSendNCPaint(pWnd, HRGN_WINDOW);
376 UserDerefObjectCo(pWnd);
377 }
378 }
379 }
380
381 /*
382 * IntPaintWindows
383 *
384 * Internal function used by IntRedrawWindow.
385 */
386
387 VOID FASTCALL
388 co_IntPaintWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
389 {
390 HDC hDC;
391 HWND hWnd = Wnd->head.h;
392 HRGN TempRegion = NULL;
393
394 Wnd->state &= ~WNDS_PAINTNOTPROCESSED;
395
396 if (Wnd->state & WNDS_SENDNCPAINT ||
397 Wnd->state & WNDS_SENDERASEBACKGROUND)
398 {
399 if (!(Wnd->style & WS_VISIBLE))
400 {
401 Wnd->state &= ~(WNDS_SENDNCPAINT|WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
402 return;
403 }
404 else
405 {
406 if (Wnd->hrgnUpdate == NULL)
407 {
408 Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
409 }
410
411 if (Wnd->head.pti == PsGetCurrentThreadWin32Thread())
412 {
413 if (Wnd->state & WNDS_SENDNCPAINT)
414 {
415 TempRegion = IntGetNCUpdateRgn(Wnd, TRUE);
416
417 IntSendNCPaint(Wnd, TempRegion);
418
419 if (TempRegion > HRGN_WINDOW && GreIsHandleValid(TempRegion))
420 {
421 /* NOTE: The region can already be deleted! */
422 GreDeleteObject(TempRegion);
423 }
424 }
425
426 if (Wnd->state & WNDS_SENDERASEBACKGROUND)
427 {
428 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
429 if (Wnd->hrgnUpdate)
430 {
431 hDC = UserGetDCEx( Wnd,
432 Wnd->hrgnUpdate,
433 DCX_CACHE|DCX_USESTYLE|DCX_INTERSECTRGN|DCX_KEEPCLIPRGN);
434
435 if (Wnd->head.pti->ppi != pti->ppi)
436 {
437 ERR("Sending DC to another Process!!!\n");
438 }
439
440 Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
441 // Kill the loop, so Clear before we send.
442 if (!co_IntSendMessage(hWnd, WM_ERASEBKGND, (WPARAM)hDC, 0))
443 {
444 Wnd->state |= (WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
445 }
446 UserReleaseDC(Wnd, hDC, FALSE);
447 }
448 }
449 }
450
451 }
452 }
453
454 /*
455 * Check that the window is still valid at this point
456 */
457 if (!IntIsWindow(hWnd))
458 {
459 return;
460 }
461
462 /*
463 * Paint child windows.
464 */
465
466 if (!(Flags & RDW_NOCHILDREN) &&
467 !(Wnd->style & WS_MINIMIZE) &&
468 ( Flags & RDW_ALLCHILDREN ||
469 (Flags & RDW_CLIPCHILDREN && Wnd->style & WS_CLIPCHILDREN) ) )
470 {
471 HWND *List, *phWnd;
472 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
473
474 if ((List = IntWinListChildren(Wnd)))
475 {
476 for (phWnd = List; *phWnd; ++phWnd)
477 {
478 if ((Wnd = UserGetWindowObject(*phWnd)) == NULL)
479 continue;
480
481 if (Wnd->head.pti != pti && Wnd->style & WS_CHILD)
482 continue;
483
484 if (Wnd->style & WS_VISIBLE)
485 {
486 USER_REFERENCE_ENTRY Ref;
487 UserRefObjectCo(Wnd, &Ref);
488 co_IntPaintWindows(Wnd, Flags, TRUE);
489 UserDerefObjectCo(Wnd);
490 }
491 }
492 ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
493 }
494 }
495 }
496
497 /*
498 * IntUpdateWindows
499 *
500 * Internal function used by IntRedrawWindow, simplecall.
501 */
502
503 VOID FASTCALL
504 co_IntUpdateWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
505 {
506 HWND hWnd = Wnd->head.h;
507
508 if ( Wnd->hrgnUpdate != NULL || Wnd->state & WNDS_INTERNALPAINT )
509 {
510 if (Wnd->hrgnUpdate)
511 {
512 if (!IntValidateParents(Wnd, Recurse))
513 {
514 return;
515 }
516 }
517
518 if (Wnd->state & WNDS_INTERNALPAINT)
519 {
520 Wnd->state &= ~WNDS_INTERNALPAINT;
521
522 if (Wnd->hrgnUpdate == NULL)
523 MsqDecPaintCountQueue(Wnd->head.pti);
524 }
525
526 Wnd->state |= WNDS_PAINTNOTPROCESSED;
527 Wnd->state &= ~WNDS_UPDATEDIRTY;
528
529 Wnd->state2 |= WNDS2_WMPAINTSENT;
530 co_IntSendMessage(hWnd, WM_PAINT, 0, 0);
531
532 if (Wnd->state & WNDS_PAINTNOTPROCESSED)
533 {
534 USER_REFERENCE_ENTRY Ref;
535 UserRefObjectCo(Wnd, &Ref);
536 co_IntPaintWindows(Wnd, RDW_NOCHILDREN, FALSE);
537 UserDerefObjectCo(Wnd);
538 }
539 }
540
541 // Force flags as a toggle. Fixes msg:test_paint_messages:WmChildPaintNc.
542 Flags = (Flags & RDW_NOCHILDREN) ? RDW_NOCHILDREN : RDW_ALLCHILDREN; // All children is the default.
543
544 /*
545 * Update child windows.
546 */
547
548 if (!(Flags & RDW_NOCHILDREN) &&
549 (Flags & RDW_ALLCHILDREN) &&
550 !UserIsDesktopWindow(Wnd))
551 {
552 PWND Child;
553
554 for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
555 {
556 /* transparent window, check for non-transparent sibling to paint first, then skip it */
557 if ( Child->ExStyle & WS_EX_TRANSPARENT &&
558 ( Child->hrgnUpdate != NULL || Child->state & WNDS_INTERNALPAINT ) )
559 {
560 PWND Next = Child->spwndNext;
561 while (Next)
562 {
563 if ( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT ) break;
564
565 Next = Next->spwndNext;
566 }
567
568 if (Next) continue;
569 }
570
571 if (Child->style & WS_VISIBLE)
572 {
573 USER_REFERENCE_ENTRY Ref;
574 UserRefObjectCo(Child, &Ref);
575 co_IntUpdateWindows(Child, Flags, TRUE);
576 UserDerefObjectCo(Child);
577 }
578 }
579 }
580 }
581
582 VOID FASTCALL
583 UserUpdateWindows(PWND pWnd, ULONG Flags)
584 {
585 // If transparent and any sibling windows below needs to be painted, leave.
586 if (pWnd->ExStyle & WS_EX_TRANSPARENT)
587 {
588 PWND Next = pWnd->spwndNext;
589
590 while(Next)
591 {
592 if ( Next->head.pti == pWnd->head.pti &&
593 ( Next->hrgnUpdate != NULL || Next->state & WNDS_INTERNALPAINT) )
594 {
595 return;
596 }
597
598 Next = Next->spwndNext;
599 }
600 }
601 co_IntUpdateWindows(pWnd, Flags, FALSE);
602 }
603
604 VOID FASTCALL
605 UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
606 {
607 PWND Parent = pWnd;
608 // Find parent, if it needs to be painted, leave.
609 while(TRUE)
610 {
611 if ((Parent = Parent->spwndParent) == NULL) break;
612 if ( Parent->style & WS_CLIPCHILDREN ) break;
613 if ( Parent->hrgnUpdate != NULL || Parent->state & WNDS_INTERNALPAINT ) return;
614 }
615
616 IntSendSyncPaint(pWnd, Flags);
617 co_IntPaintWindows(pWnd, Flags, FALSE);
618 }
619
620 /*
621 * IntInvalidateWindows
622 *
623 * Internal function used by IntRedrawWindow, UserRedrawDesktop,
624 * co_WinPosSetWindowPos, co_UserRedrawWindow.
625 */
626 VOID FASTCALL
627 IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
628 {
629 INT RgnType = NULLREGION;
630 BOOL HadPaintMessage;
631
632 TRACE("IntInvalidateWindows start Rgn %p\n",Rgn);
633
634 if ( Rgn > PRGN_WINDOW )
635 {
636 /*
637 * If the nonclient is not to be redrawn, clip the region to the client
638 * rect
639 */
640 if ((Flags & RDW_INVALIDATE) != 0 && (Flags & RDW_FRAME) == 0)
641 {
642 PREGION RgnClient;
643
644 RgnClient = IntSysCreateRectpRgnIndirect(&Wnd->rcClient);
645 if (RgnClient)
646 {
647 RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClient, RGN_AND);
648 REGION_Delete(RgnClient);
649 }
650 }
651
652 /*
653 * Clip the given region with window rectangle (or region)
654 */
655
656 if (!Wnd->hrgnClip || (Wnd->style & WS_MINIMIZE))
657 {
658 PREGION RgnWindow = IntSysCreateRectpRgnIndirect(&Wnd->rcWindow);
659 if (RgnWindow)
660 {
661 RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnWindow, RGN_AND);
662 REGION_Delete(RgnWindow);
663 }
664 }
665 else
666 {
667 PREGION RgnClip = REGION_LockRgn(Wnd->hrgnClip);
668 if (RgnClip)
669 {
670 REGION_bOffsetRgn(Rgn,
671 -Wnd->rcWindow.left,
672 -Wnd->rcWindow.top);
673 RgnType = IntGdiCombineRgn(Rgn, Rgn, RgnClip, RGN_AND);
674 REGION_bOffsetRgn(Rgn,
675 Wnd->rcWindow.left,
676 Wnd->rcWindow.top);
677 REGION_UnlockRgn(RgnClip);
678 }
679 }
680 }
681 else
682 {
683 RgnType = NULLREGION;
684 }
685
686 /*
687 * Save current state of pending updates
688 */
689
690 HadPaintMessage = IntIsWindowDirty(Wnd);
691
692 /*
693 * Update the region and flags
694 */
695
696 // The following flags are used to invalidate the window.
697 if (Flags & (RDW_INVALIDATE|RDW_INTERNALPAINT|RDW_ERASE|RDW_FRAME))
698 {
699 if (Flags & RDW_INTERNALPAINT)
700 {
701 Wnd->state |= WNDS_INTERNALPAINT;
702 }
703
704 if (Flags & RDW_INVALIDATE )
705 {
706 PREGION RgnUpdate;
707
708 Wnd->state &= ~WNDS_NONCPAINT;
709
710 /* If not the same thread set it dirty. */
711 if (Wnd->head.pti != PsGetCurrentThreadWin32Thread())
712 {
713 Wnd->state |= WNDS_UPDATEDIRTY;
714 if (Wnd->state2 & WNDS2_WMPAINTSENT)
715 Wnd->state2 |= WNDS2_ENDPAINTINVALIDATE;
716 }
717
718 if (Flags & RDW_FRAME)
719 Wnd->state |= WNDS_SENDNCPAINT;
720
721 if (Flags & RDW_ERASE)
722 Wnd->state |= WNDS_SENDERASEBACKGROUND;
723
724 if (RgnType != NULLREGION && Rgn > PRGN_WINDOW)
725 {
726 if (Wnd->hrgnUpdate == NULL)
727 {
728 Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
729 IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_PUBLIC);
730 }
731
732 if (Wnd->hrgnUpdate != HRGN_WINDOW)
733 {
734 RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
735 if (RgnUpdate)
736 {
737 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_OR);
738 REGION_UnlockRgn(RgnUpdate);
739 if (RgnType == NULLREGION)
740 {
741 IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
742 GreDeleteObject(Wnd->hrgnUpdate);
743 Wnd->hrgnUpdate = NULL;
744 }
745 }
746 }
747 }
748
749 Flags |= RDW_ERASE|RDW_FRAME; // For children.
750
751 }
752
753 if (!HadPaintMessage && IntIsWindowDirty(Wnd))
754 {
755 MsqIncPaintCountQueue(Wnd->head.pti);
756 }
757
758 } // The following flags are used to validate the window.
759 else if (Flags & (RDW_VALIDATE|RDW_NOINTERNALPAINT|RDW_NOERASE|RDW_NOFRAME))
760 {
761 if (Wnd->state & WNDS_UPDATEDIRTY && !(Flags & RDW_NOUPDATEDIRTY))
762 return;
763
764 if (Flags & RDW_NOINTERNALPAINT)
765 {
766 Wnd->state &= ~WNDS_INTERNALPAINT;
767 }
768
769 if (Flags & RDW_VALIDATE)
770 {
771 if (Flags & RDW_NOFRAME)
772 Wnd->state &= ~WNDS_SENDNCPAINT;
773
774 if (Flags & RDW_NOERASE)
775 Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
776
777 if (Wnd->hrgnUpdate > HRGN_WINDOW && RgnType != NULLREGION && Rgn > PRGN_WINDOW)
778 {
779 PREGION RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
780
781 if (RgnUpdate)
782 {
783 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, Rgn, RGN_DIFF);
784 REGION_UnlockRgn(RgnUpdate);
785
786 if (RgnType == NULLREGION)
787 {
788 IntGdiSetRegionOwner(Wnd->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
789 GreDeleteObject(Wnd->hrgnUpdate);
790 Wnd->hrgnUpdate = NULL;
791 }
792 }
793 }
794 // If update is null, do not erase.
795 if (Wnd->hrgnUpdate == NULL)
796 {
797 Wnd->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
798 }
799 }
800
801 if (HadPaintMessage && !IntIsWindowDirty(Wnd))
802 {
803 MsqDecPaintCountQueue(Wnd->head.pti);
804 }
805 }
806
807 /*
808 * Process children if needed
809 */
810
811 if (!(Flags & RDW_NOCHILDREN) &&
812 !(Wnd->style & WS_MINIMIZE) &&
813 ((Flags & RDW_ALLCHILDREN) || !(Wnd->style & WS_CLIPCHILDREN)))
814 {
815 PWND Child;
816
817 for (Child = Wnd->spwndChild; Child; Child = Child->spwndNext)
818 {
819 if (Child->style & WS_VISIBLE)
820 {
821 /*
822 * Recursive call to update children hrgnUpdate
823 */
824 PREGION RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
825 if (RgnTemp)
826 {
827 if (Rgn > PRGN_WINDOW) IntGdiCombineRgn(RgnTemp, Rgn, 0, RGN_COPY);
828 IntInvalidateWindows(Child, ((Rgn > PRGN_WINDOW)?RgnTemp:Rgn), Flags);
829 REGION_Delete(RgnTemp);
830 }
831 }
832 }
833 }
834 TRACE("IntInvalidateWindows exit\n");
835 }
836
837 /*
838 * IntIsWindowDrawable
839 *
840 * Remarks
841 * Window is drawable when it is visible and all parents are not
842 * minimized.
843 */
844
845 BOOL FASTCALL
846 IntIsWindowDrawable(PWND Wnd)
847 {
848 PWND WndObject;
849
850 for (WndObject = Wnd; WndObject != NULL; WndObject = WndObject->spwndParent)
851 {
852 if ( WndObject->state2 & WNDS2_INDESTROY ||
853 WndObject->state & WNDS_DESTROYED ||
854 !WndObject ||
855 !(WndObject->style & WS_VISIBLE) ||
856 ((WndObject->style & WS_MINIMIZE) && (WndObject != Wnd)))
857 {
858 return FALSE;
859 }
860 }
861
862 return TRUE;
863 }
864
865 /*
866 * IntRedrawWindow
867 *
868 * Internal version of NtUserRedrawWindow that takes WND as
869 * first parameter.
870 */
871
872 BOOL FASTCALL
873 co_UserRedrawWindow(
874 PWND Window,
875 const RECTL* UpdateRect,
876 PREGION UpdateRgn,
877 ULONG Flags)
878 {
879 PREGION TmpRgn = NULL;
880 TRACE("co_UserRedrawWindow start Rgn %p\n",UpdateRgn);
881
882 /*
883 * Step 1.
884 * Validation of passed parameters.
885 */
886
887 if (!IntIsWindowDrawable(Window))
888 {
889 return TRUE; // Just do nothing!!!
890 }
891
892 if (Window == NULL)
893 {
894 Window = UserGetDesktopWindow();
895 }
896
897 /*
898 * Step 2.
899 * Transform the parameters UpdateRgn and UpdateRect into
900 * a region hRgn specified in screen coordinates.
901 */
902
903 if (Flags & (RDW_INVALIDATE | RDW_VALIDATE)) // Both are OKAY!
904 {
905 /* We can't hold lock on GDI objects while doing roundtrips to user mode,
906 * so use a copy instead */
907 if (UpdateRgn)
908 {
909 TmpRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
910
911 if (UpdateRgn > PRGN_WINDOW)
912 {
913 IntGdiCombineRgn(TmpRgn, UpdateRgn, NULL, RGN_COPY);
914 }
915
916 if (Window != UserGetDesktopWindow())
917 {
918 REGION_bOffsetRgn(TmpRgn, Window->rcClient.left, Window->rcClient.top);
919 }
920 }
921 else
922 {
923 if (UpdateRect != NULL)
924 {
925 if (Window == UserGetDesktopWindow())
926 {
927 TmpRgn = IntSysCreateRectpRgnIndirect(UpdateRect);
928 }
929 else
930 {
931 TmpRgn = IntSysCreateRectpRgn(Window->rcClient.left + UpdateRect->left,
932 Window->rcClient.top + UpdateRect->top,
933 Window->rcClient.left + UpdateRect->right,
934 Window->rcClient.top + UpdateRect->bottom);
935 }
936 }
937 else
938 {
939 if ((Flags & (RDW_INVALIDATE | RDW_FRAME)) == (RDW_INVALIDATE | RDW_FRAME) ||
940 (Flags & (RDW_VALIDATE | RDW_NOFRAME)) == (RDW_VALIDATE | RDW_NOFRAME))
941 {
942 if (!RECTL_bIsEmptyRect(&Window->rcWindow))
943 TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcWindow);
944 }
945 else
946 {
947 if (!RECTL_bIsEmptyRect(&Window->rcClient))
948 TmpRgn = IntSysCreateRectpRgnIndirect(&Window->rcClient);
949 }
950 }
951 }
952 }
953
954 /* Fixes test RDW_INTERNALPAINT behavior */
955 if (TmpRgn == NULL)
956 {
957 TmpRgn = PRGN_WINDOW; // Need a region so the bits can be set!!!
958 }
959
960 /*
961 * Step 3.
962 * Adjust the window update region depending on hRgn and flags.
963 */
964
965 if (Flags & (RDW_INVALIDATE | RDW_VALIDATE | RDW_INTERNALPAINT | RDW_NOINTERNALPAINT) &&
966 TmpRgn != NULL)
967 {
968 IntInvalidateWindows(Window, TmpRgn, Flags);
969 }
970
971 /*
972 * Step 4.
973 * Repaint and erase windows if needed.
974 */
975
976 if (Flags & RDW_UPDATENOW)
977 {
978 UserUpdateWindows(Window, Flags);
979 }
980 else if (Flags & RDW_ERASENOW)
981 {
982 if ((Flags & (RDW_NOCHILDREN|RDW_ALLCHILDREN)) == 0)
983 Flags |= RDW_CLIPCHILDREN;
984
985 UserSyncAndPaintWindows(Window, Flags);
986 }
987
988 /*
989 * Step 5.
990 * Cleanup ;-)
991 */
992
993 if (TmpRgn > PRGN_WINDOW)
994 {
995 REGION_Delete(TmpRgn);
996 }
997 TRACE("co_UserRedrawWindow exit\n");
998
999 return TRUE;
1000 }
1001
1002 VOID FASTCALL
1003 PaintSuspendedWindow(PWND pwnd, HRGN hrgnOrig)
1004 {
1005 if (pwnd->hrgnUpdate)
1006 {
1007 HDC hDC;
1008 INT Flags = DC_NC|DC_NOSENDMSG;
1009 HRGN hrgnTemp;
1010 RECT Rect;
1011 INT type;
1012 PREGION prgn;
1013
1014 if (pwnd->hrgnUpdate > HRGN_WINDOW)
1015 {
1016 hrgnTemp = NtGdiCreateRectRgn(0, 0, 0, 0);
1017 type = NtGdiCombineRgn( hrgnTemp, pwnd->hrgnUpdate, 0, RGN_COPY);
1018 if (type == ERROR)
1019 {
1020 GreDeleteObject(hrgnTemp);
1021 hrgnTemp = HRGN_WINDOW;
1022 }
1023 }
1024 else
1025 {
1026 hrgnTemp = GreCreateRectRgnIndirect(&pwnd->rcWindow);
1027 }
1028
1029 if ( hrgnOrig &&
1030 hrgnTemp > HRGN_WINDOW &&
1031 NtGdiCombineRgn(hrgnTemp, hrgnTemp, hrgnOrig, RGN_AND) == NULLREGION)
1032 {
1033 GreDeleteObject(hrgnTemp);
1034 return;
1035 }
1036
1037 hDC = UserGetDCEx(pwnd, hrgnTemp, DCX_WINDOW|DCX_INTERSECTRGN|DCX_USESTYLE|DCX_KEEPCLIPRGN);
1038
1039 Rect = pwnd->rcWindow;
1040 RECTL_vOffsetRect(&Rect, -pwnd->rcWindow.left, -pwnd->rcWindow.top);
1041
1042 // Clear out client area!
1043 FillRect(hDC, &Rect, IntGetSysColorBrush(COLOR_WINDOW));
1044
1045 NC_DoNCPaint(pwnd, hDC, Flags); // Redraw without MENUs.
1046
1047 UserReleaseDC(pwnd, hDC, FALSE);
1048
1049 prgn = REGION_LockRgn(hrgnTemp);
1050 IntInvalidateWindows(pwnd, prgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ALLCHILDREN);
1051 REGION_UnlockRgn(prgn);
1052
1053 // Set updates for this window.
1054 pwnd->state |= WNDS_SENDNCPAINT|WNDS_SENDERASEBACKGROUND|WNDS_UPDATEDIRTY;
1055
1056 // DCX_KEEPCLIPRGN is set. Check it anyway.
1057 if (hrgnTemp > HRGN_WINDOW && GreIsHandleValid(hrgnTemp)) GreDeleteObject(hrgnTemp);
1058 }
1059 }
1060
1061 VOID FASTCALL
1062 UpdateTheadChildren(PWND pWnd, HRGN hRgn)
1063 {
1064 PaintSuspendedWindow( pWnd, hRgn );
1065
1066 if (!(pWnd->style & WS_CLIPCHILDREN))
1067 return;
1068
1069 pWnd = pWnd->spwndChild; // invalidate children if any.
1070 while (pWnd)
1071 {
1072 UpdateTheadChildren( pWnd, hRgn );
1073 pWnd = pWnd->spwndNext;
1074 }
1075 }
1076
1077 VOID FASTCALL
1078 UpdateThreadWindows(PWND pWnd, PTHREADINFO pti, HRGN hRgn)
1079 {
1080 PWND pwndTemp;
1081
1082 for ( pwndTemp = pWnd;
1083 pwndTemp;
1084 pwndTemp = pwndTemp->spwndNext )
1085 {
1086 if (pwndTemp->head.pti == pti)
1087 {
1088 UserUpdateWindows(pwndTemp, RDW_ALLCHILDREN);
1089 }
1090 else
1091 {
1092 if (IsThreadSuspended(pwndTemp->head.pti) || MsqIsHung(pwndTemp->head.pti))
1093 {
1094 UpdateTheadChildren(pwndTemp, hRgn);
1095 }
1096 else
1097 UserUpdateWindows(pwndTemp, RDW_ALLCHILDREN);
1098 }
1099 }
1100 }
1101
1102 BOOL FASTCALL
1103 IntIsWindowDirty(PWND Wnd)
1104 {
1105 return ( Wnd->style & WS_VISIBLE &&
1106 ( Wnd->hrgnUpdate != NULL ||
1107 Wnd->state & WNDS_INTERNALPAINT ) );
1108 }
1109
1110 /*
1111 Conditions to paint any window:
1112
1113 1. Update region is not null.
1114 2. Internal paint flag is set.
1115 3. Paint count is not zero.
1116
1117 */
1118 PWND FASTCALL
1119 IntFindWindowToRepaint(PWND Window, PTHREADINFO Thread)
1120 {
1121 PWND hChild;
1122 PWND TempWindow;
1123
1124 for (; Window != NULL; Window = Window->spwndNext)
1125 {
1126 if (IntWndBelongsToThread(Window, Thread))
1127 {
1128 if (IntIsWindowDirty(Window))
1129 {
1130 /* Make sure all non-transparent siblings are already drawn. */
1131 if (Window->ExStyle & WS_EX_TRANSPARENT)
1132 {
1133 for (TempWindow = Window->spwndNext; TempWindow != NULL;
1134 TempWindow = TempWindow->spwndNext)
1135 {
1136 if (!(TempWindow->ExStyle & WS_EX_TRANSPARENT) &&
1137 IntWndBelongsToThread(TempWindow, Thread) &&
1138 IntIsWindowDirty(TempWindow))
1139 {
1140 return TempWindow;
1141 }
1142 }
1143 }
1144 return Window;
1145 }
1146 }
1147 /* find a child of the specified window that needs repainting */
1148 if (Window->spwndChild)
1149 {
1150 hChild = IntFindWindowToRepaint(Window->spwndChild, Thread);
1151 if (hChild != NULL)
1152 return hChild;
1153 }
1154 }
1155 return Window;
1156 }
1157
1158 //
1159 // Internal painting of windows.
1160 //
1161 VOID FASTCALL
1162 IntPaintWindow( PWND Window )
1163 {
1164 // Handle normal painting.
1165 co_IntPaintWindows( Window, RDW_NOCHILDREN, FALSE );
1166 }
1167
1168 BOOL FASTCALL
1169 IntGetPaintMessage(
1170 PWND Window,
1171 UINT MsgFilterMin,
1172 UINT MsgFilterMax,
1173 PTHREADINFO Thread,
1174 MSG *Message,
1175 BOOL Remove)
1176 {
1177 PWND PaintWnd, StartWnd;
1178
1179 if ((MsgFilterMin != 0 || MsgFilterMax != 0) &&
1180 (MsgFilterMin > WM_PAINT || MsgFilterMax < WM_PAINT))
1181 return FALSE;
1182
1183 if (Thread->TIF_flags & TIF_SYSTEMTHREAD )
1184 {
1185 ERR("WM_PAINT is in a System Thread!\n");
1186 }
1187
1188 StartWnd = UserGetDesktopWindow();
1189 PaintWnd = IntFindWindowToRepaint(StartWnd, Thread);
1190
1191 Message->hwnd = PaintWnd ? UserHMGetHandle(PaintWnd) : NULL;
1192
1193 if (Message->hwnd == NULL && Thread->cPaintsReady)
1194 {
1195 // Find note in window.c:"PAINTING BUG".
1196 ERR("WARNING SOMETHING HAS GONE WRONG: Thread marked as containing dirty windows, but no dirty windows found! Counts %u\n",Thread->cPaintsReady);
1197 /* Hack to stop spamming the debug log ! */
1198 Thread->cPaintsReady = 0;
1199 return FALSE;
1200 }
1201
1202 if (Message->hwnd == NULL)
1203 return FALSE;
1204
1205 if (!(Window == NULL ||
1206 PaintWnd == Window ||
1207 IntIsChildWindow(Window, PaintWnd))) /* check that it is a child of the specified parent */
1208 return FALSE;
1209
1210 if (PaintWnd->state & WNDS_INTERNALPAINT)
1211 {
1212 PaintWnd->state &= ~WNDS_INTERNALPAINT;
1213 if (!PaintWnd->hrgnUpdate)
1214 MsqDecPaintCountQueue(Thread);
1215 }
1216 PaintWnd->state2 &= ~WNDS2_STARTPAINT;
1217 PaintWnd->state &= ~WNDS_UPDATEDIRTY;
1218
1219 Window = PaintWnd;
1220 while (Window && !UserIsDesktopWindow(Window))
1221 {
1222 // Role back and check for clip children, do not set if any.
1223 if (Window->spwndParent && !(Window->spwndParent->style & WS_CLIPCHILDREN))
1224 {
1225 PaintWnd->state2 |= WNDS2_WMPAINTSENT;
1226 }
1227 Window = Window->spwndParent;
1228 }
1229
1230 Message->wParam = Message->lParam = 0;
1231 Message->message = WM_PAINT;
1232 return TRUE;
1233 }
1234
1235 BOOL
1236 FASTCALL
1237 IntPrintWindow(
1238 PWND pwnd,
1239 HDC hdcBlt,
1240 UINT nFlags)
1241 {
1242 HDC hdcSrc;
1243 INT cx, cy, xSrc, ySrc;
1244
1245 if ( nFlags & PW_CLIENTONLY)
1246 {
1247 cx = pwnd->rcClient.right - pwnd->rcClient.left;
1248 cy = pwnd->rcClient.bottom - pwnd->rcClient.top;
1249 xSrc = pwnd->rcClient.left - pwnd->rcWindow.left;
1250 ySrc = pwnd->rcClient.top - pwnd->rcWindow.top;
1251 }
1252 else
1253 {
1254 cx = pwnd->rcWindow.right - pwnd->rcWindow.left;
1255 cy = pwnd->rcWindow.bottom - pwnd->rcWindow.top;
1256 xSrc = 0;
1257 ySrc = 0;
1258 }
1259
1260 // TODO: Setup Redirection for Print.
1261 return FALSE;
1262
1263 /* Update the window just incase. */
1264 co_IntUpdateWindows( pwnd, RDW_ALLCHILDREN, FALSE);
1265
1266 hdcSrc = UserGetDCEx( pwnd, NULL, DCX_CACHE|DCX_WINDOW);
1267 /* Print window to printer context. */
1268 NtGdiBitBlt( hdcBlt,
1269 0,
1270 0,
1271 cx,
1272 cy,
1273 hdcSrc,
1274 xSrc,
1275 ySrc,
1276 SRCCOPY,
1277 0,
1278 0);
1279
1280 UserReleaseDC( pwnd, hdcSrc, FALSE);
1281
1282 // TODO: Release Redirection from Print.
1283
1284 return TRUE;
1285 }
1286
1287 BOOL
1288 FASTCALL
1289 IntFlashWindowEx(PWND pWnd, PFLASHWINFO pfwi)
1290 {
1291 DWORD_PTR FlashState;
1292 UINT uCount = pfwi->uCount;
1293 BOOL Activate = FALSE, Ret = FALSE;
1294
1295 ASSERT(pfwi);
1296
1297 FlashState = (DWORD_PTR)UserGetProp(pWnd, AtomFlashWndState, TRUE);
1298
1299 if (FlashState == FLASHW_FINISHED)
1300 {
1301 // Cycle has finished, kill timer and set this to Stop.
1302 FlashState |= FLASHW_KILLSYSTIMER;
1303 pfwi->dwFlags = FLASHW_STOP;
1304 }
1305 else
1306 {
1307 if (FlashState)
1308 {
1309 if (pfwi->dwFlags == FLASHW_SYSTIMER)
1310 {
1311 // Called from system timer, restore flags, counts and state.
1312 pfwi->dwFlags = LOWORD(FlashState);
1313 uCount = HIWORD(FlashState);
1314 FlashState = MAKELONG(LOWORD(FlashState),0);
1315 }
1316 else
1317 {
1318 // Clean out the trash! Fix SeaMonkey crash after restart.
1319 FlashState = 0;
1320 }
1321 }
1322
1323 if (FlashState == 0)
1324 { // First time in cycle, setup flash state.
1325 if ( pWnd->state & WNDS_ACTIVEFRAME ||
1326 (pfwi->dwFlags & FLASHW_CAPTION && pWnd->style & (WS_BORDER|WS_DLGFRAME)))
1327 {
1328 FlashState = FLASHW_STARTED|FLASHW_ACTIVE;
1329 }
1330 }
1331
1332 // Set previous window state.
1333 Ret = !!(FlashState & FLASHW_ACTIVE);
1334
1335 if ( (pfwi->dwFlags & FLASHW_TIMERNOFG) == FLASHW_TIMERNOFG &&
1336 gpqForeground == pWnd->head.pti->MessageQueue )
1337 {
1338 // Flashing until foreground, set this to Stop.
1339 pfwi->dwFlags = FLASHW_STOP;
1340 }
1341 }
1342
1343 // Toggle activate flag.
1344 if ( pfwi->dwFlags == FLASHW_STOP )
1345 {
1346 if (gpqForeground && gpqForeground->spwndActive == pWnd)
1347 Activate = TRUE;
1348 else
1349 Activate = FALSE;
1350 }
1351 else
1352 {
1353 Activate = (FlashState & FLASHW_ACTIVE) == 0;
1354 }
1355
1356 if ( pfwi->dwFlags == FLASHW_STOP || pfwi->dwFlags & FLASHW_CAPTION )
1357 {
1358 co_IntSendMessage(UserHMGetHandle(pWnd), WM_NCACTIVATE, Activate, 0);
1359 }
1360
1361 // FIXME: Check for a Stop Sign here.
1362 if ( pfwi->dwFlags & FLASHW_TRAY )
1363 {
1364 // Need some shell work here too.
1365 TRACE("FIXME: Flash window no Tray support!\n");
1366 }
1367
1368 if ( pfwi->dwFlags == FLASHW_STOP )
1369 {
1370 if (FlashState & FLASHW_KILLSYSTIMER)
1371 {
1372 IntKillTimer(pWnd, ID_EVENT_SYSTIMER_FLASHWIN, TRUE);
1373 }
1374
1375 UserRemoveProp(pWnd, AtomFlashWndState, TRUE);
1376 }
1377 else
1378 { // Have a count and started, set timer.
1379 if ( uCount )
1380 {
1381 FlashState |= FLASHW_COUNT;
1382
1383 if (!(Activate ^ !!(FlashState & FLASHW_STARTED)))
1384 uCount--;
1385
1386 if (!(FlashState & FLASHW_KILLSYSTIMER))
1387 pfwi->dwFlags |= FLASHW_TIMER;
1388 }
1389
1390 if (pfwi->dwFlags & FLASHW_TIMER)
1391 {
1392 FlashState |= FLASHW_KILLSYSTIMER;
1393
1394 IntSetTimer( pWnd,
1395 ID_EVENT_SYSTIMER_FLASHWIN,
1396 pfwi->dwTimeout ? pfwi->dwTimeout : gpsi->dtCaretBlink,
1397 SystemTimerProc,
1398 TMRF_SYSTEM );
1399 }
1400
1401 if (FlashState & FLASHW_COUNT && uCount == 0)
1402 {
1403 // Keep spinning? Nothing else to do.
1404 FlashState = FLASHW_FINISHED;
1405 }
1406 else
1407 {
1408 // Save state and flags so this can be restored next time through.
1409 FlashState ^= (FlashState ^ -!!(Activate)) & FLASHW_ACTIVE;
1410 FlashState ^= (FlashState ^ pfwi->dwFlags) & (FLASHW_MASK & ~FLASHW_TIMER);
1411 }
1412 FlashState = MAKELONG(LOWORD(FlashState),uCount);
1413 UserSetProp(pWnd, AtomFlashWndState, (HANDLE)FlashState, TRUE);
1414 }
1415 return Ret;
1416 }
1417
1418 HDC FASTCALL
1419 IntBeginPaint(PWND Window, PPAINTSTRUCT Ps)
1420 {
1421 RECT Rect;
1422 INT type;
1423 BOOL Erase = FALSE;
1424
1425 co_UserHideCaret(Window);
1426
1427 Window->state2 |= WNDS2_STARTPAINT;
1428 Window->state &= ~WNDS_PAINTNOTPROCESSED;
1429
1430 if (Window->state & WNDS_SENDNCPAINT)
1431 {
1432 HRGN hRgn;
1433 // Application can keep update dirty.
1434 do
1435 {
1436 Window->state &= ~WNDS_UPDATEDIRTY;
1437 hRgn = IntGetNCUpdateRgn(Window, FALSE);
1438 IntSendNCPaint(Window, hRgn);
1439 if (hRgn > HRGN_WINDOW && GreIsHandleValid(hRgn))
1440 {
1441 /* NOTE: The region can already be deleted! */
1442 GreDeleteObject(hRgn);
1443 }
1444 }
1445 while(Window->state & WNDS_UPDATEDIRTY);
1446 }
1447 else
1448 {
1449 Window->state &= ~WNDS_UPDATEDIRTY;
1450 }
1451
1452 RtlZeroMemory(Ps, sizeof(PAINTSTRUCT));
1453
1454 if (Window->state2 & WNDS2_ENDPAINTINVALIDATE)
1455 {
1456 ERR("BP: Another thread invalidated this window\n");
1457 }
1458
1459 Ps->hdc = UserGetDCEx( Window,
1460 Window->hrgnUpdate,
1461 DCX_INTERSECTRGN | DCX_USESTYLE);
1462 if (!Ps->hdc)
1463 {
1464 return NULL;
1465 }
1466
1467 // If set, always clear flags out due to the conditions later on for sending the message.
1468 if (Window->state & WNDS_SENDERASEBACKGROUND)
1469 {
1470 Window->state &= ~(WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
1471 Erase = TRUE;
1472 }
1473
1474 if (Window->hrgnUpdate != NULL)
1475 {
1476 MsqDecPaintCountQueue(Window->head.pti);
1477 IntGdiSetRegionOwner(Window->hrgnUpdate, GDI_OBJ_HMGR_POWNED);
1478 /* The region is part of the dc now and belongs to the process! */
1479 Window->hrgnUpdate = NULL;
1480 }
1481 else
1482 {
1483 if (Window->state & WNDS_INTERNALPAINT)
1484 MsqDecPaintCountQueue(Window->head.pti);
1485 }
1486
1487 type = GdiGetClipBox(Ps->hdc, &Ps->rcPaint);
1488
1489 IntGetClientRect(Window, &Rect);
1490
1491 Window->state &= ~WNDS_INTERNALPAINT;
1492
1493 if ( Erase && // Set to erase,
1494 type != NULLREGION && // don't erase if the clip box is empty,
1495 (!(Window->pcls->style & CS_PARENTDC) || // not parent dc or
1496 RECTL_bIntersectRect( &Rect, &Rect, &Ps->rcPaint) ) ) // intersecting.
1497 {
1498 Ps->fErase = !co_IntSendMessage(UserHMGetHandle(Window), WM_ERASEBKGND, (WPARAM)Ps->hdc, 0);
1499 if ( Ps->fErase )
1500 {
1501 Window->state |= (WNDS_SENDERASEBACKGROUND|WNDS_ERASEBACKGROUND);
1502 }
1503 }
1504 else
1505 {
1506 Ps->fErase = FALSE;
1507 }
1508
1509 IntSendChildNCPaint(Window);
1510
1511 return Ps->hdc;
1512 }
1513
1514 BOOL FASTCALL
1515 IntEndPaint(PWND Wnd, PPAINTSTRUCT Ps)
1516 {
1517 HDC hdc = NULL;
1518
1519 hdc = Ps->hdc;
1520
1521 UserReleaseDC(Wnd, hdc, TRUE);
1522
1523 if (Wnd->state2 & WNDS2_ENDPAINTINVALIDATE)
1524 {
1525 ERR("EP: Another thread invalidated this window\n");
1526 Wnd->state2 &= ~WNDS2_ENDPAINTINVALIDATE;
1527 }
1528
1529 Wnd->state2 &= ~(WNDS2_WMPAINTSENT|WNDS2_STARTPAINT);
1530
1531 co_UserShowCaret(Wnd);
1532
1533 return TRUE;
1534 }
1535
1536 BOOL FASTCALL
1537 IntFillWindow(PWND pWndParent,
1538 PWND pWnd,
1539 HDC hDC,
1540 HBRUSH hBrush)
1541 {
1542 RECT Rect, Rect1;
1543 INT type;
1544
1545 if (!pWndParent)
1546 pWndParent = pWnd;
1547
1548 type = GdiGetClipBox(hDC, &Rect);
1549
1550 IntGetClientRect(pWnd, &Rect1);
1551
1552 if ( type != NULLREGION && // Clip box is not empty,
1553 (!(pWnd->pcls->style & CS_PARENTDC) || // not parent dc or
1554 RECTL_bIntersectRect( &Rect, &Rect, &Rect1) ) ) // intersecting.
1555 {
1556 POINT ppt;
1557 INT x = 0, y = 0;
1558
1559 if (!UserIsDesktopWindow(pWndParent))
1560 {
1561 x = pWndParent->rcClient.left - pWnd->rcClient.left;
1562 y = pWndParent->rcClient.top - pWnd->rcClient.top;
1563 }
1564
1565 GreSetBrushOrg(hDC, x, y, &ppt);
1566
1567 if ( hBrush < (HBRUSH)CTLCOLOR_MAX )
1568 hBrush = GetControlColor( pWndParent, pWnd, hDC, HandleToUlong(hBrush) + WM_CTLCOLORMSGBOX);
1569
1570 FillRect(hDC, &Rect, hBrush);
1571
1572 GreSetBrushOrg(hDC, ppt.x, ppt.y, NULL);
1573
1574 return TRUE;
1575 }
1576 else
1577 return FALSE;
1578 }
1579
1580 /* PUBLIC FUNCTIONS ***********************************************************/
1581
1582 /*
1583 * NtUserBeginPaint
1584 *
1585 * Status
1586 * @implemented
1587 */
1588
1589 HDC APIENTRY
1590 NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* UnsafePs)
1591 {
1592 PWND Window = NULL;
1593 PAINTSTRUCT Ps;
1594 NTSTATUS Status;
1595 HDC hDC;
1596 USER_REFERENCE_ENTRY Ref;
1597 DECLARE_RETURN(HDC);
1598
1599 TRACE("Enter NtUserBeginPaint\n");
1600 UserEnterExclusive();
1601
1602 if (!(Window = UserGetWindowObject(hWnd)))
1603 {
1604 RETURN( NULL);
1605 }
1606
1607 UserRefObjectCo(Window, &Ref);
1608
1609 hDC = IntBeginPaint(Window, &Ps);
1610
1611 Status = MmCopyToCaller(UnsafePs, &Ps, sizeof(PAINTSTRUCT));
1612 if (! NT_SUCCESS(Status))
1613 {
1614 SetLastNtError(Status);
1615 RETURN(NULL);
1616 }
1617
1618 RETURN(hDC);
1619
1620 CLEANUP:
1621 if (Window) UserDerefObjectCo(Window);
1622
1623 TRACE("Leave NtUserBeginPaint, ret=%p\n",_ret_);
1624 UserLeave();
1625 END_CLEANUP;
1626
1627 }
1628
1629 /*
1630 * NtUserEndPaint
1631 *
1632 * Status
1633 * @implemented
1634 */
1635
1636 BOOL APIENTRY
1637 NtUserEndPaint(HWND hWnd, CONST PAINTSTRUCT* pUnsafePs)
1638 {
1639 NTSTATUS Status = STATUS_SUCCESS;
1640 PWND Window = NULL;
1641 PAINTSTRUCT Ps;
1642 USER_REFERENCE_ENTRY Ref;
1643 DECLARE_RETURN(BOOL);
1644
1645 TRACE("Enter NtUserEndPaint\n");
1646 UserEnterExclusive();
1647
1648 if (!(Window = UserGetWindowObject(hWnd)))
1649 {
1650 RETURN(FALSE);
1651 }
1652
1653 UserRefObjectCo(Window, &Ref); // Here for the exception.
1654
1655 _SEH2_TRY
1656 {
1657 ProbeForRead(pUnsafePs, sizeof(*pUnsafePs), 1);
1658 RtlCopyMemory(&Ps, pUnsafePs, sizeof(PAINTSTRUCT));
1659 }
1660 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1661 {
1662 Status = _SEH2_GetExceptionCode();
1663 }
1664 _SEH2_END
1665 if (!NT_SUCCESS(Status))
1666 {
1667 RETURN(FALSE);
1668 }
1669
1670 RETURN(IntEndPaint(Window, &Ps));
1671
1672 CLEANUP:
1673 if (Window) UserDerefObjectCo(Window);
1674
1675 TRACE("Leave NtUserEndPaint, ret=%i\n",_ret_);
1676 UserLeave();
1677 END_CLEANUP;
1678 }
1679
1680 /*
1681 * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
1682 */
1683 /*
1684 * @implemented
1685 */
1686 BOOL APIENTRY
1687 NtUserFillWindow(HWND hWndParent,
1688 HWND hWnd,
1689 HDC hDC,
1690 HBRUSH hBrush)
1691 {
1692 BOOL ret = FALSE;
1693 PWND pWnd, pWndParent = NULL;
1694 USER_REFERENCE_ENTRY Ref;
1695
1696 TRACE("Enter NtUserFillWindow\n");
1697 UserEnterExclusive();
1698
1699 if (!hDC)
1700 {
1701 goto Exit;
1702 }
1703
1704 if (!(pWnd = UserGetWindowObject(hWnd)))
1705 {
1706 goto Exit;
1707 }
1708
1709 if (hWndParent && !(pWndParent = UserGetWindowObject(hWndParent)))
1710 {
1711 goto Exit;
1712 }
1713
1714 UserRefObjectCo(pWnd, &Ref);
1715 ret = IntFillWindow( pWndParent, pWnd, hDC, hBrush );
1716 UserDerefObjectCo(pWnd);
1717
1718 Exit:
1719 TRACE("Leave NtUserFillWindow, ret=%i\n",ret);
1720 UserLeave();
1721 return ret;
1722 }
1723
1724 /*
1725 * @implemented
1726 */
1727 BOOL APIENTRY
1728 NtUserFlashWindowEx(IN PFLASHWINFO pfwi)
1729 {
1730 PWND pWnd;
1731 FLASHWINFO finfo = {0};
1732 BOOL Ret = FALSE;
1733
1734 UserEnterExclusive();
1735
1736 _SEH2_TRY
1737 {
1738 ProbeForRead(pfwi, sizeof(FLASHWINFO), 1);
1739 RtlCopyMemory(&finfo, pfwi, sizeof(FLASHWINFO));
1740 }
1741 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1742 {
1743 SetLastNtError(_SEH2_GetExceptionCode());
1744 _SEH2_YIELD(goto Exit);
1745 }
1746 _SEH2_END
1747
1748 if (!( pWnd = ValidateHwndNoErr(finfo.hwnd)) ||
1749 finfo.cbSize != sizeof(FLASHWINFO) ||
1750 finfo.dwFlags & ~(FLASHW_ALL|FLASHW_TIMER|FLASHW_TIMERNOFG) )
1751 {
1752 EngSetLastError(ERROR_INVALID_PARAMETER);
1753 goto Exit;
1754 }
1755
1756 Ret = IntFlashWindowEx(pWnd, &finfo);
1757
1758 Exit:
1759 UserLeave();
1760 return Ret;
1761 }
1762
1763 /*
1764 GetUpdateRgn, this fails the same as the old one.
1765 */
1766 INT FASTCALL
1767 co_UserGetUpdateRgn(PWND Window, HRGN hRgn, BOOL bErase)
1768 {
1769 int RegionType;
1770 BOOL Type;
1771 RECTL Rect;
1772
1773 ASSERT_REFS_CO(Window);
1774
1775 if (bErase)
1776 {
1777 USER_REFERENCE_ENTRY Ref;
1778 UserRefObjectCo(Window, &Ref);
1779 co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
1780 UserDerefObjectCo(Window);
1781 }
1782
1783 Window->state &= ~WNDS_UPDATEDIRTY;
1784
1785 if (Window->hrgnUpdate == NULL)
1786 {
1787 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1788 return NULLREGION;
1789 }
1790
1791 Rect = Window->rcClient;
1792 Type = IntIntersectWithParents(Window, &Rect);
1793
1794 if (Window->hrgnUpdate == HRGN_WINDOW)
1795 {
1796 // Trap it out.
1797 ERR("GURn: Caller is passing Window Region 1\n");
1798 if (!Type)
1799 {
1800 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1801 return NULLREGION;
1802 }
1803
1804 RegionType = SIMPLEREGION;
1805
1806 if (!UserIsDesktopWindow(Window))
1807 {
1808 RECTL_vOffsetRect(&Rect,
1809 -Window->rcClient.left,
1810 -Window->rcClient.top);
1811 }
1812 GreSetRectRgnIndirect(hRgn, &Rect);
1813 }
1814 else
1815 {
1816 HRGN hrgnTemp = GreCreateRectRgnIndirect(&Rect);
1817
1818 RegionType = NtGdiCombineRgn(hRgn, hrgnTemp, Window->hrgnUpdate, RGN_AND);
1819
1820 if (RegionType == ERROR || RegionType == NULLREGION)
1821 {
1822 if (hrgnTemp) GreDeleteObject(hrgnTemp);
1823 NtGdiSetRectRgn(hRgn, 0, 0, 0, 0);
1824 return RegionType;
1825 }
1826
1827 if (!UserIsDesktopWindow(Window))
1828 {
1829 NtGdiOffsetRgn(hRgn,
1830 -Window->rcClient.left,
1831 -Window->rcClient.top);
1832 }
1833 if (hrgnTemp) GreDeleteObject(hrgnTemp);
1834 }
1835 return RegionType;
1836 }
1837
1838 BOOL FASTCALL
1839 co_UserGetUpdateRect(PWND Window, PRECT pRect, BOOL bErase)
1840 {
1841 INT RegionType;
1842 BOOL Ret = TRUE;
1843
1844 if (bErase)
1845 {
1846 USER_REFERENCE_ENTRY Ref;
1847 UserRefObjectCo(Window, &Ref);
1848 co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
1849 UserDerefObjectCo(Window);
1850 }
1851
1852 Window->state &= ~WNDS_UPDATEDIRTY;
1853
1854 if (Window->hrgnUpdate == NULL)
1855 {
1856 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1857 Ret = FALSE;
1858 }
1859 else
1860 {
1861 /* Get the update region bounding box. */
1862 if (Window->hrgnUpdate == HRGN_WINDOW)
1863 {
1864 *pRect = Window->rcClient;
1865 ERR("GURt: Caller is retrieving Window Region 1\n");
1866 }
1867 else
1868 {
1869 RegionType = IntGdiGetRgnBox(Window->hrgnUpdate, pRect);
1870
1871 if (RegionType != ERROR && RegionType != NULLREGION)
1872 RECTL_bIntersectRect(pRect, pRect, &Window->rcClient);
1873 }
1874
1875 if (IntIntersectWithParents(Window, pRect))
1876 {
1877 if (!UserIsDesktopWindow(Window))
1878 {
1879 RECTL_vOffsetRect(pRect,
1880 -Window->rcClient.left,
1881 -Window->rcClient.top);
1882 }
1883 if (Window->pcls->style & CS_OWNDC)
1884 {
1885 HDC hdc;
1886 //DWORD layout;
1887 hdc = UserGetDCEx(Window, NULL, DCX_USESTYLE);
1888 //layout = NtGdiSetLayout(hdc, -1, 0);
1889 //IntMapWindowPoints( 0, Window, (LPPOINT)pRect, 2 );
1890 GreDPtoLP( hdc, (LPPOINT)pRect, 2 );
1891 //NtGdiSetLayout(hdc, -1, layout);
1892 UserReleaseDC(Window, hdc, FALSE);
1893 }
1894 }
1895 else
1896 {
1897 pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
1898 }
1899 }
1900 return Ret;
1901 }
1902
1903 /*
1904 * NtUserGetUpdateRgn
1905 *
1906 * Status
1907 * @implemented
1908 */
1909
1910 INT APIENTRY
1911 NtUserGetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
1912 {
1913 DECLARE_RETURN(INT);
1914 PWND Window;
1915 INT ret;
1916
1917 TRACE("Enter NtUserGetUpdateRgn\n");
1918 UserEnterExclusive();
1919
1920 if (!(Window = UserGetWindowObject(hWnd)))
1921 {
1922 RETURN(ERROR);
1923 }
1924
1925 ret = co_UserGetUpdateRgn(Window, hRgn, bErase);
1926
1927 RETURN(ret);
1928
1929 CLEANUP:
1930 TRACE("Leave NtUserGetUpdateRgn, ret=%i\n",_ret_);
1931 UserLeave();
1932 END_CLEANUP;
1933 }
1934
1935 /*
1936 * NtUserGetUpdateRect
1937 *
1938 * Status
1939 * @implemented
1940 */
1941
1942 BOOL APIENTRY
1943 NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
1944 {
1945 PWND Window;
1946 RECTL Rect;
1947 NTSTATUS Status;
1948 BOOL Ret;
1949 DECLARE_RETURN(BOOL);
1950
1951 TRACE("Enter NtUserGetUpdateRect\n");
1952 UserEnterExclusive();
1953
1954 if (!(Window = UserGetWindowObject(hWnd)))
1955 {
1956 RETURN(FALSE);
1957 }
1958
1959 Ret = co_UserGetUpdateRect(Window, &Rect, bErase);
1960
1961 if (UnsafeRect != NULL)
1962 {
1963 Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECTL));
1964 if (!NT_SUCCESS(Status))
1965 {
1966 EngSetLastError(ERROR_INVALID_PARAMETER);
1967 RETURN(FALSE);
1968 }
1969 }
1970
1971 RETURN(Ret);
1972
1973 CLEANUP:
1974 TRACE("Leave NtUserGetUpdateRect, ret=%i\n",_ret_);
1975 UserLeave();
1976 END_CLEANUP;
1977 }
1978
1979 /*
1980 * NtUserRedrawWindow
1981 *
1982 * Status
1983 * @implemented
1984 */
1985
1986 BOOL APIENTRY
1987 NtUserRedrawWindow(
1988 HWND hWnd,
1989 CONST RECT *lprcUpdate,
1990 HRGN hrgnUpdate,
1991 UINT flags)
1992 {
1993 RECTL SafeUpdateRect;
1994 PWND Wnd;
1995 BOOL Ret;
1996 USER_REFERENCE_ENTRY Ref;
1997 NTSTATUS Status = STATUS_SUCCESS;
1998 PREGION RgnUpdate = NULL;
1999 DECLARE_RETURN(BOOL);
2000
2001 TRACE("Enter NtUserRedrawWindow\n");
2002 UserEnterExclusive();
2003
2004 if (!(Wnd = UserGetWindowObject(hWnd ? hWnd : IntGetDesktopWindow())))
2005 {
2006 RETURN( FALSE);
2007 }
2008
2009 if (lprcUpdate)
2010 {
2011 _SEH2_TRY
2012 {
2013 ProbeForRead(lprcUpdate, sizeof(RECTL), 1);
2014 RtlCopyMemory(&SafeUpdateRect, lprcUpdate, sizeof(RECTL));
2015 }
2016 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2017 {
2018 Status = _SEH2_GetExceptionCode();
2019 }
2020 _SEH2_END
2021 if (!NT_SUCCESS(Status))
2022 {
2023 EngSetLastError(RtlNtStatusToDosError(Status));
2024 RETURN( FALSE);
2025 }
2026 }
2027
2028 if ( flags & ~(RDW_ERASE|RDW_FRAME|RDW_INTERNALPAINT|RDW_INVALIDATE|
2029 RDW_NOERASE|RDW_NOFRAME|RDW_NOINTERNALPAINT|RDW_VALIDATE|
2030 RDW_ERASENOW|RDW_UPDATENOW|RDW_ALLCHILDREN|RDW_NOCHILDREN) )
2031 {
2032 /* RedrawWindow fails only in case that flags are invalid */
2033 EngSetLastError(ERROR_INVALID_FLAGS);
2034 RETURN( FALSE);
2035 }
2036
2037 /* We can't hold lock on GDI objects while doing roundtrips to user mode,
2038 * so it will be copied.
2039 */
2040 if (hrgnUpdate > HRGN_WINDOW)
2041 {
2042 RgnUpdate = REGION_LockRgn(hrgnUpdate);
2043 if (!RgnUpdate)
2044 {
2045 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
2046 RETURN(FALSE);
2047 }
2048 REGION_UnlockRgn(RgnUpdate);
2049 }
2050 else if (hrgnUpdate == HRGN_WINDOW) // Trap it out.
2051 {
2052 ERR("NTRW: Caller is passing Window Region 1\n");
2053 }
2054
2055 UserRefObjectCo(Wnd, &Ref);
2056
2057 Ret = co_UserRedrawWindow( Wnd,
2058 lprcUpdate ? &SafeUpdateRect : NULL,
2059 RgnUpdate,
2060 flags);
2061
2062 UserDerefObjectCo(Wnd);
2063
2064 RETURN( Ret);
2065
2066 CLEANUP:
2067 TRACE("Leave NtUserRedrawWindow, ret=%i\n",_ret_);
2068 UserLeave();
2069 END_CLEANUP;
2070 }
2071
2072 BOOL
2073 UserDrawCaptionText(
2074 PWND pWnd,
2075 HDC hDc,
2076 const PUNICODE_STRING Text,
2077 const RECTL *lpRc,
2078 UINT uFlags,
2079 HFONT hFont)
2080 {
2081 HFONT hOldFont = NULL;
2082 COLORREF OldTextColor;
2083 NONCLIENTMETRICSW nclm;
2084 NTSTATUS Status;
2085 BOOLEAN bDeleteFont = FALSE;
2086 SIZE Size;
2087 BOOL Ret = TRUE;
2088 ULONG fit = 0, Length;
2089 RECTL r = *lpRc;
2090
2091 TRACE("UserDrawCaptionText: %wZ\n", Text);
2092
2093 nclm.cbSize = sizeof(nclm);
2094 if (!UserSystemParametersInfo(SPI_GETNONCLIENTMETRICS, nclm.cbSize, &nclm, 0))
2095 {
2096 ERR("UserSystemParametersInfo() failed!\n");
2097 return FALSE;
2098 }
2099
2100 if (!hFont)
2101 {
2102 if(uFlags & DC_SMALLCAP)
2103 Status = TextIntCreateFontIndirect(&nclm.lfSmCaptionFont, &hFont);
2104 else
2105 Status = TextIntCreateFontIndirect(&nclm.lfCaptionFont, &hFont);
2106
2107 if(!NT_SUCCESS(Status))
2108 {
2109 ERR("TextIntCreateFontIndirect() failed! Status: 0x%x\n", Status);
2110 return FALSE;
2111 }
2112
2113 bDeleteFont = TRUE;
2114 }
2115
2116 IntGdiSetBkMode(hDc, TRANSPARENT);
2117
2118 hOldFont = NtGdiSelectFont(hDc, hFont);
2119
2120 if(uFlags & DC_INBUTTON)
2121 OldTextColor = IntGdiSetTextColor(hDc, IntGetSysColor(COLOR_BTNTEXT));
2122 else
2123 OldTextColor = IntGdiSetTextColor(hDc,
2124 IntGetSysColor(uFlags & DC_ACTIVE ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT));
2125
2126 // Adjust for system menu.
2127 if (pWnd && pWnd->style & WS_SYSMENU)
2128 {
2129 r.right -= UserGetSystemMetrics(SM_CYCAPTION) - 1;
2130 if ((pWnd->style & (WS_MAXIMIZEBOX | WS_MINIMIZEBOX)) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW))
2131 {
2132 r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2133 r.right -= UserGetSystemMetrics(SM_CXSIZE) + 1;
2134 }
2135 }
2136
2137 GreGetTextExtentExW(hDc, Text->Buffer, Text->Length/sizeof(WCHAR), r.right - r.left, &fit, 0, &Size, 0);
2138
2139 Length = (Text->Length/sizeof(WCHAR) == fit ? fit : fit+1);
2140
2141 if (Text->Length/sizeof(WCHAR) > Length)
2142 {
2143 Ret = FALSE;
2144 }
2145
2146 if (Ret)
2147 { // Faster while in setup.
2148 GreExtTextOutW( hDc,
2149 lpRc->left,
2150 lpRc->top + (lpRc->bottom - lpRc->top) / 2 - Size.cy / 2, // DT_SINGLELINE && DT_VCENTER
2151 ETO_CLIPPED,
2152 (RECTL *)lpRc,
2153 Text->Buffer,
2154 Length,
2155 NULL,
2156 0 );
2157 }
2158 else
2159 {
2160 DrawTextW( hDc,
2161 Text->Buffer,
2162 Text->Length/sizeof(WCHAR),
2163 (RECTL *)&r,
2164 DT_END_ELLIPSIS|DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX|DT_LEFT);
2165 }
2166
2167 IntGdiSetTextColor(hDc, OldTextColor);
2168
2169 if (hOldFont)
2170 NtGdiSelectFont(hDc, hOldFont);
2171
2172 if (bDeleteFont)
2173 GreDeleteObject(hFont);
2174
2175 return Ret;
2176 }
2177
2178 //
2179 // This draws Buttons, Icons and Text...
2180 //
2181 BOOL UserDrawCaption(
2182 PWND pWnd,
2183 HDC hDc,
2184 RECTL *lpRc,
2185 HFONT hFont,
2186 HICON hIcon,
2187 const PUNICODE_STRING Str,
2188 UINT uFlags)
2189 {
2190 BOOL Ret = FALSE;
2191 HBRUSH hBgBrush, hOldBrush = NULL;
2192 RECTL Rect = *lpRc;
2193 BOOL HasIcon;
2194
2195 RECTL_vMakeWellOrdered(lpRc);
2196
2197 /* Determine whether the icon needs to be displayed */
2198 if (!hIcon && pWnd != NULL)
2199 {
2200 HasIcon = (uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP) &&
2201 (pWnd->style & WS_SYSMENU) && !(pWnd->ExStyle & WS_EX_TOOLWINDOW);
2202 }
2203 else
2204 HasIcon = (hIcon != NULL);
2205
2206 // Draw the caption background
2207 if((uFlags & DC_GRADIENT) && !(uFlags & DC_INBUTTON))
2208 {
2209 static GRADIENT_RECT gcap = {0, 1};
2210 TRIVERTEX Vertices[2];
2211 COLORREF Colors[2];
2212
2213 Colors[0] = IntGetSysColor((uFlags & DC_ACTIVE) ?
2214 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
2215
2216 Colors[1] = IntGetSysColor((uFlags & DC_ACTIVE) ?
2217 COLOR_GRADIENTACTIVECAPTION : COLOR_GRADIENTINACTIVECAPTION);
2218
2219 Vertices[0].x = Rect.left;
2220 Vertices[0].y = Rect.top;
2221 Vertices[0].Red = (WORD)Colors[0]<<8;
2222 Vertices[0].Green = (WORD)Colors[0] & 0xFF00;
2223 Vertices[0].Blue = (WORD)(Colors[0]>>8) & 0xFF00;
2224 Vertices[0].Alpha = 0;
2225
2226 Vertices[1].x = Rect.right;
2227 Vertices[1].y = Rect.bottom;
2228 Vertices[1].Red = (WORD)Colors[1]<<8;
2229 Vertices[1].Green = (WORD)Colors[1] & 0xFF00;
2230 Vertices[1].Blue = (WORD)(Colors[1]>>8) & 0xFF00;
2231 Vertices[1].Alpha = 0;
2232
2233 if(!GreGradientFill(hDc, Vertices, 2, &gcap, 1, GRADIENT_FILL_RECT_H))
2234 {
2235 ERR("GreGradientFill() failed!\n");
2236 goto cleanup;
2237 }
2238 }
2239 else
2240 {
2241 if(uFlags & DC_INBUTTON)
2242 hBgBrush = IntGetSysColorBrush(COLOR_3DFACE);
2243 else if(uFlags & DC_ACTIVE)
2244 hBgBrush = IntGetSysColorBrush(COLOR_ACTIVECAPTION);
2245 else
2246 hBgBrush = IntGetSysColorBrush(COLOR_INACTIVECAPTION);
2247
2248 hOldBrush = NtGdiSelectBrush(hDc, hBgBrush);
2249
2250 if(!hOldBrush)
2251 {
2252 ERR("NtGdiSelectBrush() failed!\n");
2253 goto cleanup;
2254 }
2255
2256 if(!NtGdiPatBlt(hDc, Rect.left, Rect.top,
2257 Rect.right - Rect.left,
2258 Rect.bottom - Rect.top,
2259 PATCOPY))
2260 {
2261 ERR("NtGdiPatBlt() failed!\n");
2262 goto cleanup;
2263 }
2264 }
2265
2266 /* Draw icon */
2267 if (HasIcon)
2268 {
2269 PCURICON_OBJECT pIcon = NULL;
2270
2271 if (hIcon)
2272 {
2273 pIcon = UserGetCurIconObject(hIcon);
2274 }
2275 else if (pWnd)
2276 {
2277 pIcon = NC_IconForWindow(pWnd);
2278 // FIXME: NC_IconForWindow should reference it for us */
2279 if (pIcon)
2280 UserReferenceObject(pIcon);
2281 }
2282
2283 if (pIcon)
2284 {
2285 LONG cx = UserGetSystemMetrics(SM_CXSMICON);
2286 LONG cy = UserGetSystemMetrics(SM_CYSMICON);
2287 LONG x = Rect.left - cx/2 + 1 + (Rect.bottom - Rect.top)/2; // this is really what Window does
2288 LONG y = (Rect.top + Rect.bottom - cy)/2; // center
2289 UserDrawIconEx(hDc, x, y, pIcon, cx, cy, 0, NULL, DI_NORMAL);
2290 UserDereferenceObject(pIcon);
2291 }
2292 else
2293 {
2294 HasIcon = FALSE;
2295 }
2296 }
2297
2298 if (HasIcon)
2299 Rect.left += Rect.bottom - Rect.top;
2300
2301 if((uFlags & DC_TEXT))
2302 {
2303 BOOL Set = FALSE;
2304 Rect.left += 2;
2305
2306 if (Str)
2307 Set = UserDrawCaptionText(pWnd, hDc, Str, &Rect, uFlags, hFont);
2308 else if (pWnd != NULL) // FIXME: Windows does not do that
2309 {
2310 UNICODE_STRING ustr;
2311 ustr.Buffer = pWnd->strName.Buffer; // FIXME: LARGE_STRING truncated!
2312 ustr.Length = (USHORT)min(pWnd->strName.Length, MAXUSHORT);
2313 ustr.MaximumLength = (USHORT)min(pWnd->strName.MaximumLength, MAXUSHORT);
2314 Set = UserDrawCaptionText(pWnd, hDc, &ustr, &Rect, uFlags, hFont);
2315 }
2316 if (pWnd)
2317 {
2318 if (Set)
2319 pWnd->state2 &= ~WNDS2_CAPTIONTEXTTRUNCATED;
2320 else
2321 pWnd->state2 |= WNDS2_CAPTIONTEXTTRUNCATED;
2322 }
2323 }
2324
2325 Ret = TRUE;
2326
2327 cleanup:
2328 if (hOldBrush) NtGdiSelectBrush(hDc, hOldBrush);
2329
2330 return Ret;
2331 }
2332
2333 INT
2334 FASTCALL
2335 UserRealizePalette(HDC hdc)
2336 {
2337 HWND hWnd, hWndDesktop;
2338 DWORD Ret;
2339
2340 Ret = IntGdiRealizePalette(hdc);
2341 if (Ret) // There was a change.
2342 {
2343 hWnd = IntWindowFromDC(hdc);
2344 if (hWnd) // Send broadcast if dc is associated with a window.
2345 { // FYI: Thread locked in CallOneParam.
2346 hWndDesktop = IntGetDesktopWindow();
2347 if ( hWndDesktop != hWnd )
2348 {
2349 PWND pWnd = UserGetWindowObject(hWndDesktop);
2350 ERR("RealizePalette Desktop.");
2351 hdc = UserGetWindowDC(pWnd);
2352 IntPaintDesktop(hdc);
2353 UserReleaseDC(pWnd,hdc,FALSE);
2354 }
2355 UserSendNotifyMessage((HWND)HWND_BROADCAST, WM_PALETTECHANGED, (WPARAM)hWnd, 0);
2356 }
2357 }
2358 return Ret;
2359 }
2360
2361 BOOL
2362 APIENTRY
2363 NtUserDrawCaptionTemp(
2364 HWND hWnd,
2365 HDC hDC,
2366 LPCRECT lpRc,
2367 HFONT hFont,
2368 HICON hIcon,
2369 const PUNICODE_STRING str,
2370 UINT uFlags)
2371 {
2372 PWND pWnd = NULL;
2373 UNICODE_STRING SafeStr = {0};
2374 NTSTATUS Status = STATUS_SUCCESS;
2375 RECTL SafeRect;
2376 BOOL Ret;
2377
2378 UserEnterExclusive();
2379
2380 if (hWnd != NULL)
2381 {
2382 if(!(pWnd = UserGetWindowObject(hWnd)))
2383 {
2384 UserLeave();
2385 return FALSE;
2386 }
2387 }
2388
2389 _SEH2_TRY
2390 {
2391 ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
2392 RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
2393 if (str != NULL)
2394 {
2395 SafeStr = ProbeForReadUnicodeString(str);
2396 if (SafeStr.Length != 0)
2397 {
2398 ProbeForRead( SafeStr.Buffer,
2399 SafeStr.Length,
2400 sizeof(WCHAR));
2401 }
2402 }
2403 }
2404 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2405 {
2406 Status = _SEH2_GetExceptionCode();
2407 }
2408 _SEH2_END;
2409
2410 if (Status != STATUS_SUCCESS)
2411 {
2412 SetLastNtError(Status);
2413 UserLeave();
2414 return FALSE;
2415 }
2416
2417 if (str != NULL)
2418 Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, &SafeStr, uFlags);
2419 else
2420 {
2421 if ( RECTL_bIsEmptyRect(&SafeRect) && hFont == 0 && hIcon == 0 )
2422 {
2423 Ret = TRUE;
2424 if (uFlags & DC_DRAWCAPTIONMD)
2425 {
2426 ERR("NC Caption Mode\n");
2427 UserDrawCaptionBar(pWnd, hDC, uFlags);
2428 goto Exit;
2429 }
2430 else if (uFlags & DC_DRAWFRAMEMD)
2431 {
2432 ERR("NC Paint Mode\n");
2433 NC_DoNCPaint(pWnd, hDC, uFlags); // Update Menus too!
2434 goto Exit;
2435 }
2436 }
2437 Ret = UserDrawCaption(pWnd, hDC, &SafeRect, hFont, hIcon, NULL, uFlags);
2438 }
2439 Exit:
2440 UserLeave();
2441 return Ret;
2442 }
2443
2444 BOOL
2445 APIENTRY
2446 NtUserDrawCaption(HWND hWnd,
2447 HDC hDC,
2448 LPCRECT lpRc,
2449 UINT uFlags)
2450 {
2451 return NtUserDrawCaptionTemp(hWnd, hDC, lpRc, 0, 0, NULL, uFlags);
2452 }
2453
2454 INT FASTCALL
2455 co_UserExcludeUpdateRgn(HDC hDC, PWND Window)
2456 {
2457 POINT pt;
2458 RECT rc;
2459
2460 if (Window->hrgnUpdate)
2461 {
2462 if (Window->hrgnUpdate == HRGN_WINDOW)
2463 {
2464 return NtGdiIntersectClipRect(hDC, 0, 0, 0, 0);
2465 }
2466 else
2467 {
2468 INT ret = ERROR;
2469 HRGN hrgn = NtGdiCreateRectRgn(0,0,0,0);
2470
2471 if ( hrgn && GreGetDCPoint( hDC, GdiGetDCOrg, &pt) )
2472 {
2473 if ( NtGdiGetRandomRgn( hDC, hrgn, CLIPRGN) == NULLREGION )
2474 {
2475 NtGdiOffsetRgn(hrgn, pt.x, pt.y);
2476 }
2477 else
2478 {
2479 HRGN hrgnScreen;
2480 PMONITOR pm = UserGetPrimaryMonitor();
2481 hrgnScreen = NtGdiCreateRectRgn(0,0,0,0);
2482 NtGdiCombineRgn(hrgnScreen, hrgnScreen, pm->hrgnMonitor, RGN_OR);
2483
2484 NtGdiCombineRgn(hrgn, hrgnScreen, NULL, RGN_COPY);
2485
2486 GreDeleteObject(hrgnScreen);
2487 }
2488
2489 NtGdiCombineRgn(hrgn, hrgn, Window->hrgnUpdate, RGN_DIFF);
2490
2491 NtGdiOffsetRgn(hrgn, -pt.x, -pt.y);
2492
2493 ret = NtGdiExtSelectClipRgn(hDC, hrgn, RGN_COPY);
2494
2495 GreDeleteObject(hrgn);
2496 }
2497 return ret;
2498 }
2499 }
2500 else
2501 {
2502 return GdiGetClipBox( hDC, &rc);
2503 }
2504 }
2505
2506 INT
2507 APIENTRY
2508 NtUserExcludeUpdateRgn(
2509 HDC hDC,
2510 HWND hWnd)
2511 {
2512 INT ret = ERROR;
2513 PWND pWnd;
2514
2515 TRACE("Enter NtUserExcludeUpdateRgn\n");
2516 UserEnterExclusive();
2517
2518 pWnd = UserGetWindowObject(hWnd);
2519
2520 if (hDC && pWnd)
2521 ret = co_UserExcludeUpdateRgn(hDC, pWnd);
2522
2523 TRACE("Leave NtUserExcludeUpdateRgn, ret=%i\n", ret);
2524
2525 UserLeave();
2526 return ret;
2527 }
2528
2529 BOOL
2530 APIENTRY
2531 NtUserInvalidateRect(
2532 HWND hWnd,
2533 CONST RECT *lpUnsafeRect,
2534 BOOL bErase)
2535 {
2536 UINT flags = RDW_INVALIDATE | (bErase ? RDW_ERASE : 0);
2537 if (!hWnd)
2538 {
2539 flags = RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW;
2540 lpUnsafeRect = NULL;
2541 }
2542 return NtUserRedrawWindow(hWnd, lpUnsafeRect, NULL, flags);
2543 }
2544
2545 BOOL
2546 APIENTRY
2547 NtUserInvalidateRgn(
2548 HWND hWnd,
2549 HRGN hRgn,
2550 BOOL bErase)
2551 {
2552 if (!hWnd)
2553 {
2554 EngSetLastError( ERROR_INVALID_WINDOW_HANDLE );
2555 return FALSE;
2556 }
2557 return NtUserRedrawWindow(hWnd, NULL, hRgn, RDW_INVALIDATE | (bErase? RDW_ERASE : 0));
2558 }
2559
2560 BOOL
2561 APIENTRY
2562 NtUserPrintWindow(
2563 HWND hwnd,
2564 HDC hdcBlt,
2565 UINT nFlags)
2566 {
2567 PWND Window;
2568 BOOL Ret = FALSE;
2569
2570 UserEnterExclusive();
2571
2572 if (hwnd)
2573 {
2574 if (!(Window = UserGetWindowObject(hwnd)) ||
2575 UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
2576 {
2577 goto Exit;
2578 }
2579
2580 if ( Window )
2581 {
2582 /* Validate flags and check it as a mask for 0 or 1. */
2583 if ( (nFlags & PW_CLIENTONLY) == nFlags)
2584 Ret = IntPrintWindow( Window, hdcBlt, nFlags);
2585 else
2586 EngSetLastError(ERROR_INVALID_PARAMETER);
2587 }
2588 }
2589 Exit:
2590 UserLeave();
2591 return Ret;
2592 }
2593
2594 /* ValidateRect gets redirected to NtUserValidateRect:
2595 http://blog.csdn.net/ntdll/archive/2005/10/19/509299.aspx */
2596 BOOL
2597 APIENTRY
2598 NtUserValidateRect(
2599 HWND hWnd,
2600 const RECT *lpRect)
2601 {
2602 UINT flags = RDW_VALIDATE;
2603 if (!hWnd)
2604 {
2605 flags = RDW_ALLCHILDREN | RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW;
2606 lpRect = NULL;
2607 }
2608 return NtUserRedrawWindow(hWnd, lpRect, NULL, flags);
2609 }
2610
2611 /* EOF */