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