2 * Window painting functions
4 * Copyright 1993, 1994, 1995 Alexandre Julliard
13 #include "debugtools.h"
14 #include "wine/winuser16.h"
16 DECLARE_DEBUG_CHANNEL(nonclient)
17 DECLARE_DEBUG_CHANNEL(win)
19 /* client rect in window coordinates */
21 #define GETCLIENTRECTW( wnd, r ) (r).left = (wnd)->rectClient.left - (wnd)->rectWindow.left; \
22 (r).top = (wnd)->rectClient.top - (wnd)->rectWindow.top; \
23 (r).right = (wnd)->rectClient.right - (wnd)->rectWindow.left; \
24 (r).bottom = (wnd)->rectClient.bottom - (wnd)->rectWindow.top
26 /* Last CTLCOLOR id */
27 #define CTLCOLOR_MAX CTLCOLOR_STATIC
30 /***********************************************************************
34 * Send WM_NCPAINT if required (when nonclient is invalid or UNC_ENTIRE flag is set)
35 * Crop hrgnUpdate to a client rect, especially if it 1.
36 * If UNC_REGION is set return update region for the client rect.
38 * NOTE: UNC_REGION is mainly for the RDW_Paint() chunk that sends WM_ERASEBKGND message.
39 * The trick is that when the returned region handle may be different from hRgn.
40 * In this case the old hRgn must be considered gone. BUT, if the returned value
41 * is 1 then the hRgn is preserved and RDW_Paint() will have to get
42 * a DC without extra clipping region.
44 HRGN WIN_UpdateNCRgn(WND* wnd, HRGN hRgn, UINT uncFlags )
50 TRACE_(nonclient)("hwnd %04x [%04x] hrgn %04x, unc %04x, ncf %i\n",
51 wnd->hwndSelf, wnd->hrgnUpdate, hRgn, uncFlags, wnd->flags & WIN_NEEDS_NCPAINT);
53 /* desktop window doesn't have a nonclient area */
54 if(wnd == WIN_GetDesktop())
56 wnd->flags &= ~WIN_NEEDS_NCPAINT;
57 if( wnd->hrgnUpdate > 1 )
58 hrgnRet = REGION_CropRgn( hRgn, wnd->hrgnUpdate, NULL, NULL );
61 hrgnRet = wnd->hrgnUpdate;
68 if ((wnd->hwndSelf == GetForegroundWindow()) &&
69 !(wnd->flags & WIN_NCACTIVATED) )
71 wnd->flags |= WIN_NCACTIVATED;
72 uncFlags |= UNC_ENTIRE;
75 if( wnd->flags & WIN_NEEDS_NCPAINT )
79 wnd->flags &= ~WIN_NEEDS_NCPAINT;
80 GETCLIENTRECTW( wnd, r );
82 TRACE_(nonclient)( "\tclient box (%i,%i-%i,%i), hrgnUpdate %04x\n",
83 r.left, r.top, r.right, r.bottom, wnd->hrgnUpdate );
84 if( wnd->hrgnUpdate > 1 )
86 /* Check if update rgn overlaps with nonclient area */
88 GetRgnBox( wnd->hrgnUpdate, &r2 );
89 UnionRect( &r3, &r2, &r );
90 if( r3.left != r.left || r3.top != r.top ||
91 r3.right != r.right || r3.bottom != r.bottom ) /* it does */
93 /* crop hrgnUpdate, save old one in hClip - the only
94 * case that places a valid region handle in hClip */
96 hClip = wnd->hrgnUpdate;
97 wnd->hrgnUpdate = REGION_CropRgn( hRgn, hClip, &r, NULL );
98 if( uncFlags & UNC_REGION ) hrgnRet = hClip;
101 if( uncFlags & UNC_CHECK )
103 GetRgnBox( wnd->hrgnUpdate, &r3 );
104 if( IsRectEmpty( &r3 ) )
106 /* delete the update region since all invalid
107 * parts were in the nonclient area */
109 DeleteObject( wnd->hrgnUpdate );
111 if(!(wnd->flags & WIN_INTERNAL_PAINT))
112 QUEUE_DecPaintCount( wnd->hmemTaskQ );
114 wnd->flags &= ~WIN_NEEDS_ERASEBKGND;
118 if(!hClip && wnd->hrgnUpdate ) goto copyrgn;
121 if( wnd->hrgnUpdate == 1 )/* entire window */
123 if( uncFlags & UNC_UPDATE ) wnd->hrgnUpdate = CreateRectRgnIndirect( &r );
124 if( uncFlags & UNC_REGION ) hrgnRet = 1;
125 uncFlags |= UNC_ENTIRE;
128 else /* no WM_NCPAINT unless forced */
130 if( wnd->hrgnUpdate > 1 )
133 if( uncFlags & UNC_REGION )
134 hrgnRet = REGION_CropRgn( hRgn, wnd->hrgnUpdate, NULL, NULL );
137 if( wnd->hrgnUpdate == 1 && (uncFlags & UNC_UPDATE) )
139 GETCLIENTRECTW( wnd, r );
140 wnd->hrgnUpdate = CreateRectRgnIndirect( &r );
141 if( uncFlags & UNC_REGION ) hrgnRet = 1;
145 if(!hClip && (uncFlags & UNC_ENTIRE) )
147 /* still don't do anything if there is no nonclient area */
148 hClip = (memcmp( &wnd->rectWindow, &wnd->rectClient, sizeof(RECT) ) != 0);
151 if( hClip ) /* NOTE: WM_NCPAINT allows wParam to be 1 */
153 SendMessageA( wnd->hwndSelf, WM_NCPAINT, hClip, 0L );
154 if( (hClip > 1)&& (hClip != hRgn) && (hClip != hrgnRet) ) DeleteObject( hClip );
156 * Since all Window locks are suspended while processing the WM_NCPAINT
157 * we want to make sure the window still exists before continuing.
159 if (!IsWindow(wnd->hwndSelf))
161 DeleteObject(hrgnRet);
166 TRACE_(nonclient)("returning %04x (hClip = %04x, hrgnUpdate = %04x)\n", hrgnRet, hClip, wnd->hrgnUpdate );
172 /***********************************************************************
173 * BeginPaint16 (USER.39)
175 HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
179 WND *wndPtr = WIN_FindWndPtr( hwnd );
180 if (!wndPtr) return 0;
182 bIcon = (wndPtr->dwStyle & WS_MINIMIZE && GetClassWord(wndPtr->hwndSelf, GCW_HICON));
184 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
186 /* send WM_NCPAINT and make sure hrgnUpdate is a valid rgn handle */
187 WIN_UpdateNCRgn( wndPtr, 0, UNC_UPDATE );
190 * Make sure the window is still a window. All window locks are suspended
191 * when the WM_NCPAINT is sent.
193 if (!IsWindow(wndPtr->hwndSelf))
195 WIN_ReleaseWndPtr(wndPtr);
199 if( ((hrgnUpdate = wndPtr->hrgnUpdate) != 0) || (wndPtr->flags & WIN_INTERNAL_PAINT))
200 QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
202 wndPtr->hrgnUpdate = 0;
203 wndPtr->flags &= ~WIN_INTERNAL_PAINT;
207 TRACE_(win)("hrgnUpdate = %04x, \n", hrgnUpdate);
209 if (GetClassWord16(wndPtr->hwndSelf, GCW_STYLE) & CS_PARENTDC)
211 /* Don't clip the output to the update region for CS_PARENTDC window */
213 DeleteObject(hrgnUpdate);
214 lps->hdc = GetDCEx16( hwnd, 0, DCX_WINDOWPAINT | DCX_USESTYLE |
215 (bIcon ? DCX_WINDOW : 0) );
219 if( hrgnUpdate ) /* convert to client coordinates */
220 OffsetRgn( hrgnUpdate, wndPtr->rectWindow.left - wndPtr->rectClient.left,
221 wndPtr->rectWindow.top - wndPtr->rectClient.top );
222 lps->hdc = GetDCEx16(hwnd, hrgnUpdate, DCX_INTERSECTRGN |
223 DCX_WINDOWPAINT | DCX_USESTYLE | (bIcon ? DCX_WINDOW : 0) );
224 /* ReleaseDC() in EndPaint() will delete the region */
227 TRACE_(win)("hdc = %04x\n", lps->hdc);
231 WARN_(win)("GetDCEx() failed in BeginPaint(), hwnd=%04x\n", hwnd);
232 WIN_ReleaseWndPtr(wndPtr);
236 GetClipBox16( lps->hdc, &lps->rcPaint );
238 TRACE_(win)("box = (%i,%i - %i,%i)\n", lps->rcPaint.left, lps->rcPaint.top,
239 lps->rcPaint.right, lps->rcPaint.bottom );
241 if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
243 wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
244 lps->fErase = !SendMessage16(hwnd, (bIcon) ? WM_ICONERASEBKGND
246 (WPARAM16)lps->hdc, 0 );
248 else lps->fErase = TRUE;
250 WIN_ReleaseWndPtr(wndPtr);
255 /***********************************************************************
256 * BeginPaint32 (USER32.10)
258 HDC WINAPI BeginPaint( HWND hwnd, PAINTSTRUCT *lps )
262 BeginPaint16( hwnd, &ps );
263 lps->hdc = (HDC)ps.hdc;
264 lps->fErase = ps.fErase;
265 lps->rcPaint.top = ps.rcPaint.top;
266 lps->rcPaint.left = ps.rcPaint.left;
267 lps->rcPaint.right = ps.rcPaint.right;
268 lps->rcPaint.bottom = ps.rcPaint.bottom;
269 lps->fRestore = ps.fRestore;
270 lps->fIncUpdate = ps.fIncUpdate;
275 /***********************************************************************
276 * EndPaint16 (USER.40)
278 BOOL16 WINAPI EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
280 ReleaseDC16( hwnd, lps->hdc );
286 /***********************************************************************
287 * EndPaint32 (USER32.176)
289 BOOL WINAPI EndPaint( HWND hwnd, const PAINTSTRUCT *lps )
291 ReleaseDC( hwnd, lps->hdc );
297 /***********************************************************************
298 * FillWindow (USER.324)
300 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
303 GetClientRect16( hwnd, &rect );
304 DPtoLP16( hdc, (LPPOINT16)&rect, 2 );
305 PaintRect16( hwndParent, hwnd, hdc, hbrush, &rect );
309 /***********************************************************************
310 * PAINT_GetControlBrush
312 static HBRUSH16 PAINT_GetControlBrush( HWND hParent, HWND hWnd, HDC16 hDC, UINT16 ctlType )
314 HBRUSH16 bkgBrush = (HBRUSH16)SendMessageA( hParent, WM_CTLCOLORMSGBOX + ctlType,
315 (WPARAM)hDC, (LPARAM)hWnd );
316 if( !IsGDIObject16(bkgBrush) )
317 bkgBrush = DEFWND_ControlColor( hDC, ctlType );
322 /***********************************************************************
323 * PaintRect (USER.325)
325 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
326 HBRUSH16 hbrush, const RECT16 *rect)
328 if( hbrush <= CTLCOLOR_MAX )
331 hbrush = PAINT_GetControlBrush( hwndParent, hwnd, hdc, (UINT16)hbrush );
336 FillRect16( hdc, rect, hbrush );
340 /***********************************************************************
341 * GetControlBrush (USER.326)
343 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
345 WND* wndPtr = WIN_FindWndPtr( hwnd );
348 if((ctlType <= CTLCOLOR_MAX) && wndPtr )
351 if( wndPtr->dwStyle & WS_POPUP ) parent = WIN_LockWndPtr(wndPtr->owner);
352 else parent = WIN_LockWndPtr(wndPtr->parent);
353 if( !parent ) parent = wndPtr;
354 retvalue = (HBRUSH16)PAINT_GetControlBrush( parent->hwndSelf, hwnd, hdc, ctlType );
355 WIN_ReleaseWndPtr(parent);
358 retvalue = (HBRUSH16)0;
360 WIN_ReleaseWndPtr(wndPtr);
366 /***********************************************************************
367 * RDW_UpdateRgns [RedrawWindow() helper]
369 * Walks the window tree and adds/removes parts of the hRgn to/from update
370 * regions of windows that overlap it. Also, manages internal paint flags.
372 * NOTE: Walks the window tree so the caller must lock it.
373 * MUST preserve hRgn (can modify but then has to restore).
375 static void RDW_UpdateRgns( WND* wndPtr, HRGN hRgn, UINT flags )
378 * Called only when one of the following is set:
379 * (RDW_INVALIDATE | RDW_VALIDATE | RDW_INTERNALPAINT | RDW_NOINTERNALPAINT)
382 BOOL bHadOne = wndPtr->hrgnUpdate && hRgn;
383 BOOL bChildren = ( wndPtr->child && !(flags & RDW_NOCHILDREN) && !(wndPtr->dwStyle & WS_MINIMIZE)
384 && ((flags & RDW_ALLCHILDREN) || !(wndPtr->dwStyle & WS_CLIPCHILDREN)) );
389 r.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
390 r.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
392 TRACE_(win)("\thwnd %04x [%04x] -> hrgn [%04x], flags [%04x]\n", wndPtr->hwndSelf, wndPtr->hrgnUpdate, hRgn, flags );
394 if( flags & RDW_INVALIDATE )
398 switch( wndPtr->hrgnUpdate )
401 CombineRgn( wndPtr->hrgnUpdate, wndPtr->hrgnUpdate, hRgn, RGN_OR );
404 wndPtr->hrgnUpdate = REGION_CropRgn( wndPtr->hrgnUpdate,
405 wndPtr->hrgnUpdate ? wndPtr->hrgnUpdate : hRgn,
409 GetRgnBox( wndPtr->hrgnUpdate, &r );
410 if( IsRectEmpty( &r ) )
412 DeleteObject( wndPtr->hrgnUpdate );
413 wndPtr->hrgnUpdate = 0;
418 case 1: /* already an entire window */
424 if( wndPtr->hrgnUpdate > 1 )
425 DeleteObject( wndPtr->hrgnUpdate );
426 wndPtr->hrgnUpdate = 1;
429 hRgn = wndPtr->hrgnUpdate; /* this is a trick that depends on code in PAINT_RedrawWindow() */
431 if( !bHadOne && !(wndPtr->flags & WIN_INTERNAL_PAINT) )
432 QUEUE_IncPaintCount( wndPtr->hmemTaskQ );
434 if (flags & RDW_FRAME) wndPtr->flags |= WIN_NEEDS_NCPAINT;
435 if (flags & RDW_ERASE) wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
438 else if( flags & RDW_VALIDATE )
440 if( wndPtr->hrgnUpdate )
444 if( wndPtr->hrgnUpdate == 1 )
445 wndPtr->hrgnUpdate = CreateRectRgnIndirect( &r );
447 if( CombineRgn( wndPtr->hrgnUpdate, wndPtr->hrgnUpdate, hRgn, RGN_DIFF )
451 else /* validate everything */
453 if( wndPtr->hrgnUpdate > 1 )
456 DeleteObject( wndPtr->hrgnUpdate );
458 wndPtr->hrgnUpdate = 0;
461 if( !wndPtr->hrgnUpdate )
463 wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
464 if( !(wndPtr->flags & WIN_INTERNAL_PAINT) )
465 QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
469 if (flags & RDW_NOFRAME) wndPtr->flags &= ~WIN_NEEDS_NCPAINT;
470 if (flags & RDW_NOERASE) wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
473 /* in/validate child windows that intersect with the region if it
474 * is a valid handle. */
476 if( flags & (RDW_INVALIDATE | RDW_VALIDATE) )
478 if( hRgn > 1 && bChildren )
480 WND* wnd = wndPtr->child;
481 POINT ptTotal, prevOrigin = {0,0};
484 ptClient.x = wndPtr->rectClient.left - wndPtr->rectWindow.left;
485 ptClient.y = wndPtr->rectClient.top - wndPtr->rectWindow.top;
487 for( ptTotal.x = ptTotal.y = 0; wnd; wnd = wnd->next )
489 if( wnd->dwStyle & WS_VISIBLE )
493 r.left = wnd->rectWindow.left + ptClient.x;
494 r.right = wnd->rectWindow.right + ptClient.x;
495 r.top = wnd->rectWindow.top + ptClient.y;
496 r.bottom = wnd->rectWindow.bottom + ptClient.y;
498 ptOffset.x = r.left - prevOrigin.x;
499 ptOffset.y = r.top - prevOrigin.y;
500 OffsetRect( &r, -ptTotal.x, -ptTotal.y );
502 if( RectInRegion( hRgn, &r ) )
504 OffsetRgn( hRgn, -ptOffset.x, -ptOffset.y );
505 RDW_UpdateRgns( wnd, hRgn, flags );
506 prevOrigin.x = r.left + ptTotal.x;
507 prevOrigin.y = r.top + ptTotal.y;
508 ptTotal.x += ptOffset.x;
509 ptTotal.y += ptOffset.y;
513 OffsetRgn( hRgn, ptTotal.x, ptTotal.y );
518 /* handle hRgn == 1 (alias for entire window) and/or internal paint recursion */
523 for( wnd = wndPtr->child; wnd; wnd = wnd->next )
524 if( wnd->dwStyle & WS_VISIBLE )
525 RDW_UpdateRgns( wnd, hRgn, flags );
530 /* Set/clear internal paint flag */
532 if (flags & RDW_INTERNALPAINT)
534 if ( !wndPtr->hrgnUpdate && !(wndPtr->flags & WIN_INTERNAL_PAINT))
535 QUEUE_IncPaintCount( wndPtr->hmemTaskQ );
536 wndPtr->flags |= WIN_INTERNAL_PAINT;
538 else if (flags & RDW_NOINTERNALPAINT)
540 if ( !wndPtr->hrgnUpdate && (wndPtr->flags & WIN_INTERNAL_PAINT))
541 QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
542 wndPtr->flags &= ~WIN_INTERNAL_PAINT;
546 /***********************************************************************
547 * RDW_Paint [RedrawWindow() helper]
549 * Walks the window tree and paints/erases windows that have
550 * nonzero update regions according to redraw flags. hrgn is a scratch
551 * region passed down during recursion. Must not be 1.
554 static HRGN RDW_Paint( WND* wndPtr, HRGN hrgn, UINT flags, UINT ex )
556 /* NOTE: wndPtr is locked by caller.
558 * FIXME: Windows uses WM_SYNCPAINT to cut down the number of intertask
559 * SendMessage() calls. This is a comment inside DefWindowProc() source
562 * This message avoids lots of inter-app message traffic
563 * by switching to the other task and continuing the
567 * LOWORD(lParam) = hrgnClip
568 * HIWORD(lParam) = hwndSkip (not used; always NULL)
572 HWND hWnd = wndPtr->hwndSelf;
573 BOOL bIcon = ((wndPtr->dwStyle & WS_MINIMIZE) && GetClassWord(wndPtr->hwndSelf, GCW_HICON));
575 /* Erase/update the window itself ... */
577 TRACE_(win)("\thwnd %04x [%04x] -> hrgn [%04x], flags [%04x]\n", hWnd, wndPtr->hrgnUpdate, hrgn, flags );
579 if (flags & RDW_UPDATENOW)
581 if (wndPtr->hrgnUpdate) /* wm_painticon wparam is 1 */
582 SendMessage16( hWnd, (bIcon) ? WM_PAINTICON : WM_PAINT, bIcon, 0 );
584 else if ((flags & RDW_ERASENOW) || (ex & RDW_EX_TOPFRAME))
586 UINT dcx = DCX_INTERSECTRGN | DCX_USESTYLE | DCX_KEEPCLIPRGN | DCX_WINDOWPAINT | DCX_CACHE;
587 HRGN hrgnRet = WIN_UpdateNCRgn( wndPtr, hrgn, UNC_REGION | UNC_CHECK |
588 ((ex & RDW_EX_TOPFRAME) ? UNC_ENTIRE : 0) );
591 if( hrgnRet > 1 ) hrgn = hrgnRet; else hrgnRet = 0; /* entire client */
592 if( wndPtr->flags & WIN_NEEDS_ERASEBKGND )
594 if( bIcon ) dcx |= DCX_WINDOW;
597 OffsetRgn( hrgnRet, wndPtr->rectWindow.left - wndPtr->rectClient.left,
598 wndPtr->rectWindow.top - wndPtr->rectClient.top);
600 dcx &= ~DCX_INTERSECTRGN;
601 if (( hDC = GetDCEx( hWnd, hrgnRet, dcx )) )
603 if (SendMessage16( hWnd, (bIcon) ? WM_ICONERASEBKGND
604 : WM_ERASEBKGND, (WPARAM16)hDC, 0 ))
605 wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
606 ReleaseDC( hWnd, hDC );
612 if( !IsWindow(hWnd) ) return hrgn;
613 ex &= ~RDW_EX_TOPFRAME;
615 /* ... and its child windows */
617 if( wndPtr->child && !(flags & RDW_NOCHILDREN) && !(wndPtr->dwStyle & WS_MINIMIZE)
618 && ((flags & RDW_ALLCHILDREN) || !(wndPtr->dwStyle & WS_CLIPCHILDREN)) )
622 if( (list = WIN_BuildWinArray( wndPtr, 0, NULL )) )
625 for (ppWnd = list; *ppWnd; ppWnd++)
627 WIN_UpdateWndPtr(&wndPtr,*ppWnd);
628 if (!IsWindow(wndPtr->hwndSelf)) continue;
629 if ( (wndPtr->dwStyle & WS_VISIBLE) &&
630 (wndPtr->hrgnUpdate || (wndPtr->flags & WIN_INTERNAL_PAINT)) )
631 hrgn = RDW_Paint( wndPtr, hrgn, flags, ex );
633 WIN_ReleaseWndPtr(wndPtr);
634 WIN_ReleaseWinArray(list);
641 /***********************************************************************
645 BOOL PAINT_RedrawWindow( HWND hwnd, const RECT *rectUpdate,
646 HRGN hrgnUpdate, UINT flags, UINT ex )
653 if (!hwnd) hwnd = GetDesktopWindow();
654 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
656 /* check if the window or its parents are visible/not minimized */
658 if (!WIN_IsWindowDrawable( wndPtr, !(flags & RDW_FRAME) ) )
660 WIN_ReleaseWndPtr(wndPtr);
668 GetRgnBox( hrgnUpdate, &r );
669 TRACE_(win)( "%04x (%04x) NULL %04x box (%i,%i-%i,%i) flags=%04x, exflags=%04x\n",
670 hwnd, wndPtr->hrgnUpdate, hrgnUpdate, r.left, r.top, r.right, r.bottom, flags, ex);
678 TRACE_(win)( "%04x (%04x) %s %d,%d-%d,%d %04x flags=%04x, exflags=%04x\n",
679 hwnd, wndPtr->hrgnUpdate, rectUpdate ? "rect" : "NULL", r.left,
680 r.top, r.right, r.bottom, hrgnUpdate, flags, ex );
684 /* prepare an update region in window coordinates */
686 if( flags & RDW_FRAME )
687 r = wndPtr->rectWindow;
689 r = wndPtr->rectClient;
691 if( ex & RDW_EX_XYWINDOW )
694 OffsetRect( &r, -wndPtr->rectWindow.left, -wndPtr->rectWindow.top );
698 pt.x = wndPtr->rectClient.left - wndPtr->rectWindow.left;
699 pt.y = wndPtr->rectClient.top - wndPtr->rectWindow.top;
700 OffsetRect( &r, -wndPtr->rectClient.left, -wndPtr->rectClient.top );
703 if (flags & RDW_INVALIDATE) /* ------------------------- Invalidate */
705 /* If the window doesn't have hrgnUpdate we leave hRgn zero
706 * and put a new region straight into wndPtr->hrgnUpdate
707 * so that RDW_UpdateRgns() won't have to do any extra work.
712 if( wndPtr->hrgnUpdate )
713 hRgn = REGION_CropRgn( 0, hrgnUpdate, NULL, &pt );
715 wndPtr->hrgnUpdate = REGION_CropRgn( 0, hrgnUpdate, &r, &pt );
717 else if( rectUpdate )
719 if( !IntersectRect( &r2, &r, rectUpdate ) ) goto END;
720 OffsetRect( &r2, pt.x, pt.y );
723 if( wndPtr->hrgnUpdate == 0 )
724 wndPtr->hrgnUpdate = CreateRectRgnIndirect( &r2 );
726 hRgn = CreateRectRgnIndirect( &r2 );
728 else /* entire window or client depending on RDW_FRAME */
730 if( flags & RDW_FRAME )
732 if( wndPtr->hrgnUpdate )
733 DeleteObject( wndPtr->hrgnUpdate );
734 wndPtr->hrgnUpdate = 1;
738 GETCLIENTRECTW( wndPtr, r2 );
743 else if (flags & RDW_VALIDATE) /* ------------------------- Validate */
745 /* In this we cannot leave with zero hRgn */
748 hRgn = REGION_CropRgn( hRgn, hrgnUpdate, &r, &pt );
749 GetRgnBox( hRgn, &r2 );
750 if( IsRectEmpty( &r2 ) ) goto END;
752 else if( rectUpdate )
754 if( !IntersectRect( &r2, &r, rectUpdate ) ) goto END;
755 OffsetRect( &r2, pt.x, pt.y );
757 hRgn = CreateRectRgnIndirect( &r2 );
759 else /* entire window or client depending on RDW_FRAME */
761 if( flags & RDW_FRAME )
765 GETCLIENTRECTW( wndPtr, r2 );
771 /* At this point hRgn is either an update region in window coordinates or 1 or 0 */
773 RDW_UpdateRgns( wndPtr, hRgn, flags );
775 /* Erase/update windows, from now on hRgn is a scratch region */
777 hRgn = RDW_Paint( wndPtr, (hRgn == 1) ? 0 : hRgn, flags, ex );
780 if( hRgn > 1 && (hRgn != hrgnUpdate) )
782 WIN_ReleaseWndPtr(wndPtr);
787 /***********************************************************************
788 * RedrawWindow32 (USER32.426)
790 BOOL WINAPI RedrawWindow( HWND hwnd, const RECT *rectUpdate,
791 HRGN hrgnUpdate, UINT flags )
793 return PAINT_RedrawWindow( hwnd, rectUpdate, hrgnUpdate, flags, 0 );
797 /***********************************************************************
798 * RedrawWindow16 (USER.290)
800 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
801 HRGN16 hrgnUpdate, UINT16 flags )
806 CONV_RECT16TO32( rectUpdate, &r );
807 return (BOOL16)RedrawWindow( (HWND)hwnd, &r, hrgnUpdate, flags );
809 return (BOOL16)PAINT_RedrawWindow( (HWND)hwnd, NULL,
810 (HRGN)hrgnUpdate, flags, 0 );
814 /***********************************************************************
815 * UpdateWindow16 (USER.124)
817 void WINAPI UpdateWindow16( HWND16 hwnd )
819 PAINT_RedrawWindow( hwnd, NULL, 0, RDW_UPDATENOW | RDW_NOCHILDREN, 0 );
822 /***********************************************************************
823 * UpdateWindow32 (USER32.567)
825 void WINAPI UpdateWindow( HWND hwnd )
827 PAINT_RedrawWindow( hwnd, NULL, 0, RDW_UPDATENOW | RDW_NOCHILDREN, 0 );
830 /***********************************************************************
831 * InvalidateRgn16 (USER.126)
833 void WINAPI InvalidateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
835 PAINT_RedrawWindow((HWND)hwnd, NULL, (HRGN)hrgn,
836 RDW_INVALIDATE | (erase ? RDW_ERASE : 0), 0 );
840 /***********************************************************************
841 * InvalidateRgn32 (USER32.329)
843 BOOL WINAPI InvalidateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
845 return PAINT_RedrawWindow(hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0), 0 );
849 /***********************************************************************
850 * InvalidateRect16 (USER.125)
852 void WINAPI InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
854 RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
858 /***********************************************************************
859 * InvalidateRect32 (USER32.328)
861 BOOL WINAPI InvalidateRect( HWND hwnd, const RECT *rect, BOOL erase )
863 return PAINT_RedrawWindow( hwnd, rect, 0,
864 RDW_INVALIDATE | (erase ? RDW_ERASE : 0), 0 );
868 /***********************************************************************
869 * ValidateRgn16 (USER.128)
871 void WINAPI ValidateRgn16( HWND16 hwnd, HRGN16 hrgn )
873 PAINT_RedrawWindow( (HWND)hwnd, NULL, (HRGN)hrgn,
874 RDW_VALIDATE | RDW_NOCHILDREN, 0 );
878 /***********************************************************************
879 * ValidateRgn32 (USER32.572)
881 void WINAPI ValidateRgn( HWND hwnd, HRGN hrgn )
883 PAINT_RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN, 0 );
887 /***********************************************************************
888 * ValidateRect16 (USER.127)
890 void WINAPI ValidateRect16( HWND16 hwnd, const RECT16 *rect )
892 RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
896 /***********************************************************************
897 * ValidateRect32 (USER32.571)
899 void WINAPI ValidateRect( HWND hwnd, const RECT *rect )
901 PAINT_RedrawWindow( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN, 0 );
905 /***********************************************************************
906 * GetUpdateRect16 (USER.190)
908 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
913 if (!rect) return GetUpdateRect( hwnd, NULL, erase );
914 ret = GetUpdateRect( hwnd, &r, erase );
915 CONV_RECT32TO16( &r, rect );
920 /***********************************************************************
921 * GetUpdateRect32 (USER32.297)
923 BOOL WINAPI GetUpdateRect( HWND hwnd, LPRECT rect, BOOL erase )
926 WND * wndPtr = WIN_FindWndPtr( hwnd );
927 if (!wndPtr) return FALSE;
931 if (wndPtr->hrgnUpdate > 1)
933 HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
934 if (GetUpdateRgn( hwnd, hrgn, erase ) == ERROR)
939 GetRgnBox( hrgn, rect );
940 DeleteObject( hrgn );
941 if (GetClassLongA(wndPtr->hwndSelf, GCL_STYLE) & CS_OWNDC)
943 if (GetMapMode(wndPtr->dce->hDC) != MM_TEXT)
945 DPtoLP (wndPtr->dce->hDC, (LPPOINT)rect, 2);
950 if( wndPtr->hrgnUpdate == 1 )
952 GetClientRect( hwnd, rect );
953 if (erase) RedrawWindow( hwnd, NULL, 0, RDW_FRAME | RDW_ERASENOW | RDW_NOCHILDREN );
956 SetRectEmpty( rect );
958 retvalue = (wndPtr->hrgnUpdate >= 1);
960 WIN_ReleaseWndPtr(wndPtr);
965 /***********************************************************************
966 * GetUpdateRgn16 (USER.237)
968 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
970 return GetUpdateRgn( hwnd, hrgn, erase );
974 /***********************************************************************
975 * GetUpdateRgn (USER32.298)
977 INT WINAPI GetUpdateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
980 WND * wndPtr = WIN_FindWndPtr( hwnd );
981 if (!wndPtr) return ERROR;
983 if (wndPtr->hrgnUpdate == 0)
985 SetRectRgn( hrgn, 0, 0, 0, 0 );
990 if (wndPtr->hrgnUpdate == 1)
992 SetRectRgn( hrgn, 0, 0, wndPtr->rectClient.right - wndPtr->rectClient.left,
993 wndPtr->rectClient.bottom - wndPtr->rectClient.top );
994 retval = SIMPLEREGION;
998 retval = CombineRgn( hrgn, wndPtr->hrgnUpdate, 0, RGN_COPY );
999 OffsetRgn( hrgn, wndPtr->rectWindow.left - wndPtr->rectClient.left,
1000 wndPtr->rectWindow.top - wndPtr->rectClient.top );
1002 if (erase) RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW | RDW_NOCHILDREN );
1004 WIN_ReleaseWndPtr(wndPtr);
1009 /***********************************************************************
1010 * ExcludeUpdateRgn16 (USER.238)
1012 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
1014 return ExcludeUpdateRgn( hdc, hwnd );
1018 /***********************************************************************
1019 * ExcludeUpdateRgn32 (USER32.195)
1021 INT WINAPI ExcludeUpdateRgn( HDC hdc, HWND hwnd )
1026 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return ERROR;
1028 if (wndPtr->hrgnUpdate)
1031 HRGN hrgn = CreateRectRgn(wndPtr->rectWindow.left - wndPtr->rectClient.left,
1032 wndPtr->rectWindow.top - wndPtr->rectClient.top,
1033 wndPtr->rectWindow.right - wndPtr->rectClient.left,
1034 wndPtr->rectWindow.bottom - wndPtr->rectClient.top);
1035 if( wndPtr->hrgnUpdate > 1 )
1037 CombineRgn(hrgn, wndPtr->hrgnUpdate, 0, RGN_COPY);
1038 OffsetRgn(hrgn, wndPtr->rectWindow.left - wndPtr->rectClient.left,
1039 wndPtr->rectWindow.top - wndPtr->rectClient.top );
1042 /* do ugly coordinate translations in dce.c */
1044 ret = DCE_ExcludeRgn( hdc, wndPtr, hrgn );
1045 DeleteObject( hrgn );
1046 WIN_ReleaseWndPtr(wndPtr);
1049 WIN_ReleaseWndPtr(wndPtr);
1050 return GetClipBox( hdc, &rect );