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