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