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