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