windows/dce.c

   1 /*
   2  * USER DCE functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1996,1997 Alex Korobka
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *
  22  * Note: Visible regions of CS_OWNDC/CS_CLASSDC window DCs
  23  * have to be updated dynamically.
  24  *
  25  * Internal DCX flags:
  26  *
  27  * DCX_DCEEMPTY    - dce is uninitialized
  28  * DCX_DCEBUSY     - dce is in use
  29  * DCX_DCEDIRTY    - ReleaseDC() should wipe instead of caching
  30  * DCX_KEEPCLIPRGN - ReleaseDC() should not delete the clipping region
  31  * DCX_WINDOWPAINT - BeginPaint() is in effect
  32  */
  33
  34 #include <assert.h>
  35 #include "dce.h"
  36 #include "win.h"
  37 #include "user.h"
  38 #include "wine/debug.h"
  39 #include "windef.h"
  40 #include "wingdi.h"
  41 #include "wownt32.h"
  42 #include "wine/winbase16.h"
  43 #include "wine/winuser16.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(dc);
  46
  47 static DCE *firstDCE;
  48 static HDC16 defaultDCstate;
  49
  50 static void DCE_DeleteClipRgn( DCE* );
  51 static INT DCE_ReleaseDC( DCE* );
  52
  53
  54 /***********************************************************************
  55  *           DCE_DumpCache
  56  */
  57 static void DCE_DumpCache(void)
  58 {
  59     DCE *dce;
  60
  61     USER_Lock();
  62     dce = firstDCE;
  63
  64     DPRINTF("DCE:\n");
  65     while( dce )
  66     {
  67         DPRINTF("\t[0x%08x] hWnd %p, dcx %08x, %s %s\n",
  68              (unsigned)dce, dce->hwndCurrent, (unsigned)dce->DCXflags,
  69              (dce->DCXflags & DCX_CACHE) ? "Cache" : "Owned",
  70              (dce->DCXflags & DCX_DCEBUSY) ? "InUse" : "" );
  71         dce = dce->next;
  72     }
  73
  74     USER_Unlock();
  75 }
  76
  77 /***********************************************************************
  78  *           DCE_AllocDCE
  79  *
  80  * Allocate a new DCE.
  81  */
  82 DCE *DCE_AllocDCE( HWND hWnd, DCE_TYPE type )
  83 {
  84     DCE * dce;
  85
  86     if (!(dce = HeapAlloc( GetProcessHeap(), 0, sizeof(DCE) ))) return NULL;
  87     if (!(dce->hDC = CreateDCA( "DISPLAY", NULL, NULL, NULL )))
  88     {
  89         HeapFree( GetProcessHeap(), 0, dce );
  90         return 0;
  91     }
  92     if (!defaultDCstate) defaultDCstate = GetDCState16( HDC_16(dce->hDC) );
  93
  94     /* store DCE handle in DC hook data field */
  95
  96     SetDCHook( dce->hDC, DCHook16, (DWORD)dce );
  97
  98     dce->hwndCurrent = WIN_GetFullHandle( hWnd );
  99     dce->hClipRgn    = 0;
 100
 101     if( type != DCE_CACHE_DC ) /* owned or class DC */
 102     {
 103         dce->DCXflags = DCX_DCEBUSY;
 104         if( hWnd )
 105         {
 106             LONG style = GetWindowLongW( hWnd, GWL_STYLE );
 107             if (style & WS_CLIPCHILDREN) dce->DCXflags |= DCX_CLIPCHILDREN;
 108             if (style & WS_CLIPSIBLINGS) dce->DCXflags |= DCX_CLIPSIBLINGS;
 109         }
 110         SetHookFlags16( HDC_16(dce->hDC), DCHF_INVALIDATEVISRGN );
 111     }
 112     else dce->DCXflags = DCX_CACHE | DCX_DCEEMPTY;
 113
 114     USER_Lock();
 115     dce->next = firstDCE;
 116     firstDCE = dce;
 117     USER_Unlock();
 118     return dce;
 119 }
 120
 121
 122 /***********************************************************************
 123  *           DCE_FreeDCE
 124  */
 125 DCE* DCE_FreeDCE( DCE *dce )
 126 {
 127     DCE **ppDCE, *ret;
 128
 129     if (!dce) return NULL;
 130
 131     USER_Lock();
 132
 133     ppDCE = &firstDCE;
 134
 135     while (*ppDCE && (*ppDCE != dce)) ppDCE = &(*ppDCE)->next;
 136     if (*ppDCE == dce) *ppDCE = dce->next;
 137     ret = *ppDCE;
 138     USER_Unlock();
 139
 140     SetDCHook(dce->hDC, NULL, 0L);
 141
 142     DeleteDC( dce->hDC );
 143     if( dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN) )
 144         DeleteObject(dce->hClipRgn);
 145     HeapFree( GetProcessHeap(), 0, dce );
 146
 147     return ret;
 148 }
 149
 150 /***********************************************************************
 151  *           DCE_FreeWindowDCE
 152  *
 153  * Remove owned DCE and reset unreleased cache DCEs.
 154  */
 155 void DCE_FreeWindowDCE( HWND hwnd )
 156 {
 157     DCE *pDCE;
 158     WND *pWnd = WIN_GetPtr( hwnd );
 159
 160     pDCE = firstDCE;
 161     while( pDCE )
 162     {
 163         if( pDCE->hwndCurrent == hwnd )
 164         {
 165             if( pDCE == pWnd->dce ) /* owned or Class DCE*/
 166             {
 167                 if (pWnd->clsStyle & CS_OWNDC)  /* owned DCE*/
 168                 {
 169                     pDCE = DCE_FreeDCE( pDCE );
 170                     pWnd->dce = NULL;
 171                     continue;
 172                 }
 173                 else if( pDCE->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN) ) /* Class DCE*/
 174                 {
 175                     if (USER_Driver.pReleaseDC)
 176                         USER_Driver.pReleaseDC( pDCE->hwndCurrent, pDCE->hDC );
 177                     DCE_DeleteClipRgn( pDCE );
 178                     pDCE->hwndCurrent = 0;
 179                 }
 180             }
 181             else
 182             {
 183                 if( pDCE->DCXflags & DCX_DCEBUSY ) /* shared cache DCE */
 184                 {
 185                     /* FIXME: AFAICS we are doing the right thing here so
 186                      * this should be a WARN. But this is best left as an ERR
 187                      * because the 'application error' is likely to come from
 188                      * another part of Wine (i.e. it's our fault after all).
 189                      * We should change this to WARN when Wine is more stable
 190                      * (for 1.0?).
 191                      */
 192                     ERR("[%p] GetDC() without ReleaseDC()!\n",hwnd);
 193                     DCE_ReleaseDC( pDCE );
 194                 }
 195
 196                 if (pDCE->hwndCurrent && USER_Driver.pReleaseDC)
 197                     USER_Driver.pReleaseDC( pDCE->hwndCurrent, pDCE->hDC );
 198                 pDCE->DCXflags &= DCX_CACHE;
 199                 pDCE->DCXflags |= DCX_DCEEMPTY;
 200                 pDCE->hwndCurrent = 0;
 201             }
 202         }
 203         pDCE = pDCE->next;
 204     }
 205     WIN_ReleasePtr( pWnd );
 206 }
 207
 208
 209 /***********************************************************************
 210  *   DCE_DeleteClipRgn
 211  */
 212 static void DCE_DeleteClipRgn( DCE* dce )
 213 {
 214     dce->DCXflags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN | DCX_WINDOWPAINT);
 215
 216     if( dce->DCXflags & DCX_KEEPCLIPRGN )
 217         dce->DCXflags &= ~DCX_KEEPCLIPRGN;
 218     else
 219         if( dce->hClipRgn > (HRGN)1 )
 220             DeleteObject( dce->hClipRgn );
 221
 222     dce->hClipRgn = 0;
 223
 224     /* make it dirty so that the vis rgn gets recomputed next time */
 225     dce->DCXflags |= DCX_DCEDIRTY;
 226     SetHookFlags16( HDC_16(dce->hDC), DCHF_INVALIDATEVISRGN );
 227 }
 228
 229
 230 /***********************************************************************
 231  *   DCE_ReleaseDC
 232  */
 233 static INT DCE_ReleaseDC( DCE* dce )
 234 {
 235     if ((dce->DCXflags & (DCX_DCEEMPTY | DCX_DCEBUSY)) != DCX_DCEBUSY) return 0;
 236
 237     /* restore previous visible region */
 238
 239     if ((dce->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) &&
 240         (dce->DCXflags & (DCX_CACHE | DCX_WINDOWPAINT)) )
 241         DCE_DeleteClipRgn( dce );
 242
 243     if (dce->DCXflags & DCX_CACHE)
 244     {
 245         /* make the DC clean so that SetDCState doesn't try to update the vis rgn */
 246         SetHookFlags16( HDC_16(dce->hDC), DCHF_VALIDATEVISRGN );
 247         SetDCState16( HDC_16(dce->hDC), defaultDCstate );
 248         dce->DCXflags &= ~DCX_DCEBUSY;
 249         if (dce->DCXflags & DCX_DCEDIRTY)
 250         {
 251             /* don't keep around invalidated entries
 252              * because SetDCState() disables hVisRgn updates
 253              * by removing dirty bit. */
 254             if (dce->hwndCurrent && USER_Driver.pReleaseDC)
 255                 USER_Driver.pReleaseDC( dce->hwndCurrent, dce->hDC );
 256             dce->hwndCurrent = 0;
 257             dce->DCXflags &= DCX_CACHE;
 258             dce->DCXflags |= DCX_DCEEMPTY;
 259         }
 260     }
 261     return 1;
 262 }
 263
 264
 265 /***********************************************************************
 266  *   DCE_InvalidateDCE
 267  *
 268  * It is called from SetWindowPos() and EVENT_MapNotify - we have to
 269  * mark as dirty all busy DCEs for windows that have pWnd->parent as
 270  * an ancestor and whose client rect intersects with specified update
 271  * rectangle. In addition, pWnd->parent DCEs may need to be updated if
 272  * DCX_CLIPCHILDREN flag is set.  */
 273 BOOL DCE_InvalidateDCE(HWND hwnd, const RECT* pRectUpdate)
 274 {
 275     HWND hwndScope = GetAncestor( hwnd, GA_PARENT );
 276     BOOL bRet = FALSE;
 277
 278     if( hwndScope )
 279     {
 280         DCE *dce;
 281
 282         TRACE("scope hwnd = %p, (%ld,%ld - %ld,%ld)\n",
 283               hwndScope, pRectUpdate->left,pRectUpdate->top,
 284               pRectUpdate->right,pRectUpdate->bottom);
 285         if(TRACE_ON(dc))
 286           DCE_DumpCache();
 287
 288         /* walk all DCEs and fixup non-empty entries */
 289
 290         for (dce = firstDCE; (dce); dce = dce->next)
 291         {
 292             if (dce->DCXflags & DCX_DCEEMPTY) continue;
 293             if ((dce->hwndCurrent == hwndScope) && !(dce->DCXflags & DCX_CLIPCHILDREN))
 294                 continue;  /* child window positions don't bother us */
 295
 296             /* check if DCE window is within the z-order scope */
 297
 298             if (hwndScope == dce->hwndCurrent || IsChild( hwndScope, dce->hwndCurrent ))
 299             {
 300                 if (hwnd != dce->hwndCurrent)
 301                 {
 302                     /* check if the window rectangle intersects this DCE window */
 303                     RECT rect;
 304                     GetWindowRect( dce->hwndCurrent, &rect );
 305                     MapWindowPoints( 0, hwndScope, (POINT *)&rect, 2 );
 306                     if (!IntersectRect( &rect, &rect, pRectUpdate )) continue;
 307
 308                 }
 309                 if( !(dce->DCXflags & DCX_DCEBUSY) )
 310                 {
 311                     /* Don't bother with visible regions of unused DCEs */
 312
 313                     TRACE("\tpurged %p dce [%p]\n", dce, dce->hwndCurrent);
 314                     if (dce->hwndCurrent && USER_Driver.pReleaseDC)
 315                         USER_Driver.pReleaseDC( dce->hwndCurrent, dce->hDC );
 316                     dce->hwndCurrent = 0;
 317                     dce->DCXflags &= DCX_CACHE;
 318                     dce->DCXflags |= DCX_DCEEMPTY;
 319                 }
 320                 else
 321                 {
 322                     /* Set dirty bits in the hDC and DCE structs */
 323
 324                     TRACE("\tfixed up %p dce [%p]\n", dce, dce->hwndCurrent);
 325                     dce->DCXflags |= DCX_DCEDIRTY;
 326                     SetHookFlags16( HDC_16(dce->hDC), DCHF_INVALIDATEVISRGN );
 327                     bRet = TRUE;
 328                 }
 329             }
 330         } /* dce list */
 331     }
 332     return bRet;
 333 }
 334
 335
 336 /***********************************************************************
 337  *           DCE_ExcludeRgn
 338  *
 339  *  Translate given region from the wnd client to the DC coordinates
 340  *  and add it to the clipping region.
 341  */
 342 INT DCE_ExcludeRgn( HDC hDC, HWND hwnd, HRGN hRgn )
 343 {
 344   POINT  pt = {0, 0};
 345   DCE     *dce = firstDCE;
 346
 347   while (dce && (dce->hDC != hDC)) dce = dce->next;
 348   if (!dce) return ERROR;
 349
 350   MapWindowPoints( hwnd, dce->hwndCurrent, &pt, 1);
 351   if( dce->DCXflags & DCX_WINDOW )
 352   {
 353       WND *wnd = WIN_FindWndPtr(dce->hwndCurrent);
 354       pt.x += wnd->rectClient.left - wnd->rectWindow.left;
 355       pt.y += wnd->rectClient.top - wnd->rectWindow.top;
 356       WIN_ReleaseWndPtr(wnd);
 357   }
 358   OffsetRgn(hRgn, pt.x, pt.y);
 359
 360   return ExtSelectClipRgn( hDC, hRgn, RGN_DIFF );
 361 }
 362
 363
 364 /***********************************************************************
 365  *              GetDCEx (USER32.@)
 366  *
 367  * Unimplemented flags: DCX_LOCKWINDOWUPDATE
 368  *
 369  * FIXME: Full support for hrgnClip == 1 (alias for entire window).
 370  */
 371 HDC WINAPI GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
 372 {
 373     HDC         hdc = 0;
 374     DCE *       dce;
 375     WND *       wndPtr;
 376     DWORD       dcxFlags = 0;
 377     BOOL        bUpdateVisRgn = TRUE;
 378     BOOL        bUpdateClipOrigin = FALSE;
 379     HWND parent, full;
 380
 381     TRACE("hwnd %p, hrgnClip %p, flags %08lx\n", hwnd, hrgnClip, flags);
 382
 383     if (flags & (DCX_LOCKWINDOWUPDATE)) {
 384        FIXME("not yet supported - see source\n");
 385        /* See the comment in LockWindowUpdate for more explanation. This flag is not implemented
 386         * by that patch, but we need LockWindowUpdate implemented correctly before this can be done.
 387         */
 388     }
 389
 390     if (!hwnd) hwnd = GetDesktopWindow();
 391     if (!(full = WIN_IsCurrentProcess( hwnd )))
 392     {
 393         FIXME( "not supported yet on other process window %p\n", hwnd );
 394         return 0;
 395     }
 396     hwnd = full;
 397     if (!(wndPtr = WIN_GetPtr( hwnd ))) return 0;
 398
 399     /* fixup flags */
 400
 401     if (flags & (DCX_WINDOW | DCX_PARENTCLIP)) flags |= DCX_CACHE;
 402
 403     if (flags & DCX_USESTYLE)
 404     {
 405         flags &= ~( DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
 406
 407         if( wndPtr->dwStyle & WS_CLIPSIBLINGS )
 408             flags |= DCX_CLIPSIBLINGS;
 409
 410         if ( !(flags & DCX_WINDOW) )
 411         {
 412             if (wndPtr->clsStyle & CS_PARENTDC) flags |= DCX_PARENTCLIP;
 413
 414             if (wndPtr->dwStyle & WS_CLIPCHILDREN &&
 415                      !(wndPtr->dwStyle & WS_MINIMIZE) ) flags |= DCX_CLIPCHILDREN;
 416             if (!wndPtr->dce) flags |= DCX_CACHE;
 417         }
 418     }
 419
 420     if (flags & DCX_WINDOW) flags &= ~DCX_CLIPCHILDREN;
 421
 422     parent = GetAncestor( hwnd, GA_PARENT );
 423     if (!parent || (parent == GetDesktopWindow()))
 424         flags = (flags & ~DCX_PARENTCLIP) | DCX_CLIPSIBLINGS;
 425
 426     /* it seems parent clip is ignored when clipping siblings or children */
 427     if (flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) flags &= ~DCX_PARENTCLIP;
 428
 429     if( flags & DCX_PARENTCLIP )
 430     {
 431         LONG parent_style = GetWindowLongW( parent, GWL_STYLE );
 432         if( (wndPtr->dwStyle & WS_VISIBLE) && (parent_style & WS_VISIBLE) )
 433         {
 434             flags &= ~DCX_CLIPCHILDREN;
 435             if (parent_style & WS_CLIPSIBLINGS) flags |= DCX_CLIPSIBLINGS;
 436         }
 437     }
 438
 439     /* find a suitable DCE */
 440
 441     dcxFlags = flags & (DCX_PARENTCLIP | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 442                         DCX_CACHE | DCX_WINDOW);
 443
 444     if (flags & DCX_CACHE)
 445     {
 446         DCE*    dceEmpty;
 447         DCE*    dceUnused;
 448
 449         dceEmpty = dceUnused = NULL;
 450
 451         /* Strategy: First, we attempt to find a non-empty but unused DCE with
 452          * compatible flags. Next, we look for an empty entry. If the cache is
 453          * full we have to purge one of the unused entries.
 454          */
 455
 456         for (dce = firstDCE; (dce); dce = dce->next)
 457         {
 458             if ((dce->DCXflags & (DCX_CACHE | DCX_DCEBUSY)) == DCX_CACHE )
 459             {
 460                 dceUnused = dce;
 461
 462                 if (dce->DCXflags & DCX_DCEEMPTY)
 463                     dceEmpty = dce;
 464                 else
 465                 if ((dce->hwndCurrent == hwnd) &&
 466                    ((dce->DCXflags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 467                                       DCX_CACHE | DCX_WINDOW | DCX_PARENTCLIP)) == dcxFlags))
 468                 {
 469                     TRACE("\tfound valid %p dce [%p], flags %08lx\n",
 470                           dce, hwnd, dcxFlags );
 471                     bUpdateVisRgn = FALSE;
 472                     bUpdateClipOrigin = TRUE;
 473                     break;
 474                 }
 475             }
 476         }
 477
 478         if (!dce) dce = (dceEmpty) ? dceEmpty : dceUnused;
 479
 480         /* if there's no dce empty or unused, allocate a new one */
 481         if (!dce)
 482         {
 483             dce = DCE_AllocDCE( 0, DCE_CACHE_DC );
 484         }
 485     }
 486     else
 487     {
 488         dce = wndPtr->dce;
 489         if (dce && dce->hwndCurrent == hwnd)
 490         {
 491             TRACE("\tskipping hVisRgn update\n");
 492             bUpdateVisRgn = FALSE; /* updated automatically, via DCHook() */
 493         }
 494     }
 495     if (!dce)
 496     {
 497         hdc = 0;
 498         goto END;
 499     }
 500
 501     if (!(flags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN))) hrgnClip = 0;
 502
 503     if (((flags ^ dce->DCXflags) & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) &&
 504         (dce->hClipRgn != hrgnClip))
 505     {
 506         /* if the extra clip region has changed, get rid of the old one */
 507         DCE_DeleteClipRgn( dce );
 508     }
 509
 510     dce->hwndCurrent = hwnd;
 511     dce->hClipRgn = hrgnClip;
 512     dce->DCXflags = flags & (DCX_PARENTCLIP | DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 513                              DCX_CACHE | DCX_WINDOW | DCX_WINDOWPAINT |
 514                              DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_EXCLUDERGN);
 515     dce->DCXflags |= DCX_DCEBUSY;
 516     dce->DCXflags &= ~DCX_DCEDIRTY;
 517     hdc = dce->hDC;
 518
 519     if (bUpdateVisRgn) SetHookFlags16( HDC_16(hdc), DCHF_INVALIDATEVISRGN ); /* force update */
 520
 521     if (!USER_Driver.pGetDC( hwnd, hdc, hrgnClip, flags )) hdc = 0;
 522
 523     TRACE("(%p,%p,0x%lx): returning %p\n", hwnd, hrgnClip, flags, hdc);
 524 END:
 525     WIN_ReleasePtr(wndPtr);
 526     return hdc;
 527 }
 528
 529
 530 /***********************************************************************
 531  *              GetDC (USER32.@)
 532  *
 533  * Get a device context.
 534  *
 535  * RETURNS
 536  *      Success: Handle to the device context
 537  *      Failure: NULL.
 538  */
 539 HDC WINAPI GetDC(
 540              HWND hwnd /* [in] handle of window - may be NULL */
 541 ) {
 542     if (!hwnd)
 543         return GetDCEx( 0, 0, DCX_CACHE | DCX_WINDOW );
 544     return GetDCEx( hwnd, 0, DCX_USESTYLE );
 545 }
 546
 547
 548 /***********************************************************************
 549  *              GetWindowDC (USER32.@)
 550  */
 551 HDC WINAPI GetWindowDC( HWND hwnd )
 552 {
 553     return GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 554 }
 555
 556
 557 /***********************************************************************
 558  *              ReleaseDC (USER32.@)
 559  *
 560  * Release a device context.
 561  *
 562  * RETURNS
 563  *      Success: Non-zero. Resources used by hdc are released.
 564  *      Failure: 0.
 565  */
 566 INT WINAPI ReleaseDC(
 567              HWND hwnd, /* [in] Handle of window - ignored */
 568              HDC hdc   /* [in] Handle of device context */
 569 ) {
 570     DCE * dce;
 571     INT nRet = 0;
 572
 573     USER_Lock();
 574     dce = firstDCE;
 575
 576     TRACE("%p %p\n", hwnd, hdc );
 577
 578     while (dce && (dce->hDC != hdc)) dce = dce->next;
 579
 580     if ( dce )
 581         if ( dce->DCXflags & DCX_DCEBUSY )
 582             nRet = DCE_ReleaseDC( dce );
 583
 584     USER_Unlock();
 585
 586     return nRet;
 587 }
 588
 589 /***********************************************************************
 590  *              DCHook (USER.362)
 591  *
 592  * See "Undoc. Windows" for hints (DC, SetDCHook, SetHookFlags)..
 593  */
 594 BOOL16 WINAPI DCHook16( HDC16 hDC, WORD code, DWORD data, LPARAM lParam )
 595 {
 596     BOOL retv = TRUE;
 597     DCE *dce = (DCE *)data;
 598
 599     TRACE("hDC = %04x, %i\n", hDC, code);
 600
 601     if (!dce) return 0;
 602     assert( HDC_16(dce->hDC) == hDC );
 603
 604     /* Grab the windows lock before doing anything else  */
 605     USER_Lock();
 606
 607     switch( code )
 608     {
 609       case DCHC_INVALIDVISRGN:
 610            /* GDI code calls this when it detects that the
 611             * DC is dirty (usually after SetHookFlags()). This
 612             * means that we have to recompute the visible region.
 613             */
 614            if( dce->DCXflags & DCX_DCEBUSY )
 615            {
 616                /* Dirty bit has been cleared by caller, set it again so that
 617                 * pGetDC recomputes the visible region. */
 618                SetHookFlags16( hDC, DCHF_INVALIDATEVISRGN );
 619                USER_Driver.pGetDC( dce->hwndCurrent, dce->hDC, dce->hClipRgn, dce->DCXflags );
 620            }
 621            else /* non-fatal but shouldn't happen */
 622              WARN("DC is not in use!\n");
 623            break;
 624
 625       case DCHC_DELETEDC:
 626            /*
 627             * Windows will not let you delete a DC that is busy
 628             * (between GetDC and ReleaseDC)
 629             */
 630
 631            if ( dce->DCXflags & DCX_DCEBUSY )
 632            {
 633                WARN("Application trying to delete a busy DC\n");
 634                retv = FALSE;
 635            }
 636            else DCE_FreeDCE( dce );
 637            break;
 638
 639       default:
 640            FIXME("unknown code\n");
 641     }
 642
 643   USER_Unlock();  /* Release the wnd lock */
 644   return retv;
 645 }
 646
 647
 648 /**********************************************************************
 649  *              WindowFromDC (USER32.@)
 650  */
 651 HWND WINAPI WindowFromDC( HDC hDC )
 652 {
 653     DCE *dce;
 654     HWND hwnd;
 655
 656     USER_Lock();
 657     dce = firstDCE;
 658
 659     while (dce && (dce->hDC != hDC)) dce = dce->next;
 660
 661     hwnd = dce ? dce->hwndCurrent : 0;
 662     USER_Unlock();
 663
 664     return hwnd;
 665 }
 666
 667
 668 /***********************************************************************
 669  *              LockWindowUpdate (USER32.@)
 670  */
 671 BOOL WINAPI LockWindowUpdate( HWND hwnd )
 672 {
 673     static HWND lockedWnd;
 674
 675     /* This function is fully implemented by the following patch:
 676      *
 677      * http://www.winehq.org/hypermail/wine-patches/2004/01/0142.html
 678      *
 679      * but in order to work properly, it needs the ability to invalidate
 680      * DCEs in other processes when the lock window is changed, which
 681      * isn't possible yet.
 682      * -mike
 683      */
 684
 685     FIXME("(%p), partial stub!\n",hwnd);
 686
 687     USER_Lock();
 688     if (lockedWnd)
 689     {
 690         if (!hwnd)
 691         {
 692             /* Unlock lockedWnd */
 693             /* FIXME: Do something */
 694         }
 695         else
 696         {
 697             /* Attempted to lock a second window */
 698             /* Return FALSE and do nothing */
 699             USER_Unlock();
 700             return FALSE;
 701         }
 702     }
 703     lockedWnd = hwnd;
 704     USER_Unlock();
 705     return TRUE;
 706 }