windows/painting.c

   1 /*
   2  * Window painting functions
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <X11/Xlib.h>
   9
  10 #include "win.h"
  11 #include "queue.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  *           WIN_UpdateNCArea
  22  *
  23  */
  24 void WIN_UpdateNCArea(WND* wnd, BOOL bUpdate)
  25 {
  26     POINT16 pt = {0, 0};
  27     HRGN hClip = 1;
  28
  29     dprintf_nonclient(stddeb,"NCUpdate: hwnd %04x, hrgnUpdate %04x\n",
  30                       wnd->hwndSelf, wnd->hrgnUpdate );
  31
  32     /* desktop window doesn't have nonclient area */
  33     if(wnd == WIN_GetDesktop())
  34     {
  35         wnd->flags &= ~WIN_NEEDS_NCPAINT;
  36         return;
  37     }
  38
  39     if( wnd->hrgnUpdate > 1 )
  40     {
  41         ClientToScreen16(wnd->hwndSelf, &pt);
  42
  43         hClip = CreateRectRgn( 0, 0, 0, 0 );
  44         if (!CombineRgn(hClip, wnd->hrgnUpdate, 0, RGN_COPY) )
  45         {
  46             DeleteObject(hClip);
  47             hClip = 1;
  48         }
  49         else
  50             OffsetRgn(hClip, pt.x, pt.y);
  51
  52         if (bUpdate)
  53         {
  54             /* exclude non-client area from update region */
  55             HRGN hrgn = CreateRectRgn(0, 0, wnd->rectClient.right - wnd->rectClient.left,
  56                                             wnd->rectClient.bottom - wnd->rectClient.top);
  57
  58             if (hrgn && (CombineRgn(wnd->hrgnUpdate, wnd->hrgnUpdate,
  59                                     hrgn, RGN_AND) == NULLREGION))
  60             {
  61                 DeleteObject(wnd->hrgnUpdate);
  62                 wnd->hrgnUpdate = 1;
  63             }
  64
  65             DeleteObject( hrgn );
  66         }
  67     }
  68
  69     wnd->flags &= ~WIN_NEEDS_NCPAINT;
  70
  71     if ((wnd->hwndSelf == GetActiveWindow()) &&
  72         !(wnd->flags & WIN_NCACTIVATED))
  73     {
  74         wnd->flags |= WIN_NCACTIVATED;
  75         if( hClip > 1) DeleteObject(hClip);
  76         hClip = 1;
  77     }
  78
  79     if (hClip) SendMessage16( wnd->hwndSelf, WM_NCPAINT, hClip, 0L );
  80
  81     if (hClip > 1) DeleteObject( hClip );
  82 }
  83
  84
  85 /***********************************************************************
  86  *           BeginPaint16    (USER.39)
  87  */
  88 HDC16 BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
  89 {
  90     HRGN hrgnUpdate;
  91     WND * wndPtr = WIN_FindWndPtr( hwnd );
  92     if (!wndPtr) return 0;
  93
  94     wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
  95
  96     if (wndPtr->flags & WIN_NEEDS_NCPAINT) WIN_UpdateNCArea( wndPtr, TRUE );
  97
  98     if (((hrgnUpdate = wndPtr->hrgnUpdate) != 0) ||
  99         (wndPtr->flags & WIN_INTERNAL_PAINT))
 100         QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 101
 102     wndPtr->hrgnUpdate = 0;
 103     wndPtr->flags &= ~WIN_INTERNAL_PAINT;
 104
 105     HideCaret( hwnd );
 106
 107     lps->hdc = GetDCEx( hwnd, hrgnUpdate, DCX_INTERSECTRGN | DCX_USESTYLE );
 108     if(hrgnUpdate > 1) DeleteObject( hrgnUpdate );
 109
 110     if (!lps->hdc)
 111     {
 112         fprintf(stderr, "GetDCEx() failed in BeginPaint(), hwnd=%04x\n", hwnd);
 113         return 0;
 114     }
 115
 116     GetRgnBox16( InquireVisRgn(lps->hdc), &lps->rcPaint );
 117     DPtoLP16( lps->hdc, (LPPOINT16)&lps->rcPaint, 2 );
 118
 119     if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
 120     {
 121         wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 122         lps->fErase = !SendMessage16(hwnd, WM_ERASEBKGND, (WPARAM)lps->hdc, 0);
 123     }
 124     else lps->fErase = TRUE;
 125
 126     return lps->hdc;
 127 }
 128
 129
 130 /***********************************************************************
 131  *           BeginPaint32    (USER32.9)
 132  */
 133 HDC32 BeginPaint32( HWND32 hwnd, PAINTSTRUCT32 *lps )
 134 {
 135     PAINTSTRUCT16 ps;
 136
 137     BeginPaint16( hwnd, &ps );
 138     lps->hdc            = (HDC32)ps.hdc;
 139     lps->fErase         = ps.fErase;
 140     lps->rcPaint.top    = ps.rcPaint.top;
 141     lps->rcPaint.left   = ps.rcPaint.left;
 142     lps->rcPaint.right  = ps.rcPaint.right;
 143     lps->rcPaint.bottom = ps.rcPaint.bottom;
 144     lps->fRestore       = ps.fRestore;
 145     lps->fIncUpdate     = ps.fIncUpdate;
 146     return lps->hdc;
 147 }
 148
 149
 150 /***********************************************************************
 151  *           EndPaint16    (USER.40)
 152  */
 153 BOOL16 EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
 154 {
 155     ReleaseDC( hwnd, lps->hdc );
 156     ShowCaret( hwnd );
 157     return TRUE;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           EndPaint32    (USER32.175)
 163  */
 164 BOOL32 EndPaint32( HWND32 hwnd, const PAINTSTRUCT32 *lps )
 165 {
 166     ReleaseDC( hwnd, (HDC16)lps->hdc );
 167     ShowCaret( hwnd );
 168     return TRUE;
 169 }
 170
 171
 172 /***********************************************************************
 173  *           FillWindow    (USER.324)
 174  */
 175 void FillWindow( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
 176 {
 177     RECT16 rect;
 178     GetClientRect16( hwnd, &rect );
 179     DPtoLP16( hdc, (LPPOINT16)&rect, 2 );
 180     PaintRect( hwndParent, hwnd, hdc, hbrush, &rect );
 181 }
 182
 183
 184 /***********************************************************************
 185  *           PaintRect    (USER.325)
 186  */
 187 void PaintRect( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
 188                 HBRUSH16 hbrush, const RECT16 *rect)
 189 {
 190       /* Send WM_CTLCOLOR message if needed */
 191
 192     if ((DWORD)hbrush <= CTLCOLOR_MAX)
 193     {
 194         if (!hwndParent) return;
 195 #ifdef WINELIB32
 196         hbrush = (HBRUSH)SendMessage32A( hwndParent,
 197                                          WM_CTLCOLORMSGBOX+(DWORD)hbrush,
 198                                          (WPARAM)hdc, (LPARAM)hwnd );
 199 #else
 200         hbrush = (HBRUSH)SendMessage16( hwndParent, WM_CTLCOLOR,
 201                                         hdc, MAKELONG( hwnd, hbrush ) );
 202 #endif
 203     }
 204     if (hbrush) FillRect16( hdc, rect, hbrush );
 205 }
 206
 207
 208 /***********************************************************************
 209  *           GetControlBrush    (USER.326)
 210  */
 211 HBRUSH GetControlBrush( HWND hwnd, HDC hdc, WORD control )
 212 {
 213 #ifdef WINELIB32
 214     return (HBRUSH)SendMessage32A( GetParent(hwnd), WM_CTLCOLOR+control,
 215                                    (WPARAM)hdc, (LPARAM)hwnd );
 216 #else
 217     return (HBRUSH)SendMessage16( GetParent(hwnd), WM_CTLCOLOR,
 218                                   hdc, MAKELONG( hwnd, control ) );
 219 #endif
 220 }
 221
 222
 223 /***********************************************************************
 224  *           RedrawWindow32    (USER32.425)
 225  */
 226 BOOL32 RedrawWindow32( HWND32 hwnd, const RECT32 *rectUpdate,
 227                        HRGN32 hrgnUpdate, UINT32 flags )
 228 {
 229     HRGN hrgn;
 230     RECT32 rectClient;
 231     WND * wndPtr;
 232
 233     if (!hwnd) hwnd = GetDesktopWindow();
 234     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 235     if (!IsWindowVisible(hwnd) || (wndPtr->flags & WIN_NO_REDRAW))
 236         return TRUE;  /* No redraw needed */
 237
 238     if (rectUpdate)
 239     {
 240         dprintf_win(stddeb, "RedrawWindow: %04x %d,%d-%d,%d %04x flags=%04x\n",
 241                     hwnd, rectUpdate->left, rectUpdate->top,
 242                     rectUpdate->right, rectUpdate->bottom, hrgnUpdate, flags );
 243     }
 244     else
 245     {
 246         dprintf_win(stddeb, "RedrawWindow: %04x NULL %04x flags=%04x\n",
 247                      hwnd, hrgnUpdate, flags);
 248     }
 249     GetClientRect32( hwnd, &rectClient );
 250
 251     if (flags & RDW_INVALIDATE)  /* Invalidate */
 252     {
 253         int rgnNotEmpty = COMPLEXREGION;
 254
 255         if (wndPtr->hrgnUpdate > 1)  /* Is there already an update region? */
 256         {
 257             if ((hrgn = hrgnUpdate) == 0)
 258                 hrgn = CreateRectRgnIndirect32( rectUpdate ? rectUpdate :
 259                                                 &rectClient );
 260             rgnNotEmpty = CombineRgn( wndPtr->hrgnUpdate, wndPtr->hrgnUpdate, hrgn, RGN_OR );
 261             if (!hrgnUpdate) DeleteObject( hrgn );
 262         }
 263         else  /* No update region yet */
 264         {
 265             if (!(wndPtr->flags & WIN_INTERNAL_PAINT))
 266                 QUEUE_IncPaintCount( wndPtr->hmemTaskQ );
 267             if (hrgnUpdate)
 268             {
 269                 wndPtr->hrgnUpdate = CreateRectRgn( 0, 0, 0, 0 );
 270                 rgnNotEmpty = CombineRgn( wndPtr->hrgnUpdate, hrgnUpdate, 0, RGN_COPY );
 271             }
 272             else wndPtr->hrgnUpdate = CreateRectRgnIndirect32( rectUpdate ?
 273                                                     rectUpdate : &rectClient );
 274         }
 275
 276         if (flags & RDW_FRAME) wndPtr->flags |= WIN_NEEDS_NCPAINT;
 277
 278         /* check for bogus update region */
 279         if ( rgnNotEmpty == NULLREGION )
 280            {
 281              wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 282              DeleteObject(wndPtr->hrgnUpdate);
 283              wndPtr->hrgnUpdate=0;
 284              if (!(wndPtr->flags & WIN_INTERNAL_PAINT))
 285                    QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 286            }
 287         else
 288              if (flags & RDW_ERASE) wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
 289         flags |= RDW_FRAME;  /* Force invalidating the frame of children */
 290     }
 291     else if (flags & RDW_VALIDATE)  /* Validate */
 292     {
 293           /* We need an update region in order to validate anything */
 294         if (wndPtr->hrgnUpdate > 1)
 295         {
 296             if (!hrgnUpdate && !rectUpdate)
 297             {
 298                   /* Special case: validate everything */
 299                 DeleteObject( wndPtr->hrgnUpdate );
 300                 wndPtr->hrgnUpdate = 0;
 301             }
 302             else
 303             {
 304                 if ((hrgn = hrgnUpdate) == 0)
 305                     hrgn = CreateRectRgnIndirect32( rectUpdate );
 306                 if (CombineRgn( wndPtr->hrgnUpdate, wndPtr->hrgnUpdate,
 307                                 hrgn, RGN_DIFF ) == NULLREGION)
 308                 {
 309                     DeleteObject( wndPtr->hrgnUpdate );
 310                     wndPtr->hrgnUpdate = 0;
 311                 }
 312                 if (!hrgnUpdate) DeleteObject( hrgn );
 313             }
 314             if (!wndPtr->hrgnUpdate)  /* No more update region */
 315                 if (!(wndPtr->flags & WIN_INTERNAL_PAINT))
 316                     QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 317         }
 318         if (flags & RDW_NOFRAME) wndPtr->flags &= ~WIN_NEEDS_NCPAINT;
 319         if (flags & RDW_NOERASE) wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 320     }
 321
 322       /* Set/clear internal paint flag */
 323
 324     if (flags & RDW_INTERNALPAINT)
 325     {
 326         if ( wndPtr->hrgnUpdate <= 1 && !(wndPtr->flags & WIN_INTERNAL_PAINT))
 327             QUEUE_IncPaintCount( wndPtr->hmemTaskQ );
 328         wndPtr->flags |= WIN_INTERNAL_PAINT;
 329     }
 330     else if (flags & RDW_NOINTERNALPAINT)
 331     {
 332         if ( wndPtr->hrgnUpdate <= 1 && (wndPtr->flags & WIN_INTERNAL_PAINT))
 333             QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 334         wndPtr->flags &= ~WIN_INTERNAL_PAINT;
 335     }
 336
 337       /* Erase/update window */
 338
 339     if (flags & RDW_UPDATENOW)
 340     {
 341         if (wndPtr->hrgnUpdate) SendMessage16( hwnd, WM_PAINT, 0, 0 );
 342     }
 343     else if (flags & RDW_ERASENOW)
 344     {
 345         if (wndPtr->flags & WIN_NEEDS_NCPAINT)
 346             WIN_UpdateNCArea( wndPtr, FALSE);
 347
 348         if (wndPtr->flags & WIN_NEEDS_ERASEBKGND)
 349         {
 350             HDC hdc = GetDCEx( hwnd, wndPtr->hrgnUpdate,
 351                                DCX_INTERSECTRGN | DCX_USESTYLE );
 352             if (hdc)
 353             {
 354               /* Don't send WM_ERASEBKGND to icons */
 355               /* (WM_ICONERASEBKGND is sent during processing of WM_NCPAINT) */
 356                 if (!(wndPtr->dwStyle & WS_MINIMIZE) ||
 357                     !wndPtr->class->hIcon)
 358                 {
 359                     if (SendMessage16( hwnd, WM_ERASEBKGND, (WPARAM)hdc, 0 ))
 360                         wndPtr->flags &= ~WIN_NEEDS_ERASEBKGND;
 361                 }
 362                 ReleaseDC( hwnd, hdc );
 363             }
 364         }
 365     }
 366
 367       /* Recursively process children */
 368
 369     if (!(flags & RDW_NOCHILDREN) &&
 370         ((flags & RDW_ALLCHILDREN) || !(wndPtr->dwStyle & WS_CLIPCHILDREN)))
 371     {
 372         if (hrgnUpdate)
 373         {
 374             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 375             if (!hrgn) return TRUE;
 376             for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
 377             {
 378                 CombineRgn( hrgn, hrgnUpdate, 0, RGN_COPY );
 379                 OffsetRgn( hrgn, -wndPtr->rectClient.left,
 380                                  -wndPtr->rectClient.top );
 381                 RedrawWindow32( wndPtr->hwndSelf, NULL, hrgn, flags );
 382             }
 383             DeleteObject( hrgn );
 384         }
 385         else
 386         {
 387             RECT32 rect;
 388             for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
 389             {
 390                 if (rectUpdate)
 391                 {
 392                     rect = *rectUpdate;
 393                     OffsetRect32( &rect, -wndPtr->rectClient.left,
 394                                          -wndPtr->rectClient.top );
 395                     RedrawWindow32( wndPtr->hwndSelf, &rect, 0, flags );
 396                 }
 397                 else RedrawWindow32( wndPtr->hwndSelf, NULL, 0, flags );
 398             }
 399         }
 400     }
 401     return TRUE;
 402 }
 403
 404
 405 /***********************************************************************
 406  *           RedrawWindow16    (USER.290)
 407  */
 408 BOOL16 RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
 409                        HRGN16 hrgnUpdate, UINT16 flags )
 410 {
 411     if (rectUpdate)
 412     {
 413         RECT32 r;
 414         CONV_RECT16TO32( rectUpdate, &r );
 415         return (BOOL16)RedrawWindow32( (HWND32)hwnd, &r, hrgnUpdate, flags );
 416     }
 417     return (BOOL16)RedrawWindow32( (HWND32)hwnd, NULL, hrgnUpdate, flags );
 418 }
 419
 420
 421 /***********************************************************************
 422  *           UpdateWindow   (USER.124) (USER32.566)
 423  */
 424 void UpdateWindow( HWND32 hwnd )
 425 {
 426     RedrawWindow32( hwnd, NULL, 0, RDW_UPDATENOW | RDW_NOCHILDREN );
 427 }
 428
 429
 430 /***********************************************************************
 431  *           InvalidateRgn   (USER.126) (USER32.328)
 432  */
 433 void InvalidateRgn( HWND32 hwnd, HRGN32 hrgn, BOOL32 erase )
 434 {
 435     RedrawWindow32(hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0));
 436 }
 437
 438
 439 /***********************************************************************
 440  *           InvalidateRect16   (USER.125)
 441  */
 442 void InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
 443 {
 444     RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 445 }
 446
 447
 448 /***********************************************************************
 449  *           InvalidateRect32   (USER32.327)
 450  */
 451 void InvalidateRect32( HWND32 hwnd, const RECT32 *rect, BOOL32 erase )
 452 {
 453     RedrawWindow32( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 454 }
 455
 456
 457 /***********************************************************************
 458  *           ValidateRgn   (USER.128) (USER32.571)
 459  */
 460 void ValidateRgn( HWND32 hwnd, HRGN32 hrgn )
 461 {
 462     RedrawWindow32( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN );
 463 }
 464
 465
 466 /***********************************************************************
 467  *           ValidateRect16   (USER.127)
 468  */
 469 void ValidateRect16( HWND16 hwnd, const RECT16 *rect )
 470 {
 471     RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 472 }
 473
 474
 475 /***********************************************************************
 476  *           ValidateRect32   (USER32.570)
 477  */
 478 void ValidateRect32( HWND32 hwnd, const RECT32 *rect )
 479 {
 480     RedrawWindow32( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 481 }
 482
 483
 484 /***********************************************************************
 485  *           GetUpdateRect16   (USER.190)
 486  */
 487 BOOL16 GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
 488 {
 489     RECT32 r;
 490     BOOL16 ret;
 491
 492     if (!rect) return GetUpdateRect32( hwnd, NULL, erase );
 493     ret = GetUpdateRect32( hwnd, &r, erase );
 494     CONV_RECT32TO16( &r, rect );
 495     return ret;
 496 }
 497
 498
 499 /***********************************************************************
 500  *           GetUpdateRect32   (USER32.296)
 501  */
 502 BOOL32 GetUpdateRect32( HWND32 hwnd, LPRECT32 rect, BOOL32 erase )
 503 {
 504     WND * wndPtr = WIN_FindWndPtr( hwnd );
 505     if (!wndPtr) return FALSE;
 506
 507     if (rect)
 508     {
 509         if (wndPtr->hrgnUpdate > 1)
 510         {
 511             HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
 512             if (GetUpdateRgn( hwnd, hrgn, erase ) == ERROR) return FALSE;
 513             GetRgnBox32( hrgn, rect );
 514             DeleteObject( hrgn );
 515         }
 516         else SetRectEmpty32( rect );
 517     }
 518     return (wndPtr->hrgnUpdate > 1);
 519 }
 520
 521
 522 /***********************************************************************
 523  *           GetUpdateRgn   (USER.237) (USER32.297)
 524  */
 525 INT16 GetUpdateRgn( HWND32 hwnd, HRGN32 hrgn, BOOL32 erase )
 526 {
 527     INT16 retval;
 528     WND * wndPtr = WIN_FindWndPtr( hwnd );
 529     if (!wndPtr) return ERROR;
 530
 531     if (wndPtr->hrgnUpdate <= 1)
 532     {
 533         SetRectRgn( hrgn, 0, 0, 0, 0 );
 534         return NULLREGION;
 535     }
 536     retval = CombineRgn( hrgn, wndPtr->hrgnUpdate, 0, RGN_COPY );
 537     if (erase) RedrawWindow32( hwnd, NULL, 0, RDW_ERASENOW | RDW_NOCHILDREN );
 538     return retval;
 539 }
 540
 541
 542 /***********************************************************************
 543  *           ExcludeUpdateRgn   (USER.238) (USER32.194)
 544  */
 545 INT16 ExcludeUpdateRgn( HDC32 hdc, HWND32 hwnd )
 546 {
 547     INT16 retval = ERROR;
 548     HRGN hrgn;
 549     WND * wndPtr;
 550
 551     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return ERROR;
 552     if ((hrgn = CreateRectRgn( 0, 0, 0, 0 )) != 0)
 553     {
 554         retval = CombineRgn( hrgn, InquireVisRgn(hdc),
 555                              (wndPtr->hrgnUpdate>1)?wndPtr->hrgnUpdate:0,
 556                              (wndPtr->hrgnUpdate>1)?RGN_DIFF:RGN_COPY);
 557         if (retval) SelectVisRgn( hdc, hrgn );
 558         DeleteObject( hrgn );
 559     }
 560     return retval;
 561 }
 562
 563