git.oblomov.eu Git - wine/blob - windows/painting.c

   1 /*
   2  * Window painting functions
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   5  *                       1999 Alex Korobka
   6  *
   7  */
   8
   9 #include "region.h"
  10 #include "win.h"
  11 #include "queue.h"
  12 #include "dce.h"
  13 #include "heap.h"
  14 #include "debug.h"
  15 #include "wine/winuser16.h"
  16
  17 /* client rect in window coordinates */
  18
  19 #define GETCLIENTRECTW( wnd, r )        (r).left = (wnd)->rectClient.left - (wnd)->rectWindow.left; \
  20                                         (r).top = (wnd)->rectClient.top - (wnd)->rectWindow.top; \
  21                                         (r).right = (wnd)->rectClient.right - (wnd)->rectWindow.left; \
  22                                         (r).bottom = (wnd)->rectClient.bottom - (wnd)->rectWindow.top
  23
  24   /* Last CTLCOLOR id */
  25 #define CTLCOLOR_MAX   CTLCOLOR_STATIC
  26
  27
  28 /***********************************************************************
  29  *           WIN_UpdateNCRgn
  30  *
  31  * NOTE: Caller is responsible for the returned region.
  32  */
  33 HRGN WIN_UpdateNCRgn(WND* wnd, BOOL bUpdate, BOOL bForceEntire )
  34 {
  35     HRGN hClip = 0;
  36
  37     TRACE(nonclient,"hwnd %04x, hrgnUpdate %04x, ncf %i\n",
  38                       wnd->hwndSelf, wnd->hrgnUpdate, (wnd->flags & WIN_NEEDS_NCPAINT)!=0 );
  39
  40     /* desktop window doesn't have nonclient area */
  41     if(wnd == WIN_GetDesktop())
  42     {
  43         wnd->flags &= ~WIN_NEEDS_NCPAINT;
  44         WIN_ReleaseDesktop();
  45         return 0;
  46     }
  47     WIN_ReleaseDesktop();
  48
  49     if ((wnd->hwndSelf == GetActiveWindow()) &&
  50         !(wnd->flags & WIN_NCACTIVATED) )
  51     {
  52         wnd->flags |= WIN_NCACTIVATED;
  53         bForceEntire = TRUE;
  54     }
  55
  56     if( (wnd->flags & WIN_NEEDS_NCPAINT) && wnd->hrgnUpdate )
  57     {
  58         RECT r, r2, r3;
  59
  60         GETCLIENTRECTW( wnd, r );
  61
  62         TRACE(nonclient, "\tclient box (%i,%i-%i,%i)\n", r.left, r.top, r.right, r.bottom );
  63
  64         if( wnd->hrgnUpdate > 1 )
  65         {
  66                 GetRgnBox( wnd->hrgnUpdate, &r2 );
  67                 UnionRect( &r3, &r2, &r );
  68                 if( r3.left != r.left || r3.top != r.top ||
  69                     r3.right != r.right || r3.bottom != r.bottom )
  70                 {
  71                     hClip = CreateRectRgn( 0, 0, 0, 0 );
  72                     CombineRgn( hClip, wnd->hrgnUpdate, 0, RGN_COPY );
  73                 }
  74         }
  75         else
  76                 hClip = wnd->hrgnUpdate;
  77
  78         if( wnd->hrgnUpdate > 1 )
  79         {
  80             REGION_CropRgn( wnd->hrgnUpdate, wnd->hrgnUpdate, &r, NULL );
  81
  82             if( bUpdate )
  83             {
  84                 GetRgnBox( wnd->hrgnUpdate, &r3 );
  85                 if( IsRectEmpty( &r3 ) )
  86                 {
  87                     /* delete update region since all invalid
  88                      * parts were in the nonclient area */
  89
  90                     DeleteObject( wnd->hrgnUpdate );
  91                     wnd->hrgnUpdate = 0;
  92                     if(!(wnd->flags & WIN_INTERNAL_PAINT))
  93                         QUEUE_DecPaintCount( wnd->hmemTaskQ );
  94                     wnd->flags &= ~WIN_NEEDS_ERASEBKGND;
  95                 }
  96             }
  97         }
  98         else /* entire client rect */
  99            wnd->hrgnUpdate = CreateRectRgnIndirect( &r );
 100     }
 101
 102     if(!hClip && bForceEntire ) hClip = 1;
 103     wnd->flags &= ~WIN_NEEDS_NCPAINT;
 104
 105     if( hClip )
 106         SendMessageA( wnd->hwndSelf, WM_NCPAINT, hClip, 0L );
 107
 108     return hClip;
 109 }
 110
 111
 112 /***********************************************************************
 113  *           BeginPaint16    (USER.39)
 114  */
 115 HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
 116 {
 117     BOOL bIcon;
 118     HRGN hrgnUpdate;
 119     WND *wndPtr = WIN_FindWndPtr( hwnd );
 120     if (!wndPtr) return 0;
 121
 122     bIcon = (wndPtr->dwStyle & WS_MINIMIZE && wndPtr->class->hIcon);
 123
 124     wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
 125
 126     if( (hrgnUpdate = WIN_UpdateNCRgn( wndPtr, FALSE, FALSE )) > 1 )
 127         DeleteObject( hrgnUpdate );
 128
 129     if( ((hrgnUpdate = wndPtr->hrgnUpdate) != 0) || (wndPtr->flags & WIN_INTERNAL_PAINT))
 130         QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 131
 132     wndPtr->hrgnUpdate = 0;
 133     wndPtr->flags &= ~WIN_INTERNAL_PAINT;
 134
 135     HideCaret( hwnd );
 136
 137     TRACE(win,"hrgnUpdate = %04x, \n", hrgnUpdate);
 138
 139     if (wndPtr->class->style & CS_PARENTDC)
 140     {
 141         /* Don't clip the output to the update region for CS_PARENTDC window */
 142         if( hrgnUpdate > 1 )
 143             DeleteObject(hrgnUpdate);
 144         lps->hdc = GetDCEx16( hwnd, 0, DCX_WINDOWPAINT | DCX_USESTYLE |
 145                               (bIcon ? DCX_WINDOW : 0) );
 146     }
 147     else
 148     {
 149         if( hrgnUpdate )
 150             OffsetRgn( hrgnUpdate, wndPtr->rectWindow.left - wndPtr->rectClient.left,
 151                                    wndPtr->rectWindow.top - wndPtr->rectClient.top );
 152         lps->hdc = GetDCEx16(hwnd, hrgnUpdate, DCX_INTERSECTRGN |
 153                              DCX_WINDOWPAINT | DCX_USESTYLE |
 154                              (bIcon ? DCX_WINDOW : 0) );
 155     }
 156
 157     TRACE(win,"hdc = %04x\n", lps->hdc);
 158
 159     if (!lps->hdc)
 160     {
 161         WARN(win, "GetDCEx() failed in BeginPaint(), hwnd=%04x\n", hwnd);
 162         WIN_ReleaseWndPtr(wndPtr);
 163         return 0;
 164     }
 165
 166     GetClipBox16( lps->hdc, &lps->rcPaint );
 167
 168     TRACE(win,"box = (%i,%i - %i,%i)\n", lps->rcPaint.left, lps->rcPaint.top,
 169                     lps->rcPaint.right, lps->rcPaint.bottom );
 170
 171     if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
 172     {
 173         wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 174         lps->fErase = !SendMessage16(hwnd, (bIcon) ? WM_ICONERASEBKGND
 175                                                    : WM_ERASEBKGND,
 176                                      (WPARAM16)lps->hdc, 0 );
 177     }
 178     else lps->fErase = TRUE;
 179
 180     WIN_ReleaseWndPtr(wndPtr);
 181     return lps->hdc;
 182 }
 183
 184
 185 /***********************************************************************
 186  *           BeginPaint32    (USER32.10)
 187  */
 188 HDC WINAPI BeginPaint( HWND hwnd, PAINTSTRUCT *lps )
 189 {
 190     PAINTSTRUCT16 ps;
 191
 192     BeginPaint16( hwnd, &ps );
 193     lps->hdc            = (HDC)ps.hdc;
 194     lps->fErase         = ps.fErase;
 195     lps->rcPaint.top    = ps.rcPaint.top;
 196     lps->rcPaint.left   = ps.rcPaint.left;
 197     lps->rcPaint.right  = ps.rcPaint.right;
 198     lps->rcPaint.bottom = ps.rcPaint.bottom;
 199     lps->fRestore       = ps.fRestore;
 200     lps->fIncUpdate     = ps.fIncUpdate;
 201     return lps->hdc;
 202 }
 203
 204
 205 /***********************************************************************
 206  *           EndPaint16    (USER.40)
 207  */
 208 BOOL16 WINAPI EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
 209 {
 210     ReleaseDC16( hwnd, lps->hdc );
 211     ShowCaret( hwnd );
 212     return TRUE;
 213 }
 214
 215
 216 /***********************************************************************
 217  *           EndPaint32    (USER32.176)
 218  */
 219 BOOL WINAPI EndPaint( HWND hwnd, const PAINTSTRUCT *lps )
 220 {
 221     ReleaseDC( hwnd, lps->hdc );
 222     ShowCaret( hwnd );
 223     return TRUE;
 224 }
 225
 226
 227 /***********************************************************************
 228  *           FillWindow    (USER.324)
 229  */
 230 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
 231 {
 232     RECT16 rect;
 233     GetClientRect16( hwnd, &rect );
 234     DPtoLP16( hdc, (LPPOINT16)&rect, 2 );
 235     PaintRect16( hwndParent, hwnd, hdc, hbrush, &rect );
 236 }
 237
 238
 239 /***********************************************************************
 240  *           PAINT_GetControlBrush
 241  */
 242 static HBRUSH16 PAINT_GetControlBrush( HWND hParent, HWND hWnd, HDC16 hDC, UINT16 ctlType )
 243 {
 244     HBRUSH16 bkgBrush = (HBRUSH16)SendMessageA( hParent, WM_CTLCOLORMSGBOX + ctlType,
 245                                                              (WPARAM)hDC, (LPARAM)hWnd );
 246     if( !IsGDIObject16(bkgBrush) )
 247         bkgBrush = DEFWND_ControlColor( hDC, ctlType );
 248     return bkgBrush;
 249 }
 250
 251
 252 /***********************************************************************
 253  *           PaintRect    (USER.325)
 254  */
 255 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
 256                        HBRUSH16 hbrush, const RECT16 *rect)
 257 {
 258     if( hbrush <= CTLCOLOR_MAX )
 259     {
 260         if( hwndParent )
 261             hbrush = PAINT_GetControlBrush( hwndParent, hwnd, hdc, (UINT16)hbrush );
 262         else
 263             return;
 264     }
 265     if( hbrush )
 266         FillRect16( hdc, rect, hbrush );
 267 }
 268
 269
 270 /***********************************************************************
 271  *           GetControlBrush    (USER.326)
 272  */
 273 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
 274 {
 275     WND* wndPtr = WIN_FindWndPtr( hwnd );
 276     HBRUSH16 retvalue;
 277
 278     if((ctlType <= CTLCOLOR_MAX) && wndPtr )
 279     {
 280         WND* parent;
 281         if( wndPtr->dwStyle & WS_POPUP ) parent = WIN_LockWndPtr(wndPtr->owner);
 282         else parent = WIN_LockWndPtr(wndPtr->parent);
 283         if( !parent ) parent = wndPtr;
 284         retvalue = (HBRUSH16)PAINT_GetControlBrush( parent->hwndSelf, hwnd, hdc, ctlType );
 285         WIN_ReleaseWndPtr(parent);
 286         goto END;
 287     }
 288     retvalue = (HBRUSH16)0;
 289 END:
 290     WIN_ReleaseWndPtr(wndPtr);
 291     return retvalue;
 292     }
 293
 294
 295 /***********************************************************************
 296  *           PAINT_RedrawWindow
 297  *
 298  * FIXME: Windows uses WM_SYNCPAINT to cut down the number of intertask
 299  * SendMessage() calls. This is a comment inside DefWindowProc() source
 300  * from 16-bit SDK:
 301  *
 302  *   This message avoids lots of inter-app message traffic
 303  *   by switching to the other task and continuing the
 304  *   recursion there.
 305  *
 306  * wParam         = flags
 307  * LOWORD(lParam) = hrgnClip
 308  * HIWORD(lParam) = hwndSkip  (not used; always NULL)
 309  *
 310  */
 311 BOOL PAINT_RedrawWindow( HWND hwnd, const RECT *rectUpdate,
 312                            HRGN hrgnUpdate, UINT flags, UINT ex )
 313 {
 314     BOOL bIcon;
 315     HRGN hrgn = 0, hrgn2 = 0;
 316     RECT r, r2;
 317     POINT pt;
 318     WND* wndPtr;
 319     WND **list, **ppWnd;
 320
 321     if (!hwnd) hwnd = GetDesktopWindow();
 322     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 323     if (!WIN_IsWindowDrawable( wndPtr, !(flags & RDW_FRAME) ) )
 324     {
 325         WIN_ReleaseWndPtr(wndPtr);
 326         return TRUE;  /* No redraw needed */
 327     }
 328
 329     bIcon = (wndPtr->dwStyle & WS_MINIMIZE && wndPtr->class->hIcon);
 330     if (rectUpdate)
 331     {
 332         TRACE(win, "%04x (%04x) %d,%d-%d,%d %04x flags=%04x, exflags=%04x\n",
 333                     hwnd, wndPtr->hrgnUpdate, rectUpdate->left, rectUpdate->top,
 334                     rectUpdate->right, rectUpdate->bottom, hrgnUpdate, flags, ex );
 335     }
 336     else
 337     {
 338         if( hrgnUpdate ) GetRgnBox( hrgnUpdate, &r );
 339         else SetRectEmpty( &r );
 340         TRACE(win, "%04x (%04x) NULL %04x box (%i,%i-%i,%i) flags=%04x, exflags=%04x\n",
 341               hwnd, wndPtr->hrgnUpdate, hrgnUpdate, r.left, r.top, r.right, r.bottom, flags, ex);
 342     }
 343
 344     if( flags & RDW_FRAME )
 345         r = wndPtr->rectWindow;
 346     else
 347         r = wndPtr->rectClient;
 348     if( ex & RDW_EX_XYWINDOW )
 349         OffsetRect( &r, -wndPtr->rectWindow.left, -wndPtr->rectWindow.top );
 350     else
 351         OffsetRect( &r, -wndPtr->rectClient.left, -wndPtr->rectClient.top );
 352
 353     /* r is the rectangle we crop the supplied update rgn/rect with */
 354
 355     GETCLIENTRECTW( wndPtr, r2 );
 356     pt.x = r2.left; pt.y = r2.top;
 357
 358     if (flags & RDW_INVALIDATE)  /* ------------------------- Invalidate */
 359     {
 360         BOOL bHasUpdateRgn = (BOOL)wndPtr->hrgnUpdate;
 361
 362         /* wndPtr->hrgnUpdate is in window coordinates, parameters are
 363          * in client coordinates unless RDW_EX_XYWINDOW is set.
 364          */
 365
 366         if( hrgnUpdate )
 367         {
 368             hrgn = REGION_CropRgn( 0, hrgnUpdate, &r, (ex & RDW_EX_XYWINDOW) ? NULL : &pt );
 369             GetRgnBox( hrgn, &r2 );
 370             if( IsRectEmpty( &r2 ) )
 371                 goto END;
 372
 373             if( wndPtr->hrgnUpdate == 0 )
 374             {
 375                 wndPtr->hrgnUpdate = CreateRectRgn( 0, 0, 0, 0 );
 376                 CombineRgn( wndPtr->hrgnUpdate, hrgn, 0, RGN_COPY );
 377             }
 378             else
 379                 if( wndPtr->hrgnUpdate > 1 )
 380                     CombineRgn( wndPtr->hrgnUpdate, wndPtr->hrgnUpdate, hrgn, RGN_OR );
 381         }
 382         else if( rectUpdate )
 383         {
 384             if( !IntersectRect( &r2, &r, rectUpdate ) )
 385                 goto END;
 386             if( !(ex & RDW_EX_XYWINDOW) )
 387                 OffsetRect( &r2, pt.x, pt.y );
 388
 389 rect2i:     /* r2 contains a rect to add to the update region */
 390
 391             hrgn = CreateRectRgnIndirect( &r2 );
 392             if( wndPtr->hrgnUpdate == 0 )
 393                 wndPtr->hrgnUpdate = CreateRectRgnIndirect( &r2 );
 394             else
 395                 if( wndPtr->hrgnUpdate > 1 )
 396                     REGION_UnionRectWithRgn( wndPtr->hrgnUpdate, &r2 );
 397         }
 398         else /* entire window or client depending on RDW_FRAME */
 399         {
 400             hrgn = 1;
 401             if( flags & RDW_FRAME )
 402             {
 403                 if( wndPtr->hrgnUpdate )
 404                     DeleteObject( wndPtr->hrgnUpdate );
 405                 wndPtr->hrgnUpdate = 1;
 406             }
 407             else /* by default r2 contains client rect in window coordinates */
 408                 goto rect2i;
 409         }
 410
 411         if( !bHasUpdateRgn && wndPtr->hrgnUpdate && !(wndPtr->flags & WIN_INTERNAL_PAINT))
 412             QUEUE_IncPaintCount( wndPtr->hmemTaskQ );
 413
 414         if (flags & RDW_FRAME) wndPtr->flags |= WIN_NEEDS_NCPAINT;
 415         if (flags & RDW_ERASE) wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
 416         flags |= RDW_FRAME;  /* Force children frame invalidation */
 417     }
 418     else if (flags & RDW_VALIDATE)  /* ------------------------- Validate */
 419     {
 420         if (wndPtr->hrgnUpdate) /* need an update region in order to validate anything */
 421         {
 422             if( hrgnUpdate || rectUpdate )
 423             {
 424                 if( hrgnUpdate )
 425                 {
 426                     hrgn = REGION_CropRgn( hrgn, hrgnUpdate,  &r, (ex & RDW_EX_XYWINDOW) ? NULL : &pt );
 427                     GetRgnBox( hrgn, &r2 );
 428                     if( IsRectEmpty( &r2 ) )
 429                         goto END;
 430                 }
 431                 else
 432                 {
 433                     if( !IntersectRect( &r2, &r, rectUpdate ) )
 434                         goto END;
 435                     if( !(ex & RDW_EX_XYWINDOW) )
 436                         OffsetRect( &r2, pt.x, pt.y );
 437 rect2v:
 438                     hrgn = CreateRectRgnIndirect( &r2 );
 439                 }
 440
 441                 if( wndPtr->hrgnUpdate == 1 )
 442                 {
 443                     wndPtr->hrgnUpdate = CreateRectRgn( 0, 0,
 444                                          wndPtr->rectWindow.right - wndPtr->rectWindow.left,
 445                                          wndPtr->rectWindow.bottom - wndPtr->rectWindow.top );
 446                 }
 447
 448                 if( CombineRgn( wndPtr->hrgnUpdate,
 449                                 wndPtr->hrgnUpdate, hrgn, RGN_DIFF ) == NULLREGION )
 450                 {
 451                     DeleteObject( wndPtr->hrgnUpdate );
 452                     wndPtr->hrgnUpdate = 0;
 453                 }
 454             }
 455             else /* entire window or client depending on RDW_FRAME */
 456             {
 457                 wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 458
 459                 hrgn = 1;
 460                 if( flags & RDW_FRAME )
 461                 {
 462                     if( wndPtr->hrgnUpdate != 1 )
 463                         DeleteObject( wndPtr->hrgnUpdate );
 464                     wndPtr->hrgnUpdate = 0;
 465                 }
 466                 else /* by default r2 contains client rect in window coordinates */
 467                     goto rect2v;
 468             }
 469
 470             if (!wndPtr->hrgnUpdate &&  /* No more update region */
 471                 !(wndPtr->flags & WIN_INTERNAL_PAINT) )
 472                     QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 473         }
 474         if (flags & RDW_NOFRAME) wndPtr->flags &= ~WIN_NEEDS_NCPAINT;
 475         if (flags & RDW_NOERASE) wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 476     }
 477
 478     /* At this point hrgn contains new update region in window coordinates */
 479
 480     /* Set/clear internal paint flag */
 481
 482     if (flags & RDW_INTERNALPAINT)
 483     {
 484         if ( !wndPtr->hrgnUpdate && !(wndPtr->flags & WIN_INTERNAL_PAINT))
 485             QUEUE_IncPaintCount( wndPtr->hmemTaskQ );
 486         wndPtr->flags |= WIN_INTERNAL_PAINT;
 487     }
 488     else if (flags & RDW_NOINTERNALPAINT)
 489     {
 490         if ( !wndPtr->hrgnUpdate && (wndPtr->flags & WIN_INTERNAL_PAINT))
 491             QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 492         wndPtr->flags &= ~WIN_INTERNAL_PAINT;
 493     }
 494
 495       /* Erase/update window */
 496
 497     if (flags & RDW_UPDATENOW)
 498     {
 499         if (wndPtr->hrgnUpdate) /* wm_painticon wparam is 1 */
 500             SendMessage16( hwnd, (bIcon) ? WM_PAINTICON : WM_PAINT, bIcon, 0 );
 501     }
 502     else if ((flags & RDW_ERASENOW) || (ex & RDW_EX_TOPFRAME))
 503     {
 504         hrgn2 = WIN_UpdateNCRgn( wndPtr, TRUE, (ex & RDW_EX_TOPFRAME) );
 505
 506         if( wndPtr->flags & WIN_NEEDS_ERASEBKGND )
 507         {
 508             HDC hdc;
 509
 510             if( hrgn2 > 1 )
 511             {
 512                 OffsetRgn( hrgn2, -pt.x, -pt.y );
 513                 GetRgnBox( hrgn2, &r2 );
 514             }
 515             else
 516             {
 517                 hrgn2 = CreateRectRgn( 0, 0, 0, 0 );
 518                 CombineRgn( hrgn2, wndPtr->hrgnUpdate, 0, RGN_COPY );
 519                 OffsetRgn( hrgn2, -pt.x, -pt.y );
 520             }
 521             hdc = GetDCEx( hwnd, hrgn2,
 522                                  DCX_INTERSECTRGN | DCX_USESTYLE |
 523                                  DCX_KEEPCLIPRGN | DCX_WINDOWPAINT |
 524                                  (bIcon ? DCX_WINDOW : 0) );
 525             if (hdc)
 526             {
 527                if (SendMessage16( hwnd, (bIcon) ? WM_ICONERASEBKGND
 528                                                 : WM_ERASEBKGND,
 529                                   (WPARAM16)hdc, 0 ))
 530                   wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 531                ReleaseDC( hwnd, hdc );
 532             }
 533         }
 534     }
 535
 536     if ( !IsWindow( hwnd ) )
 537     {
 538         WIN_ReleaseWndPtr(wndPtr);
 539         return TRUE;
 540     }
 541
 542       /* Recursively process children */
 543
 544     if (!(flags & RDW_NOCHILDREN) &&
 545         ((flags & RDW_ALLCHILDREN) || !(wndPtr->dwStyle & WS_CLIPCHILDREN)) &&
 546         !(wndPtr->dwStyle & WS_MINIMIZE) )
 547     {
 548         if( hrgnUpdate || rectUpdate )
 549         {
 550            if( hrgn2 <= 1 )
 551                hrgn2 = (ex & RDW_EX_USEHRGN) ? hrgnUpdate : 0;
 552
 553            if( (list = WIN_BuildWinArray( wndPtr, 0, NULL )) )
 554            {
 555                 POINT   delta = pt;
 556
 557                 for (ppWnd = list; *ppWnd; ppWnd++)
 558                 {
 559                     WIN_UpdateWndPtr(&wndPtr,*ppWnd);
 560                     if (!IsWindow(wndPtr->hwndSelf)) continue;
 561                     if (wndPtr->dwStyle & WS_VISIBLE)
 562                     {
 563                         r.left = wndPtr->rectWindow.left + delta.x;
 564                         r.top = wndPtr->rectWindow.top + delta.y;
 565                         r.right = wndPtr->rectWindow.right + delta.x;
 566                         r.bottom = wndPtr->rectWindow.bottom + delta.y;
 567
 568                         pt.x = -r.left; pt.y = -r.top;
 569
 570                         hrgn2 = REGION_CropRgn( hrgn2, hrgn, &r, &pt );
 571
 572                         GetRgnBox( hrgn2, &r2 );
 573                         if( !IsRectEmpty( &r2 ) )
 574                         {
 575                             PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, hrgn2, flags,
 576                                                 RDW_EX_USEHRGN | RDW_EX_XYWINDOW );
 577                         }
 578                     }
 579                 }
 580                 WIN_ReleaseWinArray(list);
 581            }
 582         }
 583         else
 584         {
 585             if( (list = WIN_BuildWinArray( wndPtr, 0, NULL )) )
 586             {
 587                 for (ppWnd = list; *ppWnd; ppWnd++)
 588                 {
 589                     WIN_UpdateWndPtr(&wndPtr,*ppWnd);
 590                     if (IsWindow( wndPtr->hwndSelf ))
 591                         PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, 0, flags, 0 );
 592                 }
 593                 WIN_ReleaseWinArray(list);
 594             }
 595         }
 596
 597     }
 598
 599 END:
 600     if( hrgn2 > 1 && (hrgn2 != hrgnUpdate) )
 601         DeleteObject( hrgn2 );
 602     if( hrgn > 1 && (hrgn != hrgnUpdate) )
 603         DeleteObject( hrgn );
 604     WIN_ReleaseWndPtr(wndPtr);
 605     return TRUE;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           RedrawWindow32    (USER32.426)
 611  */
 612 BOOL WINAPI RedrawWindow( HWND hwnd, const RECT *rectUpdate,
 613                               HRGN hrgnUpdate, UINT flags )
 614 {
 615     return PAINT_RedrawWindow( hwnd, rectUpdate, hrgnUpdate, flags, 0 );
 616 }
 617
 618
 619 /***********************************************************************
 620  *           RedrawWindow16    (USER.290)
 621  */
 622 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
 623                               HRGN16 hrgnUpdate, UINT16 flags )
 624 {
 625     if (rectUpdate)
 626     {
 627         RECT r;
 628         CONV_RECT16TO32( rectUpdate, &r );
 629         return (BOOL16)RedrawWindow( (HWND)hwnd, &r, hrgnUpdate, flags );
 630     }
 631     return (BOOL16)PAINT_RedrawWindow( (HWND)hwnd, NULL,
 632                                        (HRGN)hrgnUpdate, flags, 0 );
 633 }
 634
 635
 636 /***********************************************************************
 637  *           UpdateWindow16   (USER.124)
 638  */
 639 void WINAPI UpdateWindow16( HWND16 hwnd )
 640 {
 641     PAINT_RedrawWindow( hwnd, NULL, 0, RDW_UPDATENOW | RDW_NOCHILDREN, 0 );
 642 }
 643
 644 /***********************************************************************
 645  *           UpdateWindow32   (USER32.567)
 646  */
 647 void WINAPI UpdateWindow( HWND hwnd )
 648 {
 649     PAINT_RedrawWindow( hwnd, NULL, 0, RDW_UPDATENOW | RDW_NOCHILDREN, 0 );
 650 }
 651
 652 /***********************************************************************
 653  *           InvalidateRgn16   (USER.126)
 654  */
 655 void WINAPI InvalidateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
 656 {
 657     PAINT_RedrawWindow((HWND)hwnd, NULL, (HRGN)hrgn,
 658                        RDW_INVALIDATE | (erase ? RDW_ERASE : 0), 0 );
 659 }
 660
 661
 662 /***********************************************************************
 663  *           InvalidateRgn32   (USER32.329)
 664  */
 665 BOOL WINAPI InvalidateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
 666 {
 667     return PAINT_RedrawWindow(hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0), 0 );
 668 }
 669
 670
 671 /***********************************************************************
 672  *           InvalidateRect16   (USER.125)
 673  */
 674 void WINAPI InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
 675 {
 676     RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 677 }
 678
 679
 680 /***********************************************************************
 681  *           InvalidateRect32   (USER32.328)
 682  */
 683 BOOL WINAPI InvalidateRect( HWND hwnd, const RECT *rect, BOOL erase )
 684 {
 685     return PAINT_RedrawWindow( hwnd, rect, 0,
 686                                RDW_INVALIDATE | (erase ? RDW_ERASE : 0), 0 );
 687 }
 688
 689
 690 /***********************************************************************
 691  *           ValidateRgn16   (USER.128)
 692  */
 693 void WINAPI ValidateRgn16( HWND16 hwnd, HRGN16 hrgn )
 694 {
 695     PAINT_RedrawWindow( (HWND)hwnd, NULL, (HRGN)hrgn,
 696                         RDW_VALIDATE | RDW_NOCHILDREN, 0 );
 697 }
 698
 699
 700 /***********************************************************************
 701  *           ValidateRgn32   (USER32.572)
 702  */
 703 void WINAPI ValidateRgn( HWND hwnd, HRGN hrgn )
 704 {
 705     PAINT_RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN, 0 );
 706 }
 707
 708
 709 /***********************************************************************
 710  *           ValidateRect16   (USER.127)
 711  */
 712 void WINAPI ValidateRect16( HWND16 hwnd, const RECT16 *rect )
 713 {
 714     RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 715 }
 716
 717
 718 /***********************************************************************
 719  *           ValidateRect32   (USER32.571)
 720  */
 721 void WINAPI ValidateRect( HWND hwnd, const RECT *rect )
 722 {
 723     PAINT_RedrawWindow( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN, 0 );
 724 }
 725
 726
 727 /***********************************************************************
 728  *           GetUpdateRect16   (USER.190)
 729  */
 730 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
 731 {
 732     RECT r;
 733     BOOL16 ret;
 734
 735     if (!rect) return GetUpdateRect( hwnd, NULL, erase );
 736     ret = GetUpdateRect( hwnd, &r, erase );
 737     CONV_RECT32TO16( &r, rect );
 738     return ret;
 739 }
 740
 741
 742 /***********************************************************************
 743  *           GetUpdateRect32   (USER32.297)
 744  */
 745 BOOL WINAPI GetUpdateRect( HWND hwnd, LPRECT rect, BOOL erase )
 746 {
 747     BOOL retvalue;
 748     WND * wndPtr = WIN_FindWndPtr( hwnd );
 749     if (!wndPtr) return FALSE;
 750
 751     if (rect)
 752     {
 753         if (wndPtr->hrgnUpdate > 1)
 754         {
 755             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 756             if (GetUpdateRgn( hwnd, hrgn, erase ) == ERROR)
 757             {
 758                 retvalue = FALSE;
 759                 goto END;
 760             }
 761             GetRgnBox( hrgn, rect );
 762             DeleteObject( hrgn );
 763             if (wndPtr->class->style & CS_OWNDC)
 764             {
 765                 if (GetMapMode(wndPtr->dce->hDC) != MM_TEXT)
 766                 {
 767                     DPtoLP (wndPtr->dce->hDC, (LPPOINT)rect,  2);
 768                 }
 769             }
 770         }
 771         else
 772         if( wndPtr->hrgnUpdate == 1 )
 773         {
 774             GetClientRect( hwnd, rect );
 775             if (erase) RedrawWindow( hwnd, NULL, 0, RDW_FRAME | RDW_ERASENOW | RDW_NOCHILDREN );
 776         }
 777         else
 778             SetRectEmpty( rect );
 779     }
 780     retvalue = (wndPtr->hrgnUpdate >= 1);
 781 END:
 782     WIN_ReleaseWndPtr(wndPtr);
 783     return retvalue;
 784 }
 785
 786
 787 /***********************************************************************
 788  *           GetUpdateRgn16   (USER.237)
 789  */
 790 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
 791 {
 792     return GetUpdateRgn( hwnd, hrgn, erase );
 793 }
 794
 795
 796 /***********************************************************************
 797  *           GetUpdateRgn    (USER32.298)
 798  */
 799 INT WINAPI GetUpdateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
 800 {
 801     INT retval;
 802     WND * wndPtr = WIN_FindWndPtr( hwnd );
 803     if (!wndPtr) return ERROR;
 804
 805     if (wndPtr->hrgnUpdate == 0)
 806     {
 807         SetRectRgn( hrgn, 0, 0, 0, 0 );
 808         retval = NULLREGION;
 809         goto END;
 810     }
 811     else
 812     if (wndPtr->hrgnUpdate == 1)
 813     {
 814         SetRectRgn( hrgn, 0, 0, wndPtr->rectClient.right - wndPtr->rectClient.left,
 815                                 wndPtr->rectClient.bottom - wndPtr->rectClient.top );
 816         retval = SIMPLEREGION;
 817     }
 818     else
 819     {
 820         retval = CombineRgn( hrgn, wndPtr->hrgnUpdate, 0, RGN_COPY );
 821         OffsetRgn( hrgn, wndPtr->rectWindow.left - wndPtr->rectClient.left,
 822                          wndPtr->rectWindow.top - wndPtr->rectClient.top );
 823     }
 824     if (erase) RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW | RDW_NOCHILDREN );
 825 END:
 826     WIN_ReleaseWndPtr(wndPtr);
 827     return retval;
 828 }
 829
 830
 831 /***********************************************************************
 832  *           ExcludeUpdateRgn16   (USER.238)
 833  */
 834 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
 835 {
 836     return ExcludeUpdateRgn( hdc, hwnd );
 837 }
 838
 839
 840 /***********************************************************************
 841  *           ExcludeUpdateRgn32   (USER32.195)
 842  */
 843 INT WINAPI ExcludeUpdateRgn( HDC hdc, HWND hwnd )
 844 {
 845     RECT rect;
 846     WND * wndPtr;
 847
 848     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return ERROR;
 849
 850     if (wndPtr->hrgnUpdate)
 851     {
 852         INT ret;
 853         HRGN hrgn = CreateRectRgn(wndPtr->rectWindow.left - wndPtr->rectClient.left,
 854                                       wndPtr->rectWindow.top - wndPtr->rectClient.top,
 855                                       wndPtr->rectWindow.right - wndPtr->rectClient.left,
 856                                       wndPtr->rectWindow.bottom - wndPtr->rectClient.top);
 857         if( wndPtr->hrgnUpdate > 1 )
 858         {
 859             CombineRgn(hrgn, wndPtr->hrgnUpdate, 0, RGN_COPY);
 860             OffsetRgn(hrgn, wndPtr->rectWindow.left - wndPtr->rectClient.left,
 861                             wndPtr->rectWindow.top - wndPtr->rectClient.top );
 862         }
 863
 864         /* do ugly coordinate translations in dce.c */
 865
 866         ret = DCE_ExcludeRgn( hdc, wndPtr, hrgn );
 867         DeleteObject( hrgn );
 868         WIN_ReleaseWndPtr(wndPtr);
 869         return ret;
 870     }
 871     WIN_ReleaseWndPtr(wndPtr);
 872     return GetClipBox( hdc, &rect );
 873 }
 874
 875