windows/painting.c

   1 /*
   2  * Window painting functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <X11/Xlib.h>
   9
  10 #include "win.h"
  11 #include "message.h"
  12 #include "gdi.h"
  13 #include "stddebug.h"
  14 /* #define DEBUG_WIN */
  15 #include "debug.h"
  16
  17   /* Last CTLCOLOR id */
  18 #define CTLCOLOR_MAX   CTLCOLOR_STATIC
  19
  20
  21 /***********************************************************************
  22  *           BeginPaint    (USER.39)
  23  */
  24 HDC BeginPaint( HWND hwnd, LPPAINTSTRUCT lps )
  25 {
  26     HRGN hrgnUpdate;
  27     WND * wndPtr = WIN_FindWndPtr( hwnd );
  28     if (!wndPtr) return 0;
  29
  30     hrgnUpdate = wndPtr->hrgnUpdate;  /* Save update region */
  31     if (!hrgnUpdate)    /* Create an empty region */
  32         if (!(hrgnUpdate = CreateRectRgn( 0, 0, 0, 0 ))) return 0;
  33
  34     if (wndPtr->hrgnUpdate || (wndPtr->flags & WIN_INTERNAL_PAINT))
  35         MSG_DecPaintCount( wndPtr->hmemTaskQ );
  36
  37     wndPtr->hrgnUpdate = 0;
  38     wndPtr->flags &= ~(WIN_NEEDS_BEGINPAINT | WIN_INTERNAL_PAINT);
  39
  40     if (wndPtr->flags & WIN_NEEDS_NCPAINT)
  41     {
  42         SendMessage( hwnd, WM_NCPAINT, 0, 0 );
  43         wndPtr->flags &= ~WIN_NEEDS_NCPAINT;
  44     }
  45
  46     lps->hdc = GetDCEx( hwnd, hrgnUpdate, DCX_INTERSECTRGN | DCX_USESTYLE );
  47     DeleteObject( hrgnUpdate );
  48     if (!lps->hdc)
  49     {
  50         fprintf( stderr, "GetDCEx() failed in BeginPaint(), hwnd=%x\n", hwnd );
  51         return 0;
  52     }
  53
  54     GetRgnBox( InquireVisRgn(lps->hdc), &lps->rcPaint );
  55     DPtoLP( lps->hdc, (LPPOINT)&lps->rcPaint, 2 );
  56
  57     if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
  58     {
  59         lps->fErase = !SendMessage( hwnd, WM_ERASEBKGND, lps->hdc, 0 );
  60         wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
  61     }
  62     else lps->fErase = TRUE;
  63
  64     return lps->hdc;
  65 }
  66
  67
  68 /***********************************************************************
  69  *           EndPaint    (USER.40)
  70  */
  71 void EndPaint( HWND hwnd, LPPAINTSTRUCT lps )
  72 {
  73     ReleaseDC( hwnd, lps->hdc );
  74 }
  75
  76
  77 /***********************************************************************
  78  *           FillWindow    (USER.324)
  79  */
  80 void FillWindow( HWND hwndParent, HWND hwnd, HDC hdc, HBRUSH hbrush )
  81 {
  82     RECT rect;
  83     GetClientRect( hwnd, &rect );
  84     DPtoLP( hdc, (LPPOINT)&rect, 2 );
  85     PaintRect( hwndParent, hwnd, hdc, hbrush, &rect );
  86 }
  87
  88
  89 /***********************************************************************
  90  *           PaintRect    (USER.325)
  91  */
  92 void PaintRect(HWND hwndParent, HWND hwnd, HDC hdc, HBRUSH hbrush, LPRECT rect)
  93 {
  94       /* Send WM_CTLCOLOR message if needed */
  95
  96     if (hbrush <= CTLCOLOR_MAX)
  97     {
  98         if (!hwndParent) return;
  99         hbrush = (HBRUSH)SendMessage( hwndParent, WM_CTLCOLOR,
 100                                       hdc, MAKELONG( hwnd, hbrush ) );
 101     }
 102     if (hbrush) FillRect( hdc, rect, hbrush );
 103 }
 104
 105
 106 /***********************************************************************
 107  *           RedrawWindow    (USER.290)
 108  */
 109 BOOL RedrawWindow( HWND hwnd, LPRECT rectUpdate, HRGN hrgnUpdate, UINT flags )
 110 {
 111     HRGN tmpRgn, hrgn = 0;
 112     RECT rectClient, rectWindow;
 113     WND * wndPtr;
 114
 115     if (!hwnd) hwnd = GetDesktopWindow();
 116     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 117     if (!(wndPtr->dwStyle & WS_VISIBLE) || (wndPtr->flags & WIN_NO_REDRAW))
 118         return TRUE;  /* No redraw needed */
 119
 120     if (rectUpdate)
 121     {
 122         dprintf_win( stddeb, "RedrawWindow: %x %d,%d-%d,%d %x flags=%04x\n",
 123                      hwnd, rectUpdate->left, rectUpdate->top,
 124                      rectUpdate->right, rectUpdate->bottom, hrgnUpdate, flags);
 125     }
 126     else
 127     {
 128         dprintf_win( stddeb, "RedrawWindow: %x NULL %x flags=%04x\n",
 129                      hwnd, hrgnUpdate, flags);
 130     }
 131     GetClientRect( hwnd, &rectClient );
 132     rectWindow = wndPtr->rectWindow;
 133     OffsetRect(&rectWindow, -wndPtr->rectClient.left, -wndPtr->rectClient.top);
 134
 135     if (flags & RDW_INVALIDATE)  /* Invalidate */
 136     {
 137         if (hrgnUpdate)  /* Invalidate a region */
 138         {
 139             if (flags & RDW_FRAME) tmpRgn = CreateRectRgnIndirect(&rectWindow);
 140             else tmpRgn = CreateRectRgnIndirect( &rectClient );
 141             if (!tmpRgn) return FALSE;
 142             hrgn = CreateRectRgn( 0, 0, 0, 0 );
 143             if (CombineRgn( hrgn, hrgnUpdate, tmpRgn, RGN_AND ) == NULLREGION)
 144             {
 145                 DeleteObject( hrgn );
 146                 hrgn = 0;
 147             }
 148             DeleteObject( tmpRgn );
 149         }
 150         else  /* Invalidate a rectangle */
 151         {
 152             RECT rect;
 153             if (flags & RDW_FRAME)
 154             {
 155                 if (rectUpdate) IntersectRect( &rect, rectUpdate, &rectWindow);
 156                 else rect = rectWindow;
 157             }
 158             else
 159             {
 160                 if (rectUpdate) IntersectRect( &rect, rectUpdate, &rectClient);
 161                 else rect = rectClient;
 162             }
 163             if (!IsRectEmpty(&rect)) hrgn = CreateRectRgnIndirect( &rect );
 164         }
 165
 166           /* Set update region */
 167
 168         if (hrgn)
 169         {
 170             if (!wndPtr->hrgnUpdate)
 171             {
 172                 wndPtr->hrgnUpdate = hrgn;
 173                 if (!(wndPtr->flags & WIN_INTERNAL_PAINT))
 174                     MSG_IncPaintCount( wndPtr->hmemTaskQ );
 175             }
 176             else
 177             {
 178                 tmpRgn = CreateRectRgn( 0, 0, 0, 0 );
 179                 CombineRgn( tmpRgn, wndPtr->hrgnUpdate, hrgn, RGN_OR );
 180                 DeleteObject( wndPtr->hrgnUpdate );
 181                 DeleteObject( hrgn );
 182                 wndPtr->hrgnUpdate = tmpRgn;
 183             }
 184         }
 185         if (flags & RDW_FRAME) wndPtr->flags |= WIN_NEEDS_NCPAINT;
 186         if (flags & RDW_ERASE) wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
 187         flags |= RDW_FRAME;  /* Force invalidating the frame of children */
 188     }
 189     else if (flags & RDW_VALIDATE)  /* Validate */
 190     {
 191         if (flags & RDW_NOERASE) wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 192         if (!(hrgn = CreateRectRgn( 0, 0, 0, 0 ))) return FALSE;
 193
 194           /* Remove frame from update region */
 195
 196         if (wndPtr->hrgnUpdate && (flags & RDW_NOFRAME))
 197         {
 198             if (!(tmpRgn = CreateRectRgnIndirect( &rectClient )))
 199                 return FALSE;
 200             if (CombineRgn(hrgn,tmpRgn,wndPtr->hrgnUpdate,RGN_AND) == NULLREGION)
 201             {
 202                 DeleteObject( hrgn );
 203                 hrgn = 0;
 204             }
 205             DeleteObject( tmpRgn );
 206             DeleteObject( wndPtr->hrgnUpdate );
 207             wndPtr->hrgnUpdate = hrgn;
 208             hrgn = CreateRectRgn( 0, 0, 0, 0 );
 209         }
 210
 211           /* Set update region */
 212
 213         if (wndPtr->hrgnUpdate)
 214         {
 215             int res;
 216             if (hrgnUpdate)  /* Validate a region */
 217             {
 218                 res = CombineRgn(hrgn,wndPtr->hrgnUpdate,hrgnUpdate,RGN_DIFF);
 219             }
 220             else  /* Validate a rectangle */
 221             {
 222                 if (rectUpdate) tmpRgn = CreateRectRgnIndirect( rectUpdate );
 223                 else tmpRgn = CreateRectRgnIndirect( &rectWindow );
 224                 res = CombineRgn( hrgn, wndPtr->hrgnUpdate, tmpRgn, RGN_DIFF );
 225                 DeleteObject( tmpRgn );
 226             }
 227             DeleteObject( wndPtr->hrgnUpdate );
 228             if (res == NULLREGION)
 229             {
 230                 DeleteObject( hrgn );
 231                 wndPtr->hrgnUpdate = 0;
 232                 if (!(wndPtr->flags & WIN_INTERNAL_PAINT))
 233                     MSG_DecPaintCount( wndPtr->hmemTaskQ );
 234             }
 235             else wndPtr->hrgnUpdate = hrgn;
 236         }
 237     }
 238
 239       /* Set/clear internal paint flag */
 240
 241     if (flags & RDW_INTERNALPAINT)
 242     {
 243         if (!wndPtr->hrgnUpdate && !(wndPtr->flags & WIN_INTERNAL_PAINT))
 244             MSG_IncPaintCount( wndPtr->hmemTaskQ );
 245         wndPtr->flags |= WIN_INTERNAL_PAINT;
 246     }
 247     else if (flags & RDW_NOINTERNALPAINT)
 248     {
 249         if (!wndPtr->hrgnUpdate && (wndPtr->flags & WIN_INTERNAL_PAINT))
 250             MSG_DecPaintCount( wndPtr->hmemTaskQ );
 251         wndPtr->flags &= ~WIN_INTERNAL_PAINT;
 252     }
 253
 254       /* Erase/update window */
 255
 256     if (flags & RDW_UPDATENOW) SendMessage( hwnd, WM_PAINT, 0, 0 );
 257     else if (flags & RDW_ERASENOW)
 258     {
 259         if (wndPtr->flags & WIN_NEEDS_NCPAINT)
 260         {
 261             SendMessage( hwnd, WM_NCPAINT, 0, 0 );
 262             wndPtr->flags &= ~WIN_NEEDS_NCPAINT;
 263         }
 264         if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
 265         {
 266             HDC hdc = GetDCEx( hwnd, wndPtr->hrgnUpdate,
 267                                DCX_INTERSECTRGN | DCX_USESTYLE );
 268             if (hdc)
 269             {
 270               /* Don't send WM_ERASEBKGND to icons */
 271               /* (WM_ICONERASEBKGND is sent during processing of WM_NCPAINT) */
 272                 if (!(wndPtr->dwStyle & WS_MINIMIZE)
 273                     || !WIN_CLASS_INFO(wndPtr).hIcon)
 274                 {
 275                     if (SendMessage( hwnd, WM_ERASEBKGND, hdc, 0 ))
 276                         wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 277                 }
 278                 ReleaseDC( hwnd, hdc );
 279             }
 280         }
 281     }
 282
 283       /* Recursively process children */
 284
 285     if (!(flags & RDW_NOCHILDREN) &&
 286         ((flags && RDW_ALLCHILDREN) || !(wndPtr->dwStyle & WS_CLIPCHILDREN)))
 287     {
 288         if (hrgnUpdate)
 289         {
 290             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 291             if (!hrgn) return TRUE;
 292             for (hwnd = wndPtr->hwndChild; (hwnd); hwnd = wndPtr->hwndNext)
 293             {
 294                 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) break;
 295                 CombineRgn( hrgn, hrgnUpdate, 0, RGN_COPY );
 296                 OffsetRgn( hrgn, -wndPtr->rectClient.left,
 297                                  -wndPtr->rectClient.top );
 298                 RedrawWindow( hwnd, NULL, hrgn, flags );
 299             }
 300             DeleteObject( hrgn );
 301         }
 302         else
 303         {
 304             RECT rect;
 305             for (hwnd = wndPtr->hwndChild; (hwnd); hwnd = wndPtr->hwndNext)
 306             {
 307                 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) break;
 308                 if (rectUpdate)
 309                 {
 310                     rect = *rectUpdate;
 311                     OffsetRect( &rect, -wndPtr->rectClient.left,
 312                                        -wndPtr->rectClient.top );
 313                     RedrawWindow( hwnd, &rect, 0, flags );
 314                 }
 315                 else RedrawWindow( hwnd, NULL, 0, flags );
 316             }
 317         }
 318     }
 319     return TRUE;
 320 }
 321
 322
 323 /***********************************************************************
 324  *           UpdateWindow   (USER.124)
 325  */
 326 void UpdateWindow( HWND hwnd )
 327 {
 328     RedrawWindow( hwnd, NULL, 0, RDW_UPDATENOW | RDW_NOCHILDREN );
 329 }
 330
 331
 332 /***********************************************************************
 333  *           InvalidateRgn   (USER.126)
 334  */
 335 void InvalidateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
 336 {
 337     RedrawWindow( hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 338 }
 339
 340
 341 /***********************************************************************
 342  *           InvalidateRect   (USER.125)
 343  */
 344 void InvalidateRect( HWND hwnd, LPRECT rect, BOOL erase )
 345 {
 346     RedrawWindow( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 347 }
 348
 349
 350 /***********************************************************************
 351  *           ValidateRgn   (USER.128)
 352  */
 353 void ValidateRgn( HWND hwnd, HRGN hrgn )
 354 {
 355     RedrawWindow( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN );
 356 }
 357
 358
 359 /***********************************************************************
 360  *           ValidateRect   (USER.127)
 361  */
 362 void ValidateRect( HWND hwnd, LPRECT rect )
 363 {
 364     RedrawWindow( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 365 }
 366
 367
 368 /***********************************************************************
 369  *           GetUpdateRect   (USER.190)
 370  */
 371 BOOL GetUpdateRect( HWND hwnd, LPRECT rect, BOOL erase )
 372 {
 373     WND * wndPtr = WIN_FindWndPtr( hwnd );
 374     if (!wndPtr) return FALSE;
 375
 376     if (rect)
 377     {
 378         if (wndPtr->hrgnUpdate)
 379         {
 380             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 381             if (GetUpdateRgn( hwnd, hrgn, erase ) == ERROR) return FALSE;
 382             GetRgnBox( hrgn, rect );
 383             DeleteObject( hrgn );
 384         }
 385         else SetRectEmpty( rect );
 386     }
 387     return (wndPtr->hrgnUpdate != 0);
 388 }
 389
 390
 391 /***********************************************************************
 392  *           GetUpdateRgn   (USER.237)
 393  */
 394 int GetUpdateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
 395 {
 396     HRGN hrgnClip;
 397     int retval;
 398     WND * wndPtr = WIN_FindWndPtr( hwnd );
 399     if (!wndPtr) return ERROR;
 400
 401     if (!wndPtr->hrgnUpdate)
 402     {
 403         SetRectRgn( hrgn, 0, 0, 0, 0 );
 404         return NULLREGION;
 405     }
 406     hrgnClip = CreateRectRgn( 0, 0,
 407                              wndPtr->rectClient.right-wndPtr->rectClient.left,
 408                              wndPtr->rectClient.bottom-wndPtr->rectClient.top);
 409     if (!hrgnClip) return ERROR;
 410     retval = CombineRgn( hrgn, wndPtr->hrgnUpdate, hrgnClip, RGN_AND );
 411     if (erase) RedrawWindow( hwnd, NULL, 0, RDW_ERASENOW | RDW_NOCHILDREN );
 412     DeleteObject( hrgnClip );
 413     return retval;
 414 }
 415
 416
 417 /***********************************************************************
 418  *           ExcludeUpdateRgn   (USER.238)
 419  */
 420 int ExcludeUpdateRgn( HDC hdc, HWND hwnd )
 421 {
 422     int retval = ERROR;
 423     HRGN hrgn;
 424     WND * wndPtr;
 425
 426     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return ERROR;
 427     if ((hrgn = CreateRectRgn( 0, 0, 0, 0 )) != 0)
 428     {
 429         retval = CombineRgn( hrgn, InquireVisRgn(hdc),
 430                              wndPtr->hrgnUpdate, RGN_DIFF );
 431         if (retval) SelectVisRgn( hdc, hrgn );
 432         DeleteObject( hrgn );
 433     }
 434     return retval;
 435 }
 436
 437