windows/dce.c

   1 /*
   2  * USER DCE functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1996,1997 Alex Korobka
   6  *
   7  *
   8  * Note: Visible regions of CS_OWNDC/CS_CLASSDC window DCs
   9  * have to be updated dynamically.
  10  *
  11  * Internal DCX flags:
  12  *
  13  * DCX_DCEEMPTY    - dce is uninitialized
  14  * DCX_DCEBUSY     - dce is in use
  15  * DCX_DCEDIRTY    - ReleaseDC() should wipe instead of caching
  16  * DCX_KEEPCLIPRGN - ReleaseDC() should not delete the clipping region
  17  * DCX_WINDOWPAINT - BeginPaint() is in effect
  18  */
  19
  20 #include "options.h"
  21 #include "dce.h"
  22 #include "class.h"
  23 #include "win.h"
  24 #include "gdi.h"
  25 #include "region.h"
  26 #include "heap.h"
  27 #include "sysmetrics.h"
  28 #include "debug.h"
  29
  30 #define NB_DCE    5  /* Number of DCEs created at startup */
  31
  32 static DCE *firstDCE = 0;
  33 static HDC32 defaultDCstate = 0;
  34
  35 static void DCE_DeleteClipRgn( DCE* );
  36 static INT32 DCE_ReleaseDC( DCE* );
  37
  38
  39 /***********************************************************************
  40  *           DCE_DumpCache
  41  */
  42 static void DCE_DumpCache(void)
  43 {
  44     DCE* dce = firstDCE;
  45
  46     printf("DCE:\n");
  47     while( dce )
  48     {
  49         printf("\t[0x%08x] hWnd 0x%04x, dcx %08x, %s %s\n",
  50         (unsigned)dce, dce->hwndCurrent, (unsigned)dce->DCXflags, (dce->DCXflags & DCX_CACHE) ?
  51         "Cache" : "Owned", (dce->DCXflags & DCX_DCEBUSY) ? "InUse" : "" );
  52         dce = dce->next;
  53     }
  54 }
  55
  56 /***********************************************************************
  57  *           DCE_AllocDCE
  58  *
  59  * Allocate a new DCE.
  60  */
  61 DCE *DCE_AllocDCE( HWND32 hWnd, DCE_TYPE type )
  62 {
  63     DCE * dce;
  64     if (!(dce = HeapAlloc( SystemHeap, 0, sizeof(DCE) ))) return NULL;
  65     if (!(dce->hDC = CreateDC16( "DISPLAY", NULL, NULL, NULL )))
  66     {
  67         HeapFree( SystemHeap, 0, dce );
  68         return 0;
  69     }
  70
  71     /* store DCE handle in DC hook data field */
  72
  73     SetDCHook( dce->hDC, (FARPROC16)DCHook, (DWORD)dce );
  74
  75     dce->hwndCurrent = hWnd;
  76     dce->hClipRgn    = 0;
  77     dce->next        = firstDCE;
  78     firstDCE = dce;
  79
  80     if( type != DCE_CACHE_DC ) /* owned or class DC */
  81     {
  82         dce->DCXflags = DCX_DCEBUSY;
  83         if( hWnd )
  84         {
  85             WND* wnd = WIN_FindWndPtr(hWnd);
  86
  87             if( wnd->dwStyle & WS_CLIPCHILDREN ) dce->DCXflags |= DCX_CLIPCHILDREN;
  88             if( wnd->dwStyle & WS_CLIPSIBLINGS ) dce->DCXflags |= DCX_CLIPSIBLINGS;
  89         }
  90         SetHookFlags(dce->hDC,DCHF_INVALIDATEVISRGN);
  91     }
  92     else dce->DCXflags = DCX_CACHE | DCX_DCEEMPTY;
  93
  94     return dce;
  95 }
  96
  97
  98 /***********************************************************************
  99  *           DCE_FreeDCE
 100  */
 101 DCE* DCE_FreeDCE( DCE *dce )
 102 {
 103     DCE **ppDCE = &firstDCE;
 104
 105     if (!dce) return NULL;
 106     while (*ppDCE && (*ppDCE != dce)) ppDCE = &(*ppDCE)->next;
 107     if (*ppDCE == dce) *ppDCE = dce->next;
 108
 109     SetDCHook(dce->hDC, NULL, 0L);
 110
 111     DeleteDC32( dce->hDC );
 112     if( dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN) )
 113         DeleteObject32(dce->hClipRgn);
 114     HeapFree( SystemHeap, 0, dce );
 115     return *ppDCE;
 116 }
 117
 118 /***********************************************************************
 119  *           DCE_FreeWindowDCE
 120  *
 121  * Remove owned DCE and reset unreleased cache DCEs.
 122  */
 123 void DCE_FreeWindowDCE( WND* pWnd )
 124 {
 125     DCE *pDCE = firstDCE;
 126
 127     while( pDCE )
 128     {
 129         if( pDCE->hwndCurrent == pWnd->hwndSelf )
 130         {
 131             if( pDCE == pWnd->dce ) /* owned DCE */
 132             {
 133                 pDCE = DCE_FreeDCE( pDCE );
 134                 pWnd->dce = NULL;
 135                 continue;
 136             }
 137             else
 138             {
 139                 if(!(pDCE->DCXflags & DCX_CACHE) ) /* class DCE */
 140                 {
 141                     if( pDCE->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN) )
 142                         DCE_DeleteClipRgn( pDCE );
 143                 }
 144                 else if( pDCE->DCXflags & DCX_DCEBUSY ) /* shared cache DCE */
 145                 {
 146                     fprintf(stderr,"[%04x] GetDC() without ReleaseDC()!\n", pWnd->hwndSelf);
 147                     DCE_ReleaseDC( pDCE );
 148                 }
 149
 150                 pDCE->DCXflags &= DCX_CACHE;
 151                 pDCE->DCXflags |= DCX_DCEEMPTY;
 152                 pDCE->hwndCurrent = 0;
 153             }
 154         }
 155         pDCE = pDCE->next;
 156     }
 157 }
 158
 159
 160 /***********************************************************************
 161  *   DCE_DeleteClipRgn
 162  */
 163 static void DCE_DeleteClipRgn( DCE* dce )
 164 {
 165     dce->DCXflags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN | DCX_WINDOWPAINT);
 166
 167     if( dce->DCXflags & DCX_KEEPCLIPRGN )
 168         dce->DCXflags &= ~DCX_KEEPCLIPRGN;
 169     else
 170         if( dce->hClipRgn > 1 )
 171             DeleteObject32( dce->hClipRgn );
 172
 173     dce->hClipRgn = 0;
 174
 175     TRACE(dc,"\trestoring VisRgn\n");
 176
 177     RestoreVisRgn(dce->hDC);
 178 }
 179
 180
 181 /***********************************************************************
 182  *   DCE_ReleaseDC
 183  */
 184 static INT32 DCE_ReleaseDC( DCE* dce )
 185 {
 186     if ((dce->DCXflags & (DCX_DCEEMPTY | DCX_DCEBUSY)) != DCX_DCEBUSY) return 0;
 187
 188     /* restore previous visible region */
 189
 190     if ((dce->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) &&
 191         (dce->DCXflags & (DCX_CACHE | DCX_WINDOWPAINT)) )
 192         DCE_DeleteClipRgn( dce );
 193
 194     if (dce->DCXflags & DCX_CACHE)
 195     {
 196         SetDCState( dce->hDC, defaultDCstate );
 197         dce->DCXflags &= ~DCX_DCEBUSY;
 198         if (dce->DCXflags & DCX_DCEDIRTY)
 199         {
 200             /* don't keep around invalidated entries
 201              * because SetDCState() disables hVisRgn updates
 202              * by removing dirty bit. */
 203
 204             dce->hwndCurrent = 0;
 205             dce->DCXflags &= DCX_CACHE;
 206             dce->DCXflags |= DCX_DCEEMPTY;
 207         }
 208     }
 209     return 1;
 210 }
 211
 212
 213 /***********************************************************************
 214  *   DCE_InvalidateDCE
 215  *
 216  * It is called from SetWindowPos() - we have to mark as dirty all busy
 217  * DCE's for windows that have pWnd->parent as an ansector and whose client
 218  * rect intersects with specified update rectangle.
 219  */
 220 BOOL32 DCE_InvalidateDCE(WND* pWnd, const RECT32* pRectUpdate)
 221 {
 222     WND* wndScope = pWnd->parent;
 223     BOOL32 bRet = FALSE;
 224
 225     if( wndScope )
 226     {
 227         DCE *dce;
 228
 229         TRACE(dc,"scope hwnd = %04x, (%i,%i - %i,%i)\n",
 230                      wndScope->hwndSelf, pRectUpdate->left,pRectUpdate->top,
 231                      pRectUpdate->right,pRectUpdate->bottom);
 232         if(TRACE_ON(dc))
 233           DCE_DumpCache();
 234
 235         /* walk all DCEs and fixup non-empty entries */
 236
 237         for (dce = firstDCE; (dce); dce = dce->next)
 238         {
 239             if( !(dce->DCXflags & DCX_DCEEMPTY) )
 240             {
 241                 WND* wndCurrent = WIN_FindWndPtr(dce->hwndCurrent);
 242
 243                 if( wndCurrent && wndCurrent != WIN_GetDesktop() )
 244                 {
 245                     WND* wnd = wndCurrent;
 246                     INT32 xoffset = 0, yoffset = 0;
 247
 248                     if( (wndCurrent == wndScope) && !(dce->DCXflags & DCX_CLIPCHILDREN) ) continue;
 249
 250                     /* check if DCE window is within the z-order scope */
 251
 252                     for( wnd = wndCurrent; wnd; wnd = wnd->parent )
 253                     {
 254                         if( wnd == wndScope )
 255                         {
 256                             RECT32 wndRect;
 257
 258                             wndRect = wndCurrent->rectWindow;
 259
 260                             OffsetRect32( &wndRect, xoffset - wndCurrent->rectClient.left,
 261                                                     yoffset - wndCurrent->rectClient.top);
 262
 263                             if (pWnd == wndCurrent ||
 264                                 IntersectRect32( &wndRect, &wndRect, pRectUpdate ))
 265                             {
 266                                 if( !(dce->DCXflags & DCX_DCEBUSY) )
 267                                 {
 268                                     /* Don't bother with visible regions of unused DCEs */
 269
 270                                     TRACE(dc,"\tpurged %08x dce [%04x]\n",
 271                                                 (unsigned)dce, wndCurrent->hwndSelf);
 272
 273                                     dce->hwndCurrent = 0;
 274                                     dce->DCXflags &= DCX_CACHE;
 275                                     dce->DCXflags |= DCX_DCEEMPTY;
 276                                 }
 277                                 else
 278                                 {
 279                                     /* Set dirty bits in the hDC and DCE structs */
 280
 281                                     TRACE(dc,"\tfixed up %08x dce [%04x]\n",
 282                                                 (unsigned)dce, wndCurrent->hwndSelf);
 283
 284                                     dce->DCXflags |= DCX_DCEDIRTY;
 285                                     SetHookFlags(dce->hDC, DCHF_INVALIDATEVISRGN);
 286                                     bRet = TRUE;
 287                                 }
 288                             }
 289                             break;
 290                         }
 291                         xoffset += wnd->rectClient.left;
 292                         yoffset += wnd->rectClient.top;
 293                     }
 294                 }
 295             }
 296         } /* dce list */
 297     }
 298     return bRet;
 299 }
 300
 301 /***********************************************************************
 302  *           DCE_Init
 303  */
 304 void DCE_Init(void)
 305 {
 306     int i;
 307     DCE * dce;
 308
 309     for (i = 0; i < NB_DCE; i++)
 310     {
 311         if (!(dce = DCE_AllocDCE( 0, DCE_CACHE_DC ))) return;
 312         if (!defaultDCstate) defaultDCstate = GetDCState( dce->hDC );
 313     }
 314 }
 315
 316
 317 /***********************************************************************
 318  *           DCE_GetVisRect
 319  *
 320  * Calculate the visible rectangle of a window (i.e. the client or
 321  * window area clipped by the client area of all ancestors) in the
 322  * corresponding coordinates. Return FALSE if the visible region is empty.
 323  */
 324 static BOOL32 DCE_GetVisRect( WND *wndPtr, BOOL32 clientArea, RECT32 *lprect )
 325 {
 326     *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow;
 327
 328     if (wndPtr->dwStyle & WS_VISIBLE)
 329     {
 330         INT32 xoffset = lprect->left;
 331         INT32 yoffset = lprect->top;
 332
 333         while (wndPtr->parent)
 334         {
 335             wndPtr = wndPtr->parent;
 336
 337             if ( (wndPtr->dwStyle & (WS_ICONIC | WS_VISIBLE)) != WS_VISIBLE )
 338                 goto fail;
 339
 340             xoffset += wndPtr->rectClient.left;
 341             yoffset += wndPtr->rectClient.top;
 342             OffsetRect32( lprect, wndPtr->rectClient.left,
 343                                   wndPtr->rectClient.top );
 344
 345             if( (wndPtr->rectClient.left >= wndPtr->rectClient.right) ||
 346                 (wndPtr->rectClient.top >= wndPtr->rectClient.bottom) ||
 347                 (lprect->left >= wndPtr->rectClient.right) ||
 348                 (lprect->right <= wndPtr->rectClient.left) ||
 349                 (lprect->top >= wndPtr->rectClient.bottom) ||
 350                 (lprect->bottom <= wndPtr->rectClient.top) )
 351                 goto fail;
 352
 353             lprect->left = MAX( lprect->left, wndPtr->rectClient.left );
 354             lprect->right = MIN( lprect->right, wndPtr->rectClient.right );
 355             lprect->top = MAX( lprect->top, wndPtr->rectClient.top );
 356             lprect->bottom = MIN( lprect->bottom, wndPtr->rectClient.bottom );
 357         }
 358         OffsetRect32( lprect, -xoffset, -yoffset );
 359         return TRUE;
 360     }
 361
 362 fail:
 363     SetRectEmpty32( lprect );
 364     return FALSE;
 365 }
 366
 367
 368 /***********************************************************************
 369  *           DCE_AddClipRects
 370  *
 371  * Go through the linked list of windows from pWndStart to pWndEnd,
 372  * adding to the clip region the intersection of the target rectangle
 373  * with an offset window rectangle.
 374  */
 375 static BOOL32 DCE_AddClipRects( WND *pWndStart, WND *pWndEnd,
 376                                 HRGN32 hrgnClip, LPRECT32 lpRect, int x, int y )
 377 {
 378     RECT32 rect;
 379
 380     if (pWndStart->window) return TRUE; /* X itself will do the clipping */
 381
 382     for (; pWndStart != pWndEnd; pWndStart = pWndStart->next)
 383     {
 384         if( !(pWndStart->dwStyle & WS_VISIBLE) ) continue;
 385
 386         rect.left = pWndStart->rectWindow.left + x;
 387         rect.top = pWndStart->rectWindow.top + y;
 388         rect.right = pWndStart->rectWindow.right + x;
 389         rect.bottom = pWndStart->rectWindow.bottom + y;
 390
 391         if( IntersectRect32( &rect, &rect, lpRect ))
 392             if(!REGION_UnionRectWithRgn( hrgnClip, &rect ))
 393                 break;
 394     }
 395     return (pWndStart == pWndEnd);
 396 }
 397
 398
 399 /***********************************************************************
 400  *           DCE_GetVisRgn
 401  *
 402  * Return the visible region of a window, i.e. the client or window area
 403  * clipped by the client area of all ancestors, and then optionally
 404  * by siblings and children.
 405  */
 406 HRGN32 DCE_GetVisRgn( HWND32 hwnd, WORD flags )
 407 {
 408     HRGN32 hrgnVis = 0;
 409     RECT32 rect;
 410     WND *wndPtr = WIN_FindWndPtr( hwnd );
 411
 412     /* Get visible rectangle and create a region with it. */
 413
 414     if (wndPtr && DCE_GetVisRect(wndPtr, !(flags & DCX_WINDOW), &rect))
 415     {
 416         if((hrgnVis = CreateRectRgnIndirect32( &rect )))
 417         {
 418             HRGN32 hrgnClip = CreateRectRgn32( 0, 0, 0, 0 );
 419             INT32 xoffset, yoffset;
 420
 421             if( hrgnClip )
 422             {
 423                 /* Compute obscured region for the visible rectangle by
 424                  * clipping children, siblings, and ancestors. Note that
 425                  * DCE_GetVisRect() returns a rectangle either in client
 426                  * or in window coordinates (for DCX_WINDOW request). */
 427
 428                 if( (flags & DCX_CLIPCHILDREN) && wndPtr->child )
 429                 {
 430                     if( flags & DCX_WINDOW )
 431                     {
 432                         /* adjust offsets since child window rectangles are
 433                          * in client coordinates */
 434
 435                         xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left;
 436                         yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top;
 437                     }
 438                     else
 439                         xoffset = yoffset = 0;
 440
 441                     DCE_AddClipRects( wndPtr->child, NULL, hrgnClip,
 442                                       &rect, xoffset, yoffset );
 443                 }
 444
 445                 /* sibling window rectangles are in client
 446                  * coordinates of the parent window */
 447
 448                 if (flags & DCX_WINDOW)
 449                 {
 450                     xoffset = -wndPtr->rectWindow.left;
 451                     yoffset = -wndPtr->rectWindow.top;
 452                 }
 453                 else
 454                 {
 455                     xoffset = -wndPtr->rectClient.left;
 456                     yoffset = -wndPtr->rectClient.top;
 457                 }
 458
 459                 if (flags & DCX_CLIPSIBLINGS && wndPtr->parent )
 460                     DCE_AddClipRects( wndPtr->parent->child,
 461                                       wndPtr, hrgnClip, &rect, xoffset, yoffset );
 462
 463                 /* Clip siblings of all ancestors that have the
 464                  * WS_CLIPSIBLINGS style
 465                  */
 466
 467                 while (wndPtr->dwStyle & WS_CHILD)
 468                 {
 469                     wndPtr = wndPtr->parent;
 470                     xoffset -= wndPtr->rectClient.left;
 471                     yoffset -= wndPtr->rectClient.top;
 472                     if(wndPtr->dwStyle & WS_CLIPSIBLINGS && wndPtr->parent)
 473                     {
 474                         DCE_AddClipRects( wndPtr->parent->child, wndPtr,
 475                                           hrgnClip, &rect, xoffset, yoffset );
 476                     }
 477                 }
 478
 479                 /* Now once we've got a jumbo clip region we have
 480                  * to substract it from the visible rectangle.
 481                  */
 482
 483                 CombineRgn32( hrgnVis, hrgnVis, hrgnClip, RGN_DIFF );
 484                 DeleteObject32( hrgnClip );
 485             }
 486             else
 487             {
 488                 DeleteObject32( hrgnVis );
 489                 hrgnVis = 0;
 490             }
 491         }
 492     }
 493     else
 494         hrgnVis = CreateRectRgn32(0, 0, 0, 0); /* empty */
 495     return hrgnVis;
 496 }
 497
 498
 499 /***********************************************************************
 500  *           DCE_SetDrawable
 501  *
 502  * Set the drawable, origin and dimensions for the DC associated to
 503  * a given window.
 504  */
 505 static void DCE_SetDrawable( WND *wndPtr, DC *dc, WORD flags, BOOL32 bSetClipOrigin )
 506 {
 507     if (!wndPtr)  /* Get a DC for the whole screen */
 508     {
 509         dc->w.DCOrgX = 0;
 510         dc->w.DCOrgY = 0;
 511         dc->u.x.drawable = rootWindow;
 512         TSXSetSubwindowMode( display, dc->u.x.gc, IncludeInferiors );
 513     }
 514     else
 515     {
 516         if (flags & DCX_WINDOW)
 517         {
 518             dc->w.DCOrgX  = wndPtr->rectWindow.left;
 519             dc->w.DCOrgY  = wndPtr->rectWindow.top;
 520         }
 521         else
 522         {
 523             dc->w.DCOrgX  = wndPtr->rectClient.left;
 524             dc->w.DCOrgY  = wndPtr->rectClient.top;
 525         }
 526         while (!wndPtr->window)
 527         {
 528             wndPtr = wndPtr->parent;
 529             dc->w.DCOrgX += wndPtr->rectClient.left;
 530             dc->w.DCOrgY += wndPtr->rectClient.top;
 531         }
 532         dc->w.DCOrgX -= wndPtr->rectWindow.left;
 533         dc->w.DCOrgY -= wndPtr->rectWindow.top;
 534         dc->u.x.drawable = wndPtr->window;
 535
 536         /* This is needed when we reuse a cached DC because
 537          * SetDCState() called by ReleaseDC() screws up DC
 538          * origins for child windows.
 539          */
 540
 541         if( bSetClipOrigin )
 542             TSXSetClipOrigin( display, dc->u.x.gc, dc->w.DCOrgX, dc->w.DCOrgY );
 543     }
 544 }
 545 /***********************************************************************
 546  *           DCE_ExcludeRgn
 547  *
 548  *  Translate given region from the wnd client to the DC coordinates
 549  *  and add it to the clipping region.
 550  */
 551 INT16 DCE_ExcludeRgn( HDC32 hDC, WND* wnd, HRGN32 hRgn )
 552 {
 553   INT16    ret;
 554   POINT32  pt = {0, 0};
 555   HRGN32   hRgnClip = GetClipRgn16( hDC );
 556   DCE     *dce = firstDCE;
 557
 558   while (dce && (dce->hDC != hDC)) dce = dce->next;
 559   if( dce )
 560   {
 561       MapWindowPoints32( wnd->hwndSelf, dce->hwndCurrent, &pt, 1);
 562       if( dce->DCXflags & DCX_WINDOW )
 563       {
 564           wnd = WIN_FindWndPtr(dce->hwndCurrent);
 565           pt.x += wnd->rectClient.left - wnd->rectWindow.left;
 566           pt.y += wnd->rectClient.top - wnd->rectWindow.top;
 567       }
 568   }
 569   else return ERROR;
 570   OffsetRgn32(hRgn, pt.x, pt.y);
 571   if( hRgnClip ) ret = CombineRgn32( hRgnClip, hRgnClip, hRgn, RGN_DIFF );
 572   else
 573   {
 574       hRgnClip = InquireVisRgn( hDC );
 575       ret = CombineRgn32( hRgn, hRgnClip, hRgn, RGN_DIFF );
 576       SelectClipRgn32( hDC, hRgn );
 577   }
 578   return ret;
 579 }
 580
 581 /***********************************************************************
 582  *           GetDCEx16    (USER.359)
 583  */
 584 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
 585 {
 586     return (HDC16)GetDCEx32( hwnd, hrgnClip, flags );
 587 }
 588
 589
 590 /***********************************************************************
 591  *           GetDCEx32    (USER32.230)
 592  *
 593  * Unimplemented flags: DCX_LOCKWINDOWUPDATE
 594  *
 595  * FIXME: Full support for hrgnClip == 1 (alias for entire window).
 596  */
 597 HDC32 WINAPI GetDCEx32( HWND32 hwnd, HRGN32 hrgnClip, DWORD flags )
 598 {
 599     HRGN32      hrgnVisible = 0;
 600     HDC32       hdc = 0;
 601     DCE *       dce;
 602     DC *        dc;
 603     WND *       wndPtr;
 604     DWORD       dcxFlags = 0;
 605     BOOL32      bUpdateVisRgn = TRUE;
 606     BOOL32      bUpdateClipOrigin = FALSE;
 607
 608     TRACE(dc,"hwnd %04x, hrgnClip %04x, flags %08x\n",
 609                                 hwnd, hrgnClip, (unsigned)flags);
 610
 611     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 612
 613     /* fixup flags */
 614
 615     if (!(wndPtr->class->style & (CS_OWNDC | CS_CLASSDC))) flags |= DCX_CACHE;
 616
 617     if (flags & DCX_USESTYLE)
 618     {
 619         flags &= ~( DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
 620
 621         if( wndPtr->dwStyle & WS_CLIPSIBLINGS )
 622             flags |= DCX_CLIPSIBLINGS;
 623
 624         if ( !(flags & DCX_WINDOW) )
 625         {
 626             if (wndPtr->class->style & CS_PARENTDC) flags |= DCX_PARENTCLIP;
 627
 628             if (wndPtr->dwStyle & WS_CLIPCHILDREN &&
 629                      !(wndPtr->dwStyle & WS_MINIMIZE) ) flags |= DCX_CLIPCHILDREN;
 630         }
 631         else flags |= DCX_CACHE;
 632     }
 633
 634     if( flags & DCX_NOCLIPCHILDREN )
 635     {
 636         flags |= DCX_CACHE;
 637         flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN);
 638     }
 639
 640     if (flags & DCX_WINDOW)
 641         flags = (flags & ~DCX_CLIPCHILDREN) | DCX_CACHE;
 642
 643     if (!(wndPtr->dwStyle & WS_CHILD) || !wndPtr->parent )
 644         flags &= ~DCX_PARENTCLIP;
 645     else if( flags & DCX_PARENTCLIP )
 646     {
 647         flags |= DCX_CACHE;
 648         if( !(flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) )
 649             if( (wndPtr->dwStyle & WS_VISIBLE) && (wndPtr->parent->dwStyle & WS_VISIBLE) )
 650             {
 651                 flags &= ~DCX_CLIPCHILDREN;
 652                 if( wndPtr->parent->dwStyle & WS_CLIPSIBLINGS )
 653                     flags |= DCX_CLIPSIBLINGS;
 654             }
 655     }
 656
 657     /* find a suitable DCE */
 658
 659     dcxFlags = flags & (DCX_PARENTCLIP | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 660                         DCX_CACHE | DCX_WINDOW);
 661
 662     if (flags & DCX_CACHE)
 663     {
 664         DCE*    dceEmpty;
 665         DCE*    dceUnused;
 666
 667         dceEmpty = dceUnused = NULL;
 668
 669         /* Strategy: First, we attempt to find a non-empty but unused DCE with
 670          * compatible flags. Next, we look for an empty entry. If the cache is
 671          * full we have to purge one of the unused entries.
 672          */
 673
 674         for (dce = firstDCE; (dce); dce = dce->next)
 675         {
 676             if ((dce->DCXflags & (DCX_CACHE | DCX_DCEBUSY)) == DCX_CACHE )
 677             {
 678                 dceUnused = dce;
 679
 680                 if (dce->DCXflags & DCX_DCEEMPTY)
 681                     dceEmpty = dce;
 682                 else
 683                 if ((dce->hwndCurrent == hwnd) &&
 684                    ((dce->DCXflags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 685                                       DCX_CACHE | DCX_WINDOW | DCX_PARENTCLIP)) == dcxFlags))
 686                 {
 687                     TRACE(dc,"\tfound valid %08x dce [%04x], flags %08x\n",
 688                                         (unsigned)dce, hwnd, (unsigned)dcxFlags );
 689                     bUpdateVisRgn = FALSE;
 690                     bUpdateClipOrigin = TRUE;
 691                     break;
 692                 }
 693             }
 694         }
 695         if (!dce) dce = (dceEmpty) ? dceEmpty : dceUnused;
 696     }
 697     else
 698     {
 699         dce = (wndPtr->class->style & CS_OWNDC) ? wndPtr->dce : wndPtr->class->dce;
 700         if( dce->hwndCurrent == hwnd )
 701         {
 702             TRACE(dc,"\tskipping hVisRgn update\n");
 703             bUpdateVisRgn = FALSE; /* updated automatically, via DCHook() */
 704
 705             if( (dce->DCXflags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN)) &&
 706                 (flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN)) )
 707             {
 708                 /* This is likely to be a nested BeginPaint(). */
 709
 710                 if( dce->hClipRgn != hrgnClip )
 711                 {
 712                     fprintf(stdnimp,"GetDCEx: new hrgnClip [%04x] smashes the previous [%04x]!\n",
 713                                      hrgnClip, dce->hClipRgn );
 714                     DCE_DeleteClipRgn( dce );
 715                 }
 716                 else
 717                     RestoreVisRgn(dce->hDC);
 718             }
 719         }
 720     }
 721     if (!dce) return 0;
 722
 723     dce->hwndCurrent = hwnd;
 724     dce->hClipRgn = 0;
 725     dce->DCXflags = dcxFlags | (flags & DCX_WINDOWPAINT) | DCX_DCEBUSY;
 726     hdc = dce->hDC;
 727
 728     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 729     bUpdateVisRgn = bUpdateVisRgn || (dc->w.flags & DC_DIRTY);
 730
 731     /* recompute visible region */
 732
 733     DCE_SetDrawable( wndPtr, dc, flags, bUpdateClipOrigin );
 734     if( bUpdateVisRgn )
 735     {
 736         TRACE(dc,"updating visrgn for %08x dce, hwnd [%04x]\n", (unsigned)dce, hwnd);
 737
 738         if (flags & DCX_PARENTCLIP)
 739         {
 740             WND *parentPtr = wndPtr->parent;
 741
 742             if( wndPtr->dwStyle & WS_VISIBLE && !(parentPtr->dwStyle & WS_MINIMIZE) )
 743             {
 744                 if( parentPtr->dwStyle & WS_CLIPSIBLINGS )
 745                     dcxFlags = DCX_CLIPSIBLINGS | (flags & ~(DCX_CLIPCHILDREN | DCX_WINDOW));
 746                 else
 747                     dcxFlags = flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_WINDOW);
 748
 749                 hrgnVisible = DCE_GetVisRgn( parentPtr->hwndSelf, dcxFlags );
 750                 if( flags & DCX_WINDOW )
 751                     OffsetRgn32( hrgnVisible, -wndPtr->rectWindow.left,
 752                                               -wndPtr->rectWindow.top );
 753                 else
 754                     OffsetRgn32( hrgnVisible, -wndPtr->rectClient.left,
 755                                               -wndPtr->rectClient.top );
 756             }
 757             else
 758                 hrgnVisible = CreateRectRgn32( 0, 0, 0, 0 );
 759         }
 760         else
 761             if ((hwnd == GetDesktopWindow32()) &&
 762                 (rootWindow == DefaultRootWindow(display)))
 763                  hrgnVisible = CreateRectRgn32( 0, 0, SYSMETRICS_CXSCREEN,
 764                                                       SYSMETRICS_CYSCREEN );
 765             else hrgnVisible = DCE_GetVisRgn( hwnd, flags );
 766
 767         dc->w.flags &= ~DC_DIRTY;
 768         dce->DCXflags &= ~DCX_DCEDIRTY;
 769         SelectVisRgn( hdc, hrgnVisible );
 770     }
 771     else
 772         TRACE(dc,"no visrgn update %08x dce, hwnd [%04x]\n", (unsigned)dce, hwnd);
 773
 774     /* apply additional region operation (if any) */
 775
 776     if( flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN) )
 777     {
 778         if( !hrgnVisible ) hrgnVisible = CreateRectRgn32( 0, 0, 0, 0 );
 779
 780         dce->DCXflags |= flags & (DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_EXCLUDERGN);
 781         dce->hClipRgn = hrgnClip;
 782
 783         TRACE(dc, "\tsaved VisRgn, clipRgn = %04x\n", hrgnClip);
 784
 785         SaveVisRgn( hdc );
 786         CombineRgn32( hrgnVisible, InquireVisRgn( hdc ), hrgnClip,
 787                       (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF );
 788         SelectVisRgn( hdc, hrgnVisible );
 789     }
 790
 791     if( hrgnVisible ) DeleteObject32( hrgnVisible );
 792
 793     TRACE(dc, "(%04x,%04x,0x%lx): returning %04x\n",
 794                hwnd, hrgnClip, flags, hdc);
 795     return hdc;
 796 }
 797
 798
 799 /***********************************************************************
 800  *           GetDC16    (USER.66)
 801  */
 802 HDC16 WINAPI GetDC16( HWND16 hwnd )
 803 {
 804     return (HDC16)GetDC32( hwnd );
 805 }
 806
 807
 808 /***********************************************************************
 809  *           GetDC32    (USER32.229)
 810  * RETURNS
 811  *      :Handle to DC
 812  *      NULL: Failure
 813  */
 814 HDC32 WINAPI GetDC32(
 815              HWND32 hwnd /* handle of window */
 816 ) {
 817     if (!hwnd)
 818         return GetDCEx32( GetDesktopWindow32(), 0, DCX_CACHE | DCX_WINDOW );
 819     return GetDCEx32( hwnd, 0, DCX_USESTYLE );
 820 }
 821
 822
 823 /***********************************************************************
 824  *           GetWindowDC16    (USER.67)
 825  */
 826 HDC16 WINAPI GetWindowDC16( HWND16 hwnd )
 827 {
 828     if (!hwnd) hwnd = GetDesktopWindow16();
 829     return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 830 }
 831
 832
 833 /***********************************************************************
 834  *           GetWindowDC32    (USER32.)
 835  */
 836 HDC32 WINAPI GetWindowDC32( HWND32 hwnd )
 837 {
 838     if (!hwnd) hwnd = GetDesktopWindow32();
 839     return GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 840 }
 841
 842
 843 /***********************************************************************
 844  *           ReleaseDC16    (USER.68)
 845  */
 846 INT16 WINAPI ReleaseDC16( HWND16 hwnd, HDC16 hdc )
 847 {
 848     return (INT16)ReleaseDC32( hwnd, hdc );
 849 }
 850
 851
 852 /***********************************************************************
 853  *           ReleaseDC32    (USER32.439)
 854  *
 855  * RETURNS
 856  *      1: Success
 857  *      0: Failure
 858  */
 859 INT32 WINAPI ReleaseDC32(
 860              HWND32 hwnd /* Handle of window - ignored */,
 861              HDC32 hdc   /* Handle of device context */
 862 ) {
 863     DCE * dce = firstDCE;
 864
 865     TRACE(dc, "%04x %04x\n", hwnd, hdc );
 866
 867     while (dce && (dce->hDC != hdc)) dce = dce->next;
 868
 869     if ( dce )
 870         if ( dce->DCXflags & DCX_DCEBUSY )
 871              return DCE_ReleaseDC( dce );
 872     return 0;
 873 }
 874
 875 /***********************************************************************
 876  *           DCHook    (USER.362)
 877  *
 878  * See "Undoc. Windows" for hints (DC, SetDCHook, SetHookFlags)..
 879  */
 880 BOOL16 WINAPI DCHook( HDC16 hDC, WORD code, DWORD data, LPARAM lParam )
 881 {
 882     HRGN32 hVisRgn;
 883     DCE *dce = firstDCE;;
 884
 885     TRACE(dc,"hDC = %04x, %i\n", hDC, code);
 886
 887     while (dce && (dce->hDC != hDC)) dce = dce->next;
 888     if (!dce) return 0;
 889
 890     switch( code )
 891     {
 892       case DCHC_INVALIDVISRGN:
 893
 894            /* GDI code calls this when it detects that the
 895             * DC is dirty (usually after SetHookFlags()). This
 896             * means that we have to recompute the visible region.
 897             */
 898
 899            if( dce->DCXflags & DCX_DCEBUSY )
 900            {
 901                SetHookFlags(hDC, DCHF_VALIDATEVISRGN);
 902                hVisRgn = DCE_GetVisRgn(dce->hwndCurrent, dce->DCXflags);
 903
 904                TRACE(dc,"\tapplying saved clipRgn\n");
 905
 906                /* clip this region with saved clipping region */
 907
 908                if ( (dce->DCXflags & DCX_INTERSECTRGN && dce->hClipRgn != 1) ||
 909                   (  dce->DCXflags & DCX_EXCLUDERGN && dce->hClipRgn) )
 910                {
 911
 912                     if( (!dce->hClipRgn && dce->DCXflags & DCX_INTERSECTRGN) ||
 913                          (dce->hClipRgn == 1 && dce->DCXflags & DCX_EXCLUDERGN) )
 914                          SetRectRgn32(hVisRgn,0,0,0,0);
 915                     else
 916                          CombineRgn32(hVisRgn, hVisRgn, dce->hClipRgn,
 917                                       (dce->DCXflags & DCX_EXCLUDERGN)? RGN_DIFF:RGN_AND);
 918                }
 919                dce->DCXflags &= ~DCX_DCEDIRTY;
 920                SelectVisRgn(hDC, hVisRgn);
 921                DeleteObject32( hVisRgn );
 922            }
 923            else /* non-fatal but shouldn't happen */
 924              WARN(dc, "DC is not in use!\n");
 925            break;
 926
 927       case DCHC_DELETEDC: /* FIXME: ?? */
 928            break;
 929
 930       default:
 931            fprintf(stdnimp,"DCHook: unknown code\n");
 932     }
 933   return 0;
 934 }
 935
 936
 937 /**********************************************************************
 938  *          WindowFromDC16   (USER32.580)
 939  */
 940 HWND16 WINAPI WindowFromDC16( HDC16 hDC )
 941 {
 942     return (HWND16)WindowFromDC32( hDC );
 943 }
 944
 945
 946 /**********************************************************************
 947  *          WindowFromDC32   (USER32.580)
 948  */
 949 HWND32 WINAPI WindowFromDC32( HDC32 hDC )
 950 {
 951     DCE *dce = firstDCE;
 952     while (dce && (dce->hDC != hDC)) dce = dce->next;
 953     return dce ? dce->hwndCurrent : 0;
 954 }
 955
 956
 957 /***********************************************************************
 958  *           LockWindowUpdate16   (USER.294)
 959  */
 960 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
 961 {
 962     return LockWindowUpdate32( hwnd );
 963 }
 964
 965
 966 /***********************************************************************
 967  *           LockWindowUpdate32   (USER32.377)
 968  */
 969 BOOL32 WINAPI LockWindowUpdate32( HWND32 hwnd )
 970 {
 971     /* FIXME? DCX_LOCKWINDOWUPDATE is unimplemented */
 972     return TRUE;
 973 }