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