windows/dce.c

   1 /*
   2  * USER DCE functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1996 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_DCEBUSY     - dce structure is in use
  14  * DCX_KEEPCLIPRGN - do not delete clipping region in ReleaseDC
  15  * DCX_WINDOWPAINT - BeginPaint specific flag
  16  */
  17
  18 #include "dce.h"
  19 #include "class.h"
  20 #include "win.h"
  21 #include "gdi.h"
  22 #include "heap.h"
  23 #include "sysmetrics.h"
  24 #include "stddebug.h"
  25 /* #define DEBUG_DC */
  26 #include "debug.h"
  27
  28 #define NB_DCE    5  /* Number of DCEs created at startup */
  29
  30 static DCE *firstDCE = 0;
  31 static HDC32 defaultDCstate = 0;
  32
  33 /***********************************************************************
  34  *           DCE_AllocDCE
  35 *
  36  * Allocate a new DCE.
  37  */
  38 DCE *DCE_AllocDCE( HWND32 hWnd, DCE_TYPE type )
  39 {
  40     DCE * dce;
  41     if (!(dce = HeapAlloc( SystemHeap, 0, sizeof(DCE) ))) return NULL;
  42     if (!(dce->hDC = CreateDC16( "DISPLAY", NULL, NULL, NULL )))
  43     {
  44         HeapFree( SystemHeap, 0, dce );
  45         return 0;
  46     }
  47
  48     /* store DCE handle in DC hook data field */
  49
  50     SetDCHook( dce->hDC, (FARPROC16)DCHook, (DWORD)dce );
  51
  52     dce->hwndCurrent = hWnd;
  53     dce->hClipRgn    = 0;
  54     dce->next        = firstDCE;
  55     firstDCE = dce;
  56
  57     if( type != DCE_CACHE_DC )
  58       {
  59         dce->DCXflags = DCX_DCEBUSY;
  60         if( hWnd )
  61           {
  62             WND* wnd = WIN_FindWndPtr(hWnd);
  63
  64             if( wnd->dwStyle & WS_CLIPCHILDREN ) dce->DCXflags |= DCX_CLIPCHILDREN;
  65             if( wnd->dwStyle & WS_CLIPSIBLINGS ) dce->DCXflags |= DCX_CLIPSIBLINGS;
  66           }
  67         SetHookFlags(dce->hDC,DCHF_INVALIDATEVISRGN);
  68       }
  69     else dce->DCXflags = DCX_CACHE;
  70
  71     return dce;
  72 }
  73
  74
  75 /***********************************************************************
  76  *           DCE_FreeDCE
  77  */
  78 void DCE_FreeDCE( DCE *dce )
  79 {
  80     DCE **ppDCE = &firstDCE;
  81
  82     if (!dce) return;
  83     while (*ppDCE && (*ppDCE != dce)) ppDCE = &(*ppDCE)->next;
  84     if (*ppDCE == dce) *ppDCE = dce->next;
  85
  86     SetDCHook(dce->hDC, NULL, 0L);
  87
  88     DeleteDC32( dce->hDC );
  89     if( dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN) )
  90         DeleteObject32(dce->hClipRgn);
  91     HeapFree( SystemHeap, 0, dce );
  92 }
  93
  94
  95 /**********************************************************************
  96  *          WindowFromDC16   (USER32.580)
  97  */
  98 HWND16 WindowFromDC16( HDC16 hDC )
  99 {
 100     return (HWND16)WindowFromDC32( hDC );
 101 }
 102
 103
 104 /**********************************************************************
 105  *          WindowFromDC32   (USER32.580)
 106  */
 107 HWND32 WindowFromDC32( HDC32 hDC )
 108 {
 109     DCE *dce = firstDCE;
 110     while (dce && (dce->hDC != hDC)) dce = dce->next;
 111     return dce ? dce->hwndCurrent : 0;
 112 }
 113
 114
 115 /***********************************************************************
 116  *   DCE_InvalidateDCE
 117  *
 118  * It is called from SetWindowPos - we have to invalidate all busy
 119  * DCE's for windows whose client rect intersects with update rectangle
 120  */
 121 BOOL32 DCE_InvalidateDCE(WND* wndScope, RECT32* pRectUpdate)
 122 {
 123     BOOL32 bRet = FALSE;
 124     DCE *dce;
 125
 126  if( !wndScope ) return 0;
 127
 128  dprintf_dc(stddeb,"InvalidateDCE: scope hwnd = %04x, (%i,%i - %i,%i)\n",
 129                     wndScope->hwndSelf, pRectUpdate->left,pRectUpdate->top,
 130                                         pRectUpdate->right,pRectUpdate->bottom);
 131  /* walk all DCE's */
 132
 133  for (dce = firstDCE; (dce); dce = dce->next)
 134   {
 135     if( dce->DCXflags & DCX_DCEBUSY )
 136       {
 137         WND * wndCurrent, * wnd;
 138
 139         wnd = wndCurrent = WIN_FindWndPtr(dce->hwndCurrent);
 140
 141         /* desktop is not critical (DC is not owned anyway) */
 142
 143         if( wnd == WIN_GetDesktop() ) continue;
 144
 145         /* check if DCE window is within z-order scope */
 146
 147         for( ; wnd ; wnd = wnd->parent )
 148             if( wnd == wndScope )
 149               {
 150                 RECT32 wndRect = wndCurrent->rectWindow;
 151
 152                 dprintf_dc(stddeb,"\tgot hwnd %04x\n", wndCurrent->hwndSelf);
 153
 154                 MapWindowPoints32( wndCurrent->parent->hwndSelf,
 155                                    wndScope->hwndSelf,
 156                                    (LPPOINT32)&wndRect, 2 );
 157                 if (IntersectRect32( &wndRect, &wndRect, pRectUpdate ))
 158                 {
 159                    SetHookFlags(dce->hDC, DCHF_INVALIDATEVISRGN);
 160                    bRet = TRUE;
 161                 }
 162                 break;
 163               }
 164       }
 165   }
 166  return bRet;
 167 }
 168
 169 /***********************************************************************
 170  *           DCE_Init
 171  */
 172 void DCE_Init()
 173 {
 174     int i;
 175     DCE * dce;
 176
 177     for (i = 0; i < NB_DCE; i++)
 178     {
 179         if (!(dce = DCE_AllocDCE( 0, DCE_CACHE_DC ))) return;
 180         if (!defaultDCstate) defaultDCstate = GetDCState( dce->hDC );
 181     }
 182 }
 183
 184
 185 /***********************************************************************
 186  *           DCE_GetVisRect
 187  *
 188  * Calc the visible rectangle of a window, i.e. the client or
 189  * window area clipped by the client area of all ancestors.
 190  * Return FALSE if the visible region is empty.
 191  */
 192 static BOOL32 DCE_GetVisRect( WND *wndPtr, BOOL32 clientArea, RECT32 *lprect )
 193 {
 194     int xoffset, yoffset;
 195
 196     *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow;
 197     xoffset = lprect->left;
 198     yoffset = lprect->top;
 199
 200     if (!(wndPtr->dwStyle & WS_VISIBLE) || (wndPtr->flags & WIN_NO_REDRAW))
 201     {
 202         SetRectEmpty32( lprect );  /* Clip everything */
 203         return FALSE;
 204     }
 205
 206     while (wndPtr->parent)
 207     {
 208         wndPtr = wndPtr->parent;
 209         if (!(wndPtr->dwStyle & WS_VISIBLE) ||
 210             (wndPtr->flags & WIN_NO_REDRAW) ||
 211             (wndPtr->dwStyle & WS_ICONIC))
 212         {
 213             SetRectEmpty32( lprect );  /* Clip everything */
 214             return FALSE;
 215         }
 216         xoffset += wndPtr->rectClient.left;
 217         yoffset += wndPtr->rectClient.top;
 218         OffsetRect32( lprect, wndPtr->rectClient.left,
 219                       wndPtr->rectClient.top );
 220
 221           /* Warning!! we assume that IntersectRect() handles the case */
 222           /* where the destination is the same as one of the sources.  */
 223         if (!IntersectRect32( lprect, lprect, &wndPtr->rectClient ))
 224             return FALSE;  /* Visible rectangle is empty */
 225     }
 226     OffsetRect32( lprect, -xoffset, -yoffset );
 227     return TRUE;
 228 }
 229
 230
 231 /***********************************************************************
 232  *           DCE_ClipWindows
 233  *
 234  * Go through the linked list of windows from hwndStart to hwndEnd,
 235  * removing from the given region the rectangle of each window offset
 236  * by a given amount.  The new region is returned, and the original one
 237  * is destroyed.  Used to implement DCX_CLIPSIBLINGS and
 238  * DCX_CLIPCHILDREN styles. Now it skips managed windows
 239  * because we have no idea about decoration size anyway.
 240  */
 241 static HRGN32 DCE_ClipWindows( WND *pWndStart, WND *pWndEnd,
 242                                HRGN32 hrgn, int xoffset, int yoffset )
 243 {
 244     HRGN32 hrgnNew;
 245
 246     if ( pWndStart == NULL ) return hrgn;
 247     if ( (hrgnNew = CreateRectRgn32( 0, 0, 0, 0 )) )
 248     {
 249         for (; pWndStart != pWndEnd; pWndStart = pWndStart->next)
 250         {
 251             if ( !(pWndStart->dwStyle & WS_VISIBLE) ||
 252                  (pWndStart->flags & WIN_MANAGED) ) continue;
 253
 254             SetRectRgn32( hrgnNew, pWndStart->rectWindow.left + xoffset,
 255                                    pWndStart->rectWindow.top + yoffset,
 256                                    pWndStart->rectWindow.right + xoffset,
 257                                    pWndStart->rectWindow.bottom + yoffset );
 258             if (!CombineRgn32( hrgn, hrgn, hrgnNew, RGN_DIFF )) break;
 259         }
 260         DeleteObject32( hrgnNew );
 261     } else pWndEnd = NULL;
 262
 263     if (pWndStart != pWndEnd)  /* something went wrong */
 264     {
 265         DeleteObject32( hrgn );
 266         return 0;
 267     }
 268     return hrgn;
 269 }
 270
 271
 272 /***********************************************************************
 273  *           DCE_GetVisRgn
 274  *
 275  * Return the visible region of a window, i.e. the client or window area
 276  * clipped by the client area of all ancestors, and then optionally
 277  * by siblings and children.
 278  */
 279 HRGN32 DCE_GetVisRgn( HWND32 hwnd, WORD flags )
 280 {
 281     RECT32 rect;
 282     HRGN32 hrgn;
 283     int xoffset, yoffset;
 284     WND *wndPtr = WIN_FindWndPtr( hwnd );
 285
 286       /* Get visible rectangle and create a region with it.
 287        */
 288
 289     if (!wndPtr || !DCE_GetVisRect( wndPtr, !(flags & DCX_WINDOW), &rect ))
 290     {
 291         return CreateRectRgn32( 0, 0, 0, 0 );  /* Visible region is empty */
 292     }
 293     if (!(hrgn = CreateRectRgnIndirect32( &rect ))) return 0;
 294
 295       /* Clip all children from the visible region */
 296
 297     if (flags & DCX_CLIPCHILDREN)
 298     {
 299         if (flags & DCX_WINDOW)
 300         {
 301             xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left;
 302             yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top;
 303         }
 304         else xoffset = yoffset = 0;
 305         hrgn = DCE_ClipWindows( wndPtr->child, NULL, hrgn, xoffset, yoffset );
 306         if (!hrgn) return 0;
 307     }
 308
 309       /* Clip siblings placed above this window */
 310
 311     if (flags & DCX_WINDOW)
 312     {
 313         xoffset = -wndPtr->rectWindow.left;
 314         yoffset = -wndPtr->rectWindow.top;
 315     }
 316     else
 317     {
 318         xoffset = -wndPtr->rectClient.left;
 319         yoffset = -wndPtr->rectClient.top;
 320     }
 321     if (flags & DCX_CLIPSIBLINGS)
 322     {
 323         hrgn = DCE_ClipWindows( wndPtr->parent ? wndPtr->parent->child : NULL,
 324                                 wndPtr, hrgn, xoffset, yoffset );
 325         if (!hrgn) return 0;
 326     }
 327
 328       /* Clip siblings of all ancestors that have the WS_CLIPSIBLINGS style */
 329
 330     while (wndPtr->dwStyle & WS_CHILD)
 331     {
 332         wndPtr = wndPtr->parent;
 333         xoffset -= wndPtr->rectClient.left;
 334         yoffset -= wndPtr->rectClient.top;
 335         hrgn = DCE_ClipWindows( wndPtr->parent ? wndPtr->parent->child : NULL,
 336                                 wndPtr, hrgn, xoffset, yoffset );
 337         if (!hrgn) return 0;
 338     }
 339     return hrgn;
 340 }
 341
 342
 343 /***********************************************************************
 344  *           DCE_SetDrawable
 345  *
 346  * Set the drawable, origin and dimensions for the DC associated to
 347  * a given window.
 348  */
 349 static void DCE_SetDrawable( WND *wndPtr, DC *dc, WORD flags )
 350 {
 351     if (!wndPtr)  /* Get a DC for the whole screen */
 352     {
 353         dc->w.DCOrgX = 0;
 354         dc->w.DCOrgY = 0;
 355         dc->u.x.drawable = rootWindow;
 356         XSetSubwindowMode( display, dc->u.x.gc, IncludeInferiors );
 357     }
 358     else
 359     {
 360         if (flags & DCX_WINDOW)
 361         {
 362             dc->w.DCOrgX  = wndPtr->rectWindow.left;
 363             dc->w.DCOrgY  = wndPtr->rectWindow.top;
 364         }
 365         else
 366         {
 367             dc->w.DCOrgX  = wndPtr->rectClient.left;
 368             dc->w.DCOrgY  = wndPtr->rectClient.top;
 369         }
 370         while (!wndPtr->window)
 371         {
 372             wndPtr = wndPtr->parent;
 373             dc->w.DCOrgX += wndPtr->rectClient.left;
 374             dc->w.DCOrgY += wndPtr->rectClient.top;
 375         }
 376         dc->w.DCOrgX -= wndPtr->rectWindow.left;
 377         dc->w.DCOrgY -= wndPtr->rectWindow.top;
 378         dc->u.x.drawable = wndPtr->window;
 379     }
 380 }
 381 /***********************************************************************
 382  *           DCE_ExcludeRgn
 383  *
 384  *  Translate given region from the wnd client to the DC coordinates
 385  *  and add it to the clipping region.
 386  */
 387 INT16 DCE_ExcludeRgn( HDC32 hDC, WND* wnd, HRGN32 hRgn )
 388 {
 389   INT16    ret;
 390   POINT32  pt = {0, 0};
 391   HRGN32   hRgnClip = GetClipRgn16( hDC );
 392   DCE     *dce = firstDCE;
 393
 394   while (dce && (dce->hDC != hDC)) dce = dce->next;
 395   if( dce )
 396   {
 397       MapWindowPoints32( wnd->hwndSelf, dce->hwndCurrent, &pt, 1);
 398       if( dce->DCXflags & DCX_WINDOW )
 399       {
 400           wnd = WIN_FindWndPtr(dce->hwndCurrent);
 401           pt.x += wnd->rectClient.left - wnd->rectWindow.left;
 402           pt.y += wnd->rectClient.top - wnd->rectWindow.top;
 403       }
 404   }
 405   else return ERROR;
 406   OffsetRgn32(hRgn, pt.x, pt.y);
 407   if( hRgnClip ) ret = CombineRgn32( hRgnClip, hRgnClip, hRgn, RGN_DIFF );
 408   else
 409   {
 410       hRgnClip = InquireVisRgn( hDC );
 411       ret = CombineRgn32( hRgn, hRgnClip, hRgn, RGN_DIFF );
 412       SelectClipRgn32( hDC, hRgn );
 413   }
 414   return ret;
 415 }
 416
 417 /***********************************************************************
 418  *           GetDCEx16    (USER.359)
 419  */
 420 HDC16 GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
 421 {
 422     return (HDC16)GetDCEx32( hwnd, hrgnClip, flags );
 423 }
 424
 425
 426 /***********************************************************************
 427  *           GetDCEx32    (USER32.230)
 428  *
 429  * Unimplemented flags: DCX_LOCKWINDOWUPDATE
 430  */
 431 HDC32 GetDCEx32( HWND32 hwnd, HRGN32 hrgnClip, DWORD flags )
 432 {
 433     HRGN32      hrgnVisible;
 434     HDC32       hdc = 0;
 435     DCE *       dce;
 436     DC *        dc;
 437     WND *       wndPtr;
 438     DWORD       dcx_flags = 0;
 439     BOOL32      need_update = TRUE;
 440
 441     dprintf_dc(stddeb,"GetDCEx: hwnd %04x, hrgnClip %04x, flags %08x\n", hwnd, hrgnClip, (unsigned)flags);
 442
 443     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 444
 445     if (!(wndPtr->class->style & (CS_OWNDC | CS_CLASSDC))) flags |= DCX_CACHE;
 446
 447     if (flags & DCX_USESTYLE)
 448     {
 449         flags &= ~( DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
 450
 451         if( wndPtr->dwStyle & WS_CLIPSIBLINGS )
 452             flags |= DCX_CLIPSIBLINGS;
 453
 454         if ( !(flags & DCX_WINDOW) )
 455         {
 456             if (wndPtr->class->style & CS_PARENTDC) flags |= DCX_PARENTCLIP;
 457
 458             if (wndPtr->dwStyle & WS_CLIPCHILDREN &&
 459                      !(wndPtr->dwStyle & WS_MINIMIZE) ) flags |= DCX_CLIPCHILDREN;
 460         }
 461         else flags |= DCX_CACHE;
 462     }
 463
 464     if( flags & DCX_NOCLIPCHILDREN )
 465     {
 466         flags |= DCX_CACHE;
 467         flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN);
 468     }
 469
 470     if (flags & DCX_WINDOW) flags = (flags & ~DCX_CLIPCHILDREN) | DCX_CACHE;
 471
 472     if (!(wndPtr->dwStyle & WS_CHILD) || !wndPtr->parent ) flags &= ~DCX_PARENTCLIP;
 473     else if( flags & DCX_PARENTCLIP )
 474     {
 475         flags |= DCX_CACHE;
 476         if( !(flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) )
 477           if( (wndPtr->dwStyle & WS_VISIBLE) && (wndPtr->parent->dwStyle & WS_VISIBLE) )
 478           {
 479               flags &= ~DCX_CLIPCHILDREN;
 480               if( wndPtr->parent->dwStyle & WS_CLIPSIBLINGS )
 481                   flags |= DCX_CLIPSIBLINGS;
 482           }
 483     }
 484
 485     if (flags & DCX_CACHE)
 486     {
 487         for (dce = firstDCE; (dce); dce = dce->next)
 488         {
 489             if ((dce->DCXflags & DCX_CACHE) && !(dce->DCXflags & DCX_DCEBUSY)) break;
 490         }
 491     }
 492     else
 493     {
 494         dce = (wndPtr->class->style & CS_OWNDC)?wndPtr->dce:wndPtr->class->dce;
 495         if( dce->hwndCurrent == hwnd )
 496         {
 497             dprintf_dc(stddeb,"\tskipping hVisRgn update\n");
 498             need_update = FALSE;
 499         }
 500
 501         if( hrgnClip && dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN))
 502         {
 503             fprintf(stdnimp,"GetDCEx: hClipRgn collision!\n");
 504             DeleteObject32( dce->hClipRgn );
 505             need_update = TRUE;
 506         }
 507     }
 508
 509     dcx_flags = flags & ( DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_CACHE | DCX_WINDOW | DCX_WINDOWPAINT);
 510
 511     if (!dce) return 0;
 512     dce->hwndCurrent = hwnd;
 513     dce->hClipRgn = 0;
 514     dce->DCXflags = dcx_flags | DCX_DCEBUSY;
 515     hdc = dce->hDC;
 516
 517     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 518
 519     DCE_SetDrawable( wndPtr, dc, flags );
 520     if( need_update || dc->w.flags & DC_DIRTY )
 521     {
 522       dprintf_dc(stddeb,"updating hDC anyway\n");
 523
 524       if (flags & DCX_PARENTCLIP)
 525         {
 526             WND *parentPtr = wndPtr->parent;
 527             dcx_flags = flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 528                                        DCX_WINDOW);
 529             if (parentPtr->dwStyle & WS_CLIPSIBLINGS)
 530                 dcx_flags |= DCX_CLIPSIBLINGS;
 531             hrgnVisible = DCE_GetVisRgn( parentPtr->hwndSelf, dcx_flags );
 532             if (flags & DCX_WINDOW)
 533                 OffsetRgn32( hrgnVisible, -wndPtr->rectWindow.left,
 534                                           -wndPtr->rectWindow.top );
 535             else OffsetRgn32( hrgnVisible, -wndPtr->rectClient.left,
 536                                            -wndPtr->rectClient.top );
 537         }
 538            /* optimize away GetVisRgn for desktop if it isn't there */
 539
 540       else if ((hwnd == GetDesktopWindow32()) &&
 541                (rootWindow == DefaultRootWindow(display)))
 542                hrgnVisible = CreateRectRgn32( 0, 0, SYSMETRICS_CXSCREEN,
 543                                                     SYSMETRICS_CYSCREEN );
 544       else hrgnVisible = DCE_GetVisRgn( hwnd, flags );
 545
 546       if( wndPtr->parent && wndPtr->window )
 547       {
 548         WND*    wnd = wndPtr->parent->child;
 549         RECT32  rect;
 550
 551         for( ; wnd != wndPtr; wnd = wnd->next )
 552            if( wnd->class->style & CS_SAVEBITS &&
 553                wnd->dwStyle & WS_VISIBLE &&
 554                IntersectRect32(&rect, &wndPtr->rectClient, &wnd->rectClient) )
 555                wnd->flags |= WIN_SAVEUNDER_OVERRIDE;
 556       }
 557
 558       dc->w.flags &= ~DC_DIRTY;
 559       SelectVisRgn( hdc, hrgnVisible );
 560     }
 561     else hrgnVisible = CreateRectRgn32( 0, 0, 0, 0 );
 562
 563     if( flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN) )
 564     {
 565         dce->DCXflags |= flags & (DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_EXCLUDERGN);
 566         dce->hClipRgn = hrgnClip;
 567
 568         dprintf_dc(stddeb, "\tsaved VisRgn, clipRgn = %04x\n", hrgnClip);
 569
 570         SaveVisRgn( hdc );
 571         CombineRgn32( hrgnVisible, InquireVisRgn( hdc ), hrgnClip,
 572                       (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF );
 573         SelectVisRgn( hdc, hrgnVisible );
 574     }
 575     DeleteObject32( hrgnVisible );
 576
 577     dprintf_dc(stddeb, "GetDCEx(%04x,%04x,0x%lx): returning %04x\n",
 578                hwnd, hrgnClip, flags, hdc);
 579     return hdc;
 580 }
 581
 582
 583 /***********************************************************************
 584  *           GetDC16    (USER.66)
 585  */
 586 HDC16 GetDC16( HWND16 hwnd )
 587 {
 588     return (HDC16)GetDC32( hwnd );
 589 }
 590
 591
 592 /***********************************************************************
 593  *           GetDC32    (USER32.229)
 594  */
 595 HDC32 GetDC32( HWND32 hwnd )
 596 {
 597     if (!hwnd)
 598         return GetDCEx32( GetDesktopWindow32(), 0, DCX_CACHE | DCX_WINDOW );
 599     return GetDCEx32( hwnd, 0, DCX_USESTYLE );
 600 }
 601
 602
 603 /***********************************************************************
 604  *           GetWindowDC16    (USER.67)
 605  */
 606 HDC16 GetWindowDC16( HWND16 hwnd )
 607 {
 608     if (!hwnd) hwnd = GetDesktopWindow16();
 609     return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 610 }
 611
 612
 613 /***********************************************************************
 614  *           GetWindowDC32    (USER32.)
 615  */
 616 HDC32 GetWindowDC32( HWND32 hwnd )
 617 {
 618     if (!hwnd) hwnd = GetDesktopWindow32();
 619     return GetDCEx32( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 620 }
 621
 622
 623 /***********************************************************************
 624  *           ReleaseDC16    (USER.68)
 625  */
 626 INT16 ReleaseDC16( HWND16 hwnd, HDC16 hdc )
 627 {
 628     return (INT32)ReleaseDC32( hwnd, hdc );
 629 }
 630
 631
 632 /***********************************************************************
 633  *           ReleaseDC32    (USER32.439)
 634  */
 635 INT32 ReleaseDC32( HWND32 hwnd, HDC32 hdc )
 636 {
 637     DCE * dce = firstDCE;
 638
 639     dprintf_dc(stddeb, "ReleaseDC: %04x %04x\n", hwnd, hdc );
 640
 641     while (dce && (dce->hDC != hdc)) dce = dce->next;
 642     if (!dce) return 0;
 643     if (!(dce->DCXflags & DCX_DCEBUSY) ) return 0;
 644
 645     /* restore previous visible region */
 646
 647     if ( dce->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN) &&
 648         (dce->DCXflags & DCX_CACHE || dce->DCXflags & DCX_WINDOWPAINT) )
 649     {
 650         dprintf_dc(stddeb,"\tcleaning up visrgn...\n");
 651         dce->DCXflags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN | DCX_WINDOWPAINT);
 652
 653         if( dce->DCXflags & DCX_KEEPCLIPRGN )
 654             dce->DCXflags &= ~DCX_KEEPCLIPRGN;
 655         else
 656             if( dce->hClipRgn > 1 )
 657                 DeleteObject32( dce->hClipRgn );
 658
 659         dce->hClipRgn = 0;
 660         RestoreVisRgn(dce->hDC);
 661     }
 662
 663     if (dce->DCXflags & DCX_CACHE)
 664     {
 665         SetDCState( dce->hDC, defaultDCstate );
 666         dce->DCXflags = DCX_CACHE;
 667         dce->hwndCurrent = 0;
 668     }
 669     return 1;
 670 }
 671
 672 /***********************************************************************
 673  *           DCHook    (USER.362)
 674  *
 675  * See "Undoc. Windows" for hints (DC, SetDCHook, SetHookFlags)..
 676  */
 677 BOOL16 DCHook( HDC16 hDC, WORD code, DWORD data, LPARAM lParam )
 678 {
 679     HRGN32 hVisRgn;
 680     DCE *dce = firstDCE;;
 681
 682     dprintf_dc(stddeb,"DCHook: hDC = %04x, %i\n", hDC, code);
 683
 684     while (dce && (dce->hDC != hDC)) dce = dce->next;
 685     if (!dce) return 0;
 686
 687   switch( code )
 688     {
 689       case DCHC_INVALIDVISRGN:
 690          {
 691            if( dce->DCXflags & DCX_DCEBUSY )
 692              {
 693                SetHookFlags(hDC, DCHF_VALIDATEVISRGN);
 694                hVisRgn = DCE_GetVisRgn(dce->hwndCurrent, dce->DCXflags);
 695
 696                dprintf_dc(stddeb,"\tapplying saved clipRgn\n");
 697
 698                /* clip this region with saved clipping region */
 699
 700                if ( (dce->DCXflags & DCX_INTERSECTRGN && dce->hClipRgn != 1) ||
 701                   (  dce->DCXflags & DCX_EXCLUDERGN && dce->hClipRgn) )
 702                   {
 703
 704                     if( (!dce->hClipRgn && dce->DCXflags & DCX_INTERSECTRGN) ||
 705                          (dce->hClipRgn == 1 && dce->DCXflags & DCX_EXCLUDERGN) )
 706                          SetRectRgn32(hVisRgn,0,0,0,0);
 707                     else
 708                          CombineRgn32(hVisRgn, hVisRgn, dce->hClipRgn,
 709                                       (dce->DCXflags & DCX_EXCLUDERGN)? RGN_DIFF:RGN_AND);
 710                   }
 711                SelectVisRgn(hDC, hVisRgn);
 712                DeleteObject32( hVisRgn );
 713              }
 714            else
 715              dprintf_dc(stddeb,"DCHook: DC is not in use!\n");
 716          }
 717          break;
 718
 719       case DCHC_DELETEDC: /* FIXME: ?? */
 720          break;
 721
 722       default:
 723          fprintf(stdnimp,"DCHook: unknown code\n");
 724     }
 725   return 0;
 726 }
 727
 728
 729 /***********************************************************************
 730  *           LockWindowUpdate16   (USER.294)
 731  */
 732 BOOL16 LockWindowUpdate16( HWND16 hwnd )
 733 {
 734     return LockWindowUpdate32( hwnd );
 735 }
 736
 737
 738 /***********************************************************************
 739  *           LockWindowUpdate32   (USER32.377)
 740  */
 741 BOOL32 LockWindowUpdate32( HWND32 hwnd )
 742 {
 743     /* FIXME? DCX_LOCKWINDOWUPDATE is unimplemented */
 744     return TRUE;
 745 }