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