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