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