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 <assert.h>
  21 #include "dce.h"
  22 #include "win.h"
  23 #include "gdi.h"
  24 #include "region.h"
  25 #include "user.h"
  26 #include "debugtools.h"
  27 #include "windef.h"
  28 #include "wingdi.h"
  29 #include "wine/winbase16.h"
  30 #include "wine/winuser16.h"
  31
  32 DEFAULT_DEBUG_CHANNEL(dc);
  33
  34 static DCE *firstDCE;
  35 static HDC defaultDCstate;
  36
  37 static void DCE_DeleteClipRgn( DCE* );
  38 static INT DCE_ReleaseDC( DCE* );
  39
  40
  41 /***********************************************************************
  42  *           DCE_DumpCache
  43  */
  44 static void DCE_DumpCache(void)
  45 {
  46     DCE *dce;
  47
  48     WIN_LockWnds();
  49     dce = firstDCE;
  50
  51     DPRINTF("DCE:\n");
  52     while( dce )
  53     {
  54         DPRINTF("\t[0x%08x] hWnd 0x%04x, dcx %08x, %s %s\n",
  55              (unsigned)dce, dce->hwndCurrent, (unsigned)dce->DCXflags,
  56              (dce->DCXflags & DCX_CACHE) ? "Cache" : "Owned",
  57              (dce->DCXflags & DCX_DCEBUSY) ? "InUse" : "" );
  58         dce = dce->next;
  59     }
  60
  61     WIN_UnlockWnds();
  62 }
  63
  64 /***********************************************************************
  65  *           DCE_AllocDCE
  66  *
  67  * Allocate a new DCE.
  68  */
  69 DCE *DCE_AllocDCE( HWND hWnd, DCE_TYPE type )
  70 {
  71     FARPROC16 hookProc;
  72     DCE * dce;
  73     WND* wnd;
  74
  75     if (!(dce = HeapAlloc( GetProcessHeap(), 0, sizeof(DCE) ))) return NULL;
  76     if (!(dce->hDC = CreateDCA( "DISPLAY", NULL, NULL, NULL )))
  77     {
  78         HeapFree( GetProcessHeap(), 0, dce );
  79         return 0;
  80     }
  81     if (!defaultDCstate) defaultDCstate = GetDCState16( dce->hDC );
  82
  83     wnd = WIN_FindWndPtr(hWnd);
  84
  85     /* store DCE handle in DC hook data field */
  86
  87     hookProc = GetProcAddress16( GetModuleHandle16("USER"), (LPCSTR)362 );
  88     SetDCHook( dce->hDC, hookProc, (DWORD)dce );
  89
  90     dce->hwndCurrent = hWnd;
  91     dce->hClipRgn    = 0;
  92     dce->next        = firstDCE;
  93     firstDCE = dce;
  94
  95     if( type != DCE_CACHE_DC ) /* owned or class DC */
  96     {
  97         dce->DCXflags = DCX_DCEBUSY;
  98         if( hWnd )
  99         {
 100             if( wnd->dwStyle & WS_CLIPCHILDREN ) dce->DCXflags |= DCX_CLIPCHILDREN;
 101             if( wnd->dwStyle & WS_CLIPSIBLINGS ) dce->DCXflags |= DCX_CLIPSIBLINGS;
 102         }
 103         SetHookFlags16(dce->hDC,DCHF_INVALIDATEVISRGN);
 104     }
 105     else dce->DCXflags = DCX_CACHE | DCX_DCEEMPTY;
 106
 107     WIN_ReleaseWndPtr(wnd);
 108
 109     return dce;
 110 }
 111
 112
 113 /***********************************************************************
 114  *           DCE_FreeDCE
 115  */
 116 DCE* DCE_FreeDCE( DCE *dce )
 117 {
 118     DCE **ppDCE;
 119
 120     if (!dce) return NULL;
 121
 122     WIN_LockWnds();
 123
 124     ppDCE = &firstDCE;
 125
 126     while (*ppDCE && (*ppDCE != dce)) ppDCE = &(*ppDCE)->next;
 127     if (*ppDCE == dce) *ppDCE = dce->next;
 128
 129     SetDCHook(dce->hDC, NULL, 0L);
 130
 131     DeleteDC( dce->hDC );
 132     if( dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN) )
 133         DeleteObject(dce->hClipRgn);
 134     HeapFree( GetProcessHeap(), 0, dce );
 135
 136     WIN_UnlockWnds();
 137
 138     return *ppDCE;
 139 }
 140
 141 /***********************************************************************
 142  *           DCE_FreeWindowDCE
 143  *
 144  * Remove owned DCE and reset unreleased cache DCEs.
 145  */
 146 void DCE_FreeWindowDCE( WND* pWnd )
 147 {
 148     DCE *pDCE;
 149
 150     WIN_LockWnds();
 151     pDCE = firstDCE;
 152
 153     while( pDCE )
 154     {
 155         if( pDCE->hwndCurrent == pWnd->hwndSelf )
 156         {
 157             if( pDCE == pWnd->dce ) /* owned or Class DCE*/
 158             {
 159                 if (pWnd->clsStyle & CS_OWNDC)  /* owned DCE*/
 160                 {
 161                     pDCE = DCE_FreeDCE( pDCE );
 162                     pWnd->dce = NULL;
 163                     continue;
 164                 }
 165                 else if( pDCE->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN) ) /* Class DCE*/
 166                 {
 167                     DCE_DeleteClipRgn( pDCE );
 168                     pDCE->hwndCurrent = 0;
 169                 }
 170             }
 171             else
 172             {
 173                 if( pDCE->DCXflags & DCX_DCEBUSY ) /* shared cache DCE */
 174                 {
 175                     /* FIXME: AFAICS we are doing the right thing here so
 176                      * this should be a WARN. But this is best left as an ERR
 177                      * because the 'application error' is likely to come from
 178                      * another part of Wine (i.e. it's our fault after all).
 179                      * We should change this to WARN when Wine is more stable
 180                      * (for 1.0?).
 181                      */
 182                     ERR("[%04x] GetDC() without ReleaseDC()!\n",
 183                         pWnd->hwndSelf);
 184                     DCE_ReleaseDC( pDCE );
 185                 }
 186
 187                 pDCE->DCXflags &= DCX_CACHE;
 188                 pDCE->DCXflags |= DCX_DCEEMPTY;
 189                 pDCE->hwndCurrent = 0;
 190             }
 191         }
 192         pDCE = pDCE->next;
 193     }
 194
 195     WIN_UnlockWnds();
 196 }
 197
 198
 199 /***********************************************************************
 200  *   DCE_DeleteClipRgn
 201  */
 202 static void DCE_DeleteClipRgn( DCE* dce )
 203 {
 204     dce->DCXflags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN | DCX_WINDOWPAINT);
 205
 206     if( dce->DCXflags & DCX_KEEPCLIPRGN )
 207         dce->DCXflags &= ~DCX_KEEPCLIPRGN;
 208     else
 209         if( dce->hClipRgn > 1 )
 210             DeleteObject( dce->hClipRgn );
 211
 212     dce->hClipRgn = 0;
 213
 214     TRACE("\trestoring VisRgn\n");
 215
 216     RestoreVisRgn16(dce->hDC);
 217 }
 218
 219
 220 /***********************************************************************
 221  *   DCE_ReleaseDC
 222  */
 223 static INT DCE_ReleaseDC( DCE* dce )
 224 {
 225     if ((dce->DCXflags & (DCX_DCEEMPTY | DCX_DCEBUSY)) != DCX_DCEBUSY) return 0;
 226
 227     /* restore previous visible region */
 228
 229     if ((dce->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) &&
 230         (dce->DCXflags & (DCX_CACHE | DCX_WINDOWPAINT)) )
 231         DCE_DeleteClipRgn( dce );
 232
 233     if (dce->DCXflags & DCX_CACHE)
 234     {
 235         SetDCState16( dce->hDC, defaultDCstate );
 236         dce->DCXflags &= ~DCX_DCEBUSY;
 237         if (dce->DCXflags & DCX_DCEDIRTY)
 238         {
 239             /* don't keep around invalidated entries
 240              * because SetDCState() disables hVisRgn updates
 241              * by removing dirty bit. */
 242
 243             dce->hwndCurrent = 0;
 244             dce->DCXflags &= DCX_CACHE;
 245             dce->DCXflags |= DCX_DCEEMPTY;
 246         }
 247     }
 248     return 1;
 249 }
 250
 251
 252 /***********************************************************************
 253  *   DCE_InvalidateDCE
 254  *
 255  * It is called from SetWindowPos() and EVENT_MapNotify - we have to
 256  * mark as dirty all busy DCEs for windows that have pWnd->parent as
 257  * an ancestor and whose client rect intersects with specified update
 258  * rectangle. In addition, pWnd->parent DCEs may need to be updated if
 259  * DCX_CLIPCHILDREN flag is set.  */
 260 BOOL DCE_InvalidateDCE(WND* pWnd, const RECT* pRectUpdate)
 261 {
 262     WND* wndScope = WIN_LockWndPtr(pWnd->parent);
 263     WND *pDesktop = WIN_GetDesktop();
 264     BOOL bRet = FALSE;
 265
 266     if( wndScope )
 267     {
 268         DCE *dce;
 269
 270         TRACE("scope hwnd = %04x, (%i,%i - %i,%i)\n",
 271                      wndScope->hwndSelf, pRectUpdate->left,pRectUpdate->top,
 272                      pRectUpdate->right,pRectUpdate->bottom);
 273         if(TRACE_ON(dc))
 274           DCE_DumpCache();
 275
 276         /* walk all DCEs and fixup non-empty entries */
 277
 278         for (dce = firstDCE; (dce); dce = dce->next)
 279         {
 280             if( !(dce->DCXflags & DCX_DCEEMPTY) )
 281             {
 282                 WND* wndCurrent = WIN_FindWndPtr(dce->hwndCurrent);
 283
 284                 if( wndCurrent )
 285                 {
 286                     WND* wnd = NULL;
 287                     INT xoffset = 0, yoffset = 0;
 288
 289                     if( (wndCurrent == wndScope) && !(dce->DCXflags & DCX_CLIPCHILDREN) )
 290                     {
 291                         /* child window positions don't bother us */
 292                         WIN_ReleaseWndPtr(wndCurrent);
 293                         continue;
 294                     }
 295
 296                     if (wndCurrent == pDesktop && !(wndCurrent->flags & WIN_NATIVE))
 297                     {
 298                         /* don't bother with fake desktop */
 299                         WIN_ReleaseWndPtr(wndCurrent);
 300                         continue;
 301                     }
 302
 303                     /* check if DCE window is within the z-order scope */
 304
 305                     for( wnd = WIN_LockWndPtr(wndCurrent); wnd; WIN_UpdateWndPtr(&wnd,wnd->parent))
 306                     {
 307                         if( wnd == wndScope )
 308                         {
 309                             RECT wndRect;
 310
 311                             wndRect = wndCurrent->rectWindow;
 312
 313                             OffsetRect( &wndRect, xoffset - wndCurrent->rectClient.left,
 314                                                     yoffset - wndCurrent->rectClient.top);
 315
 316                             if (pWnd == wndCurrent ||
 317                                 IntersectRect( &wndRect, &wndRect, pRectUpdate ))
 318                             {
 319                                 if( !(dce->DCXflags & DCX_DCEBUSY) )
 320                                 {
 321                                     /* Don't bother with visible regions of unused DCEs */
 322
 323                                     TRACE("\tpurged %08x dce [%04x]\n",
 324                                                 (unsigned)dce, wndCurrent->hwndSelf);
 325
 326                                     dce->hwndCurrent = 0;
 327                                     dce->DCXflags &= DCX_CACHE;
 328                                     dce->DCXflags |= DCX_DCEEMPTY;
 329                                 }
 330                                 else
 331                                 {
 332                                     /* Set dirty bits in the hDC and DCE structs */
 333
 334                                     TRACE("\tfixed up %08x dce [%04x]\n",
 335                                                 (unsigned)dce, wndCurrent->hwndSelf);
 336
 337                                     dce->DCXflags |= DCX_DCEDIRTY;
 338                                     SetHookFlags16(dce->hDC, DCHF_INVALIDATEVISRGN);
 339                                     bRet = TRUE;
 340                                 }
 341                             }
 342                             WIN_ReleaseWndPtr(wnd);
 343                             break;
 344                         }
 345                         xoffset += wnd->rectClient.left;
 346                         yoffset += wnd->rectClient.top;
 347                     }
 348                 }
 349                 WIN_ReleaseWndPtr(wndCurrent);
 350             }
 351         } /* dce list */
 352         WIN_ReleaseWndPtr(wndScope);
 353     }
 354     WIN_ReleaseDesktop();
 355     return bRet;
 356 }
 357
 358
 359 /***********************************************************************
 360  *           DCE_ExcludeRgn
 361  *
 362  *  Translate given region from the wnd client to the DC coordinates
 363  *  and add it to the clipping region.
 364  */
 365 INT DCE_ExcludeRgn( HDC hDC, WND* wnd, HRGN hRgn )
 366 {
 367   POINT  pt = {0, 0};
 368   DCE     *dce = firstDCE;
 369
 370   while (dce && (dce->hDC != hDC)) dce = dce->next;
 371   if( dce )
 372   {
 373       MapWindowPoints( wnd->hwndSelf, dce->hwndCurrent, &pt, 1);
 374       if( dce->DCXflags & DCX_WINDOW )
 375       {
 376           wnd = WIN_FindWndPtr(dce->hwndCurrent);
 377           pt.x += wnd->rectClient.left - wnd->rectWindow.left;
 378           pt.y += wnd->rectClient.top - wnd->rectWindow.top;
 379           WIN_ReleaseWndPtr(wnd);
 380       }
 381   }
 382   else return ERROR;
 383   OffsetRgn(hRgn, pt.x, pt.y);
 384
 385   return ExtSelectClipRgn( hDC, hRgn, RGN_DIFF );
 386 }
 387
 388
 389 /***********************************************************************
 390  *              GetDCEx (USER.359)
 391  */
 392 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
 393 {
 394     return (HDC16)GetDCEx( hwnd, hrgnClip, flags );
 395 }
 396
 397
 398 /***********************************************************************
 399  *              GetDCEx (USER32.@)
 400  *
 401  * Unimplemented flags: DCX_LOCKWINDOWUPDATE
 402  *
 403  * FIXME: Full support for hrgnClip == 1 (alias for entire window).
 404  */
 405 HDC WINAPI GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
 406 {
 407     HDC         hdc = 0;
 408     DCE *       dce;
 409     WND *       wndPtr;
 410     DWORD       dcxFlags = 0;
 411     BOOL        bUpdateVisRgn = TRUE;
 412     BOOL        bUpdateClipOrigin = FALSE;
 413
 414     TRACE("hwnd %04x, hrgnClip %04x, flags %08x\n",
 415                                 hwnd, hrgnClip, (unsigned)flags);
 416
 417     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 418
 419     /* fixup flags */
 420
 421     if (!wndPtr->dce) flags |= DCX_CACHE;
 422
 423     if (flags & DCX_USESTYLE)
 424     {
 425         flags &= ~( DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
 426
 427         if( wndPtr->dwStyle & WS_CLIPSIBLINGS )
 428             flags |= DCX_CLIPSIBLINGS;
 429
 430         if ( !(flags & DCX_WINDOW) )
 431         {
 432             if (wndPtr->clsStyle & CS_PARENTDC) flags |= DCX_PARENTCLIP;
 433
 434             if (wndPtr->dwStyle & WS_CLIPCHILDREN &&
 435                      !(wndPtr->dwStyle & WS_MINIMIZE) ) flags |= DCX_CLIPCHILDREN;
 436         }
 437         else flags |= DCX_CACHE;
 438     }
 439
 440     if( flags & DCX_NOCLIPCHILDREN )
 441     {
 442         flags |= DCX_CACHE;
 443         flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN);
 444     }
 445
 446     if (flags & DCX_WINDOW)
 447         flags = (flags & ~DCX_CLIPCHILDREN) | DCX_CACHE;
 448
 449     if (!(wndPtr->dwStyle & WS_CHILD) || !wndPtr->parent )
 450         flags &= ~DCX_PARENTCLIP;
 451     else if( flags & DCX_PARENTCLIP )
 452     {
 453         flags |= DCX_CACHE;
 454         if( !(flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) )
 455             if( (wndPtr->dwStyle & WS_VISIBLE) && (wndPtr->parent->dwStyle & WS_VISIBLE) )
 456             {
 457                 flags &= ~DCX_CLIPCHILDREN;
 458                 if( wndPtr->parent->dwStyle & WS_CLIPSIBLINGS )
 459                     flags |= DCX_CLIPSIBLINGS;
 460             }
 461     }
 462
 463     /* find a suitable DCE */
 464
 465     dcxFlags = flags & (DCX_PARENTCLIP | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 466                         DCX_CACHE | DCX_WINDOW);
 467
 468     if (flags & DCX_CACHE)
 469     {
 470         DCE*    dceEmpty;
 471         DCE*    dceUnused;
 472
 473         dceEmpty = dceUnused = NULL;
 474
 475         /* Strategy: First, we attempt to find a non-empty but unused DCE with
 476          * compatible flags. Next, we look for an empty entry. If the cache is
 477          * full we have to purge one of the unused entries.
 478          */
 479
 480         for (dce = firstDCE; (dce); dce = dce->next)
 481         {
 482             if ((dce->DCXflags & (DCX_CACHE | DCX_DCEBUSY)) == DCX_CACHE )
 483             {
 484                 dceUnused = dce;
 485
 486                 if (dce->DCXflags & DCX_DCEEMPTY)
 487                     dceEmpty = dce;
 488                 else
 489                 if ((dce->hwndCurrent == hwnd) &&
 490                    ((dce->DCXflags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 491                                       DCX_CACHE | DCX_WINDOW | DCX_PARENTCLIP)) == dcxFlags))
 492                 {
 493                     TRACE("\tfound valid %08x dce [%04x], flags %08x\n",
 494                                         (unsigned)dce, hwnd, (unsigned)dcxFlags );
 495                     bUpdateVisRgn = FALSE;
 496                     bUpdateClipOrigin = TRUE;
 497                     break;
 498                 }
 499             }
 500         }
 501
 502         if (!dce) dce = (dceEmpty) ? dceEmpty : dceUnused;
 503
 504         /* if there's no dce empty or unused, allocate a new one */
 505         if (!dce)
 506         {
 507             dce = DCE_AllocDCE( 0, DCE_CACHE_DC );
 508         }
 509     }
 510     else
 511     {
 512         dce = wndPtr->dce;
 513         if( dce->hwndCurrent == hwnd )
 514         {
 515             TRACE("\tskipping hVisRgn update\n");
 516             bUpdateVisRgn = FALSE; /* updated automatically, via DCHook() */
 517
 518             /* Abey - 16Jul99. to take care of the nested GetDC. first one
 519                with DCX_EXCLUDERGN or DCX_INTERSECTRGN flags and the next
 520                one with or without these flags. */
 521
 522             if(dce->DCXflags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN))
 523             {
 524                 /* This is likely to be a nested BeginPaint().
 525                    or a BeginPaint() followed by a GetDC()*/
 526
 527                 if( dce->hClipRgn != hrgnClip )
 528                 {
 529                     FIXME("new hrgnClip[%04x] smashes the previous[%04x]\n",
 530                           hrgnClip, dce->hClipRgn );
 531                     DCE_DeleteClipRgn( dce );
 532                 }
 533                 else
 534                     RestoreVisRgn16(dce->hDC);
 535             }
 536         }
 537     }
 538     if (!dce)
 539     {
 540         hdc = 0;
 541         goto END;
 542     }
 543
 544     if (!(flags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN))) hrgnClip = 0;
 545     dce->hwndCurrent = hwnd;
 546     dce->hClipRgn = hrgnClip;
 547     dce->DCXflags = flags & (DCX_PARENTCLIP | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 548                              DCX_CACHE | DCX_WINDOW | DCX_WINDOWPAINT |
 549                              DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_EXCLUDERGN);
 550     dce->DCXflags |= DCX_DCEBUSY;
 551     dce->DCXflags &= ~DCX_DCEDIRTY;
 552     hdc = dce->hDC;
 553
 554     if (bUpdateVisRgn) SetHookFlags16( hdc, DCHF_INVALIDATEVISRGN ); /* force update */
 555
 556     if (!USER_Driver.pGetDC( hwnd, hdc, hrgnClip, flags )) hdc = 0;
 557
 558     TRACE("(%04x,%04x,0x%lx): returning %04x\n", hwnd, hrgnClip, flags, hdc);
 559 END:
 560     WIN_ReleaseWndPtr(wndPtr);
 561     return hdc;
 562 }
 563
 564
 565 /***********************************************************************
 566  *              GetDC (USER.66)
 567  */
 568 HDC16 WINAPI GetDC16( HWND16 hwnd )
 569 {
 570     return (HDC16)GetDC( hwnd );
 571 }
 572
 573
 574 /***********************************************************************
 575  *              GetDC (USER32.@)
 576  * RETURNS
 577  *      :Handle to DC
 578  *      NULL: Failure
 579  */
 580 HDC WINAPI GetDC(
 581              HWND hwnd /* [in] handle of window */
 582 ) {
 583     if (!hwnd)
 584         return GetDCEx( GetDesktopWindow(), 0, DCX_CACHE | DCX_WINDOW );
 585     return GetDCEx( hwnd, 0, DCX_USESTYLE );
 586 }
 587
 588
 589 /***********************************************************************
 590  *              GetWindowDC (USER.67)
 591  */
 592 HDC16 WINAPI GetWindowDC16( HWND16 hwnd )
 593 {
 594     if (!hwnd) hwnd = GetDesktopWindow16();
 595     return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 596 }
 597
 598
 599 /***********************************************************************
 600  *              GetWindowDC (USER32.@)
 601  */
 602 HDC WINAPI GetWindowDC( HWND hwnd )
 603 {
 604     if (!hwnd) hwnd = GetDesktopWindow();
 605     return GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 606 }
 607
 608
 609 /***********************************************************************
 610  *              ReleaseDC (USER.68)
 611  */
 612 INT16 WINAPI ReleaseDC16( HWND16 hwnd, HDC16 hdc )
 613 {
 614     return (INT16)ReleaseDC( hwnd, hdc );
 615 }
 616
 617
 618 /***********************************************************************
 619  *              ReleaseDC (USER32.@)
 620  *
 621  * RETURNS
 622  *      1: Success
 623  *      0: Failure
 624  */
 625 INT WINAPI ReleaseDC(
 626              HWND hwnd /* [in] Handle of window - ignored */,
 627              HDC hdc   /* [in] Handle of device context */
 628 ) {
 629     DCE * dce;
 630     INT nRet = 0;
 631
 632     WIN_LockWnds();
 633     dce = firstDCE;
 634
 635     TRACE("%04x %04x\n", hwnd, hdc );
 636
 637     while (dce && (dce->hDC != hdc)) dce = dce->next;
 638
 639     if ( dce )
 640         if ( dce->DCXflags & DCX_DCEBUSY )
 641             nRet = DCE_ReleaseDC( dce );
 642
 643     WIN_UnlockWnds();
 644
 645     return nRet;
 646 }
 647
 648 /***********************************************************************
 649  *              DCHook (USER.362)
 650  *
 651  * See "Undoc. Windows" for hints (DC, SetDCHook, SetHookFlags)..
 652  */
 653 BOOL16 WINAPI DCHook16( HDC16 hDC, WORD code, DWORD data, LPARAM lParam )
 654 {
 655     BOOL retv = TRUE;
 656     DCE *dce = (DCE *)data;
 657
 658     TRACE("hDC = %04x, %i\n", hDC, code);
 659
 660     if (!dce) return 0;
 661     assert(dce->hDC == hDC);
 662
 663     /* Grab the windows lock before doing anything else  */
 664     WIN_LockWnds();
 665
 666     switch( code )
 667     {
 668       case DCHC_INVALIDVISRGN:
 669            /* GDI code calls this when it detects that the
 670             * DC is dirty (usually after SetHookFlags()). This
 671             * means that we have to recompute the visible region.
 672             */
 673            if( dce->DCXflags & DCX_DCEBUSY )
 674                USER_Driver.pGetDC( dce->hwndCurrent, dce->hDC, dce->hClipRgn, dce->DCXflags );
 675            else /* non-fatal but shouldn't happen */
 676              WARN("DC is not in use!\n");
 677            break;
 678
 679       case DCHC_DELETEDC:
 680            /*
 681             * Windows will not let you delete a DC that is busy
 682             * (between GetDC and ReleaseDC)
 683             */
 684
 685            if ( dce->DCXflags & DCX_DCEBUSY )
 686            {
 687                WARN("Application trying to delete a busy DC\n");
 688                retv = FALSE;
 689            }
 690            break;
 691
 692       default:
 693            FIXME("unknown code\n");
 694     }
 695
 696   WIN_UnlockWnds();  /* Release the wnd lock */
 697   return retv;
 698 }
 699
 700
 701 /**********************************************************************
 702  *              WindowFromDC (USER.117)
 703  */
 704 HWND16 WINAPI WindowFromDC16( HDC16 hDC )
 705 {
 706     return (HWND16)WindowFromDC( hDC );
 707 }
 708
 709
 710 /**********************************************************************
 711  *              WindowFromDC (USER32.@)
 712  */
 713 HWND WINAPI WindowFromDC( HDC hDC )
 714 {
 715     DCE *dce;
 716     HWND hwnd;
 717
 718     WIN_LockWnds();
 719     dce = firstDCE;
 720
 721     while (dce && (dce->hDC != hDC)) dce = dce->next;
 722
 723     hwnd = dce ? dce->hwndCurrent : 0;
 724     WIN_UnlockWnds();
 725
 726     return hwnd;
 727 }
 728
 729
 730 /***********************************************************************
 731  *              LockWindowUpdate (USER.294)
 732  */
 733 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
 734 {
 735     return LockWindowUpdate( hwnd );
 736 }
 737
 738
 739 /***********************************************************************
 740  *              LockWindowUpdate (USER32.@)
 741  */
 742 BOOL WINAPI LockWindowUpdate( HWND hwnd )
 743 {
 744     FIXME("DCX_LOCKWINDOWUPDATE is unimplemented\n");
 745     return TRUE;
 746 }