windows/dce.c

   1 /*
   2  * USER DCE functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1996 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_DCEBUSY     - dce structure is in use
  14  * DCX_KEEPCLIPRGN - do not delete clipping region in ReleaseDC
  15  * DCX_WINDOWPAINT - BeginPaint specific flag
  16  */
  17
  18 #include "options.h"
  19 #include "dce.h"
  20 #include "class.h"
  21 #include "win.h"
  22 #include "gdi.h"
  23 #include "user.h"
  24 #include "sysmetrics.h"
  25 #include "stddebug.h"
  26 /* #define DEBUG_DC */
  27 #include "debug.h"
  28
  29 #define NB_DCE    5  /* Number of DCEs created at startup */
  30
  31 static HANDLE firstDCE = 0;
  32 static HDC defaultDCstate = 0;
  33
  34 BOOL   DCHook(HDC, WORD, DWORD, DWORD);
  35
  36 /***********************************************************************
  37  *           DCE_AllocDCE
  38 *
  39  * Allocate a new DCE.
  40  */
  41 HANDLE DCE_AllocDCE( HWND hWnd, DCE_TYPE type )
  42 {
  43     DCE * dce;
  44     HANDLE handle = USER_HEAP_ALLOC( sizeof(DCE) );
  45     if (!handle) return 0;
  46     dce = (DCE *) USER_HEAP_LIN_ADDR( handle );
  47     if (!(dce->hDC = CreateDC( "DISPLAY", NULL, NULL, NULL )))
  48     {
  49         USER_HEAP_FREE( handle );
  50         return 0;
  51     }
  52
  53     /* store DCE handle in DC hook data field */
  54
  55     SetDCHook(dce->hDC, GDI_GetDefDCHook(), MAKELONG(handle,DC_MAGIC));
  56
  57     dce->hwndCurrent = hWnd;
  58     dce->hNext = firstDCE;
  59     dce->hClipRgn = 0;
  60     firstDCE = handle;
  61
  62     if( type != DCE_CACHE_DC )
  63       {
  64         dce->DCXflags = DCX_DCEBUSY;
  65         if( hWnd )
  66           {
  67             WND* wnd = WIN_FindWndPtr(hWnd);
  68
  69             if( wnd->dwStyle & WS_CLIPCHILDREN ) dce->DCXflags |= DCX_CLIPCHILDREN;
  70             if( wnd->dwStyle & WS_CLIPSIBLINGS ) dce->DCXflags |= DCX_CLIPSIBLINGS;
  71           }
  72         SetHookFlags(dce->hDC,DCHF_INVALIDATEVISRGN);
  73       }
  74     else dce->DCXflags = DCX_CACHE;
  75
  76     return handle;
  77 }
  78
  79
  80 /***********************************************************************
  81  *           DCE_FreeDCE
  82  */
  83 void DCE_FreeDCE( HANDLE hdce )
  84 {
  85     DCE * dce;
  86     HANDLE *handle = &firstDCE;
  87
  88     if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return;
  89     while (*handle && (*handle != hdce))
  90     {
  91         DCE * prev = (DCE *) USER_HEAP_LIN_ADDR( *handle );
  92         handle = &prev->hNext;
  93     }
  94     if (*handle == hdce) *handle = dce->hNext;
  95
  96     SetDCHook(dce->hDC,(SEGPTR)NULL,0L);
  97
  98     DeleteDC( dce->hDC );
  99     if( dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN) )
 100         DeleteObject(dce->hClipRgn);
 101     USER_HEAP_FREE( hdce );
 102 }
 103
 104 /***********************************************************************
 105  *           DCE_FindDCE
 106  */
 107 HANDLE DCE_FindDCE(HDC hDC)
 108 {
 109  HANDLE hdce = firstDCE;
 110  DCE*   dce;
 111
 112  while( hdce )
 113   {
 114     dce = (DCE *) USER_HEAP_LIN_ADDR(hdce);
 115     if( dce->hDC == hDC ) break;
 116     hdce = dce->hNext;
 117   }
 118  return hdce;
 119 }
 120
 121 /***********************************************************************
 122  *   DCE_InvalidateDCE
 123  *
 124  * It is called from SetWindowPos - we have to invalidate all busy
 125  * DCE's for windows whose client rect intersects with update rectangle
 126  */
 127 BOOL DCE_InvalidateDCE(WND* wndScope, RECT16* pRectUpdate)
 128 {
 129  HANDLE hdce;
 130  DCE*   dce;
 131
 132  if( !wndScope ) return 0;
 133
 134  dprintf_dc(stddeb,"InvalidateDCE: scope hwnd = %04x, (%i,%i - %i,%i)\n",
 135                     wndScope->hwndSelf, pRectUpdate->left,pRectUpdate->top,
 136                                         pRectUpdate->right,pRectUpdate->bottom);
 137  /* walk all DCE's */
 138
 139  for( hdce = firstDCE; (hdce); hdce=dce->hNext)
 140   {
 141     dce = (DCE*)USER_HEAP_LIN_ADDR(hdce);
 142
 143     if( dce->DCXflags & DCX_DCEBUSY )
 144       {
 145         WND * wndCurrent, * wnd;
 146
 147         wnd = wndCurrent = WIN_FindWndPtr(dce->hwndCurrent);
 148
 149         /* desktop is not critical (DC is not owned anyway) */
 150
 151         if( wnd == WIN_GetDesktop() ) continue;
 152
 153         /* check if DCE window is within z-order scope */
 154
 155         for( ; wnd ; wnd = wnd->parent )
 156             if( wnd == wndScope )
 157               {
 158                 RECT16 wndRect = wndCurrent->rectWindow;
 159
 160                 dprintf_dc(stddeb,"\tgot hwnd %04x\n", wndCurrent->hwndSelf);
 161
 162                 MapWindowPoints16(wndCurrent->parent->hwndSelf, wndScope->hwndSelf,
 163                                                                (LPPOINT16)&wndRect, 2);
 164                 if( IntersectRect16(&wndRect,&wndRect,pRectUpdate) )
 165                     SetHookFlags(dce->hDC, DCHF_INVALIDATEVISRGN);
 166                 break;
 167               }
 168       }
 169   }
 170  return 1;
 171 }
 172
 173 /***********************************************************************
 174  *           DCE_Init
 175  */
 176 void DCE_Init()
 177 {
 178     int i;
 179     HANDLE handle;
 180     DCE * dce;
 181
 182     for (i = 0; i < NB_DCE; i++)
 183     {
 184         if (!(handle = DCE_AllocDCE( 0, DCE_CACHE_DC ))) return;
 185         dce = (DCE *) USER_HEAP_LIN_ADDR( handle );
 186         if (!defaultDCstate) defaultDCstate = GetDCState( dce->hDC );
 187     }
 188 }
 189
 190
 191 /***********************************************************************
 192  *           DCE_GetVisRect
 193  *
 194  * Calc the visible rectangle of a window, i.e. the client or
 195  * window area clipped by the client area of all ancestors.
 196  * Return FALSE if the visible region is empty.
 197  */
 198 static BOOL DCE_GetVisRect( WND *wndPtr, BOOL clientArea, RECT16 *lprect )
 199 {
 200     int xoffset, yoffset;
 201
 202     *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow;
 203     xoffset = lprect->left;
 204     yoffset = lprect->top;
 205
 206     if (!(wndPtr->dwStyle & WS_VISIBLE) || (wndPtr->flags & WIN_NO_REDRAW))
 207     {
 208         SetRectEmpty16( lprect );  /* Clip everything */
 209         return FALSE;
 210     }
 211
 212     while (wndPtr->parent)
 213     {
 214         wndPtr = wndPtr->parent;
 215         if (!(wndPtr->dwStyle & WS_VISIBLE) ||
 216             (wndPtr->flags & WIN_NO_REDRAW) ||
 217             (wndPtr->dwStyle & WS_ICONIC))
 218         {
 219             SetRectEmpty16( lprect );  /* Clip everything */
 220             return FALSE;
 221         }
 222         xoffset += wndPtr->rectClient.left;
 223         yoffset += wndPtr->rectClient.top;
 224         OffsetRect16( lprect, wndPtr->rectClient.left,
 225                       wndPtr->rectClient.top );
 226
 227           /* Warning!! we assume that IntersectRect() handles the case */
 228           /* where the destination is the same as one of the sources.  */
 229         if (!IntersectRect16( lprect, lprect, &wndPtr->rectClient ))
 230             return FALSE;  /* Visible rectangle is empty */
 231     }
 232     OffsetRect16( lprect, -xoffset, -yoffset );
 233     return TRUE;
 234 }
 235
 236
 237 /***********************************************************************
 238  *           DCE_ClipWindows
 239  *
 240  * Go through the linked list of windows from hwndStart to hwndEnd,
 241  * removing from the given region the rectangle of each window offset
 242  * by a given amount.  The new region is returned, and the original one
 243  * is destroyed.  Used to implement DCX_CLIPSIBLINGS and
 244  * DCX_CLIPCHILDREN styles.
 245  */
 246 static HRGN DCE_ClipWindows( WND *pWndStart, WND *pWndEnd,
 247                              HRGN hrgn, int xoffset, int yoffset )
 248 {
 249     HRGN hrgnNew;
 250
 251     if (!pWndStart) return hrgn;
 252     if (!(hrgnNew = CreateRectRgn( 0, 0, 0, 0 )))
 253     {
 254         DeleteObject( hrgn );
 255         return 0;
 256     }
 257     for (; pWndStart != pWndEnd; pWndStart = pWndStart->next)
 258     {
 259         if (!(pWndStart->dwStyle & WS_VISIBLE)) continue;
 260         SetRectRgn( hrgnNew, pWndStart->rectWindow.left + xoffset,
 261                     pWndStart->rectWindow.top + yoffset,
 262                     pWndStart->rectWindow.right + xoffset,
 263                     pWndStart->rectWindow.bottom + yoffset );
 264         if (!CombineRgn( hrgn, hrgn, hrgnNew, RGN_DIFF )) break;
 265     }
 266     DeleteObject( hrgnNew );
 267     if (pWndStart != pWndEnd)  /* something went wrong */
 268     {
 269         DeleteObject( hrgn );
 270         return 0;
 271     }
 272     return hrgn;
 273 }
 274
 275
 276 /***********************************************************************
 277  *           DCE_GetVisRgn
 278  *
 279  * Return the visible region of a window, i.e. the client or window area
 280  * clipped by the client area of all ancestors, and then optionally
 281  * by siblings and children.
 282  */
 283 HRGN DCE_GetVisRgn( HWND hwnd, WORD flags )
 284 {
 285     RECT16 rect;
 286     HRGN hrgn;
 287     int xoffset, yoffset;
 288     WND *wndPtr = WIN_FindWndPtr( hwnd );
 289
 290       /* Get visible rectangle and create a region with it
 291        * FIXME: do we really need to calculate vis rgns for X windows?
 292        */
 293
 294     if (!wndPtr || !DCE_GetVisRect( wndPtr, !(flags & DCX_WINDOW), &rect ))
 295     {
 296         return CreateRectRgn( 0, 0, 0, 0 );  /* Visible region is empty */
 297     }
 298     if (!(hrgn = CreateRectRgnIndirect16( &rect ))) return 0;
 299
 300       /* Clip all children from the visible region */
 301
 302     if (flags & DCX_CLIPCHILDREN)
 303     {
 304         if (flags & DCX_WINDOW)
 305         {
 306             xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left;
 307             yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top;
 308         }
 309         else xoffset = yoffset = 0;
 310         hrgn = DCE_ClipWindows( wndPtr->child, NULL, hrgn, xoffset, yoffset );
 311         if (!hrgn) return 0;
 312     }
 313
 314       /* Clip siblings placed above this window */
 315
 316     if (flags & DCX_WINDOW)
 317     {
 318         xoffset = -wndPtr->rectWindow.left;
 319         yoffset = -wndPtr->rectWindow.top;
 320     }
 321     else
 322     {
 323         xoffset = -wndPtr->rectClient.left;
 324         yoffset = -wndPtr->rectClient.top;
 325     }
 326     if (flags & DCX_CLIPSIBLINGS)
 327     {
 328         hrgn = DCE_ClipWindows( wndPtr->parent ? wndPtr->parent->child : NULL,
 329                                 wndPtr, hrgn, xoffset, yoffset );
 330         if (!hrgn) return 0;
 331     }
 332
 333       /* Clip siblings of all ancestors that have the WS_CLIPSIBLINGS style */
 334
 335     while (wndPtr->dwStyle & WS_CHILD)
 336     {
 337         wndPtr = wndPtr->parent;
 338         xoffset -= wndPtr->rectClient.left;
 339         yoffset -= wndPtr->rectClient.top;
 340         hrgn = DCE_ClipWindows( wndPtr->parent->child, wndPtr,
 341                                 hrgn, xoffset, yoffset );
 342         if (!hrgn) return 0;
 343     }
 344     return hrgn;
 345 }
 346
 347
 348 /***********************************************************************
 349  *           DCE_SetDrawable
 350  *
 351  * Set the drawable, origin and dimensions for the DC associated to
 352  * a given window.
 353  */
 354 static void DCE_SetDrawable( WND *wndPtr, DC *dc, WORD flags )
 355 {
 356     if (!wndPtr)  /* Get a DC for the whole screen */
 357     {
 358         dc->w.DCOrgX = 0;
 359         dc->w.DCOrgY = 0;
 360         dc->u.x.drawable = rootWindow;
 361         XSetSubwindowMode( display, dc->u.x.gc, IncludeInferiors );
 362     }
 363     else
 364     {
 365         if (flags & DCX_WINDOW)
 366         {
 367             dc->w.DCOrgX  = wndPtr->rectWindow.left;
 368             dc->w.DCOrgY  = wndPtr->rectWindow.top;
 369         }
 370         else
 371         {
 372             dc->w.DCOrgX  = wndPtr->rectClient.left;
 373             dc->w.DCOrgY  = wndPtr->rectClient.top;
 374         }
 375         while (!wndPtr->window)
 376         {
 377             wndPtr = wndPtr->parent;
 378             dc->w.DCOrgX += wndPtr->rectClient.left;
 379             dc->w.DCOrgY += wndPtr->rectClient.top;
 380         }
 381         dc->w.DCOrgX -= wndPtr->rectWindow.left;
 382         dc->w.DCOrgY -= wndPtr->rectWindow.top;
 383         dc->u.x.drawable = wndPtr->window;
 384     }
 385 }
 386
 387 /***********************************************************************
 388  *           GetDCEx    (USER.359)
 389  *
 390  * Unimplemented flags: DCX_LOCKWINDOWUPDATE
 391  */
 392 HDC GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
 393 {
 394     HANDLE      hdce;
 395     HRGN        hrgnVisible;
 396     HDC         hdc = 0;
 397     DCE *       dce;
 398     DC *        dc;
 399     WND *       wndPtr;
 400     DWORD       dcx_flags = 0;
 401     BOOL        need_update = TRUE;
 402
 403     dprintf_dc(stddeb,"GetDCEx: hwnd %04x, hrgnClip %04x, flags %08x\n", hwnd, hrgnClip, (unsigned)flags);
 404
 405     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 406
 407     if (flags & DCX_USESTYLE)
 408     {
 409         flags &= ~( DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
 410
 411         if( wndPtr->dwStyle & WS_CLIPSIBLINGS )
 412             flags |= DCX_CLIPSIBLINGS;
 413
 414         if ( !(flags & DCX_WINDOW) )
 415         {
 416             if (!(wndPtr->class->style & (CS_OWNDC | CS_CLASSDC)))
 417                 flags |= DCX_CACHE;
 418
 419             if (wndPtr->class->style & CS_PARENTDC) flags |= DCX_PARENTCLIP;
 420
 421             if (wndPtr->dwStyle & WS_CLIPCHILDREN &&
 422                      !(wndPtr->dwStyle & WS_MINIMIZE) ) flags |= DCX_CLIPCHILDREN;
 423         }
 424         else flags |= DCX_CACHE;
 425     }
 426
 427     if( flags & DCX_NOCLIPCHILDREN )
 428       {
 429         flags |= DCX_CACHE;
 430         flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN);
 431       }
 432
 433     if (hwnd==GetDesktopWindow() || !(wndPtr->dwStyle & WS_CHILD)) flags &= ~DCX_PARENTCLIP;
 434
 435     if (flags & DCX_WINDOW) flags = (flags & ~DCX_CLIPCHILDREN) | DCX_CACHE;
 436
 437     if( flags & DCX_PARENTCLIP )
 438       {
 439         flags |= DCX_CACHE;
 440         if( !(flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) )
 441           if( (wndPtr->dwStyle & WS_VISIBLE) && (wndPtr->parent->dwStyle & WS_VISIBLE) )
 442             {
 443               flags &= ~DCX_CLIPCHILDREN;
 444               if( wndPtr->parent->dwStyle & WS_CLIPSIBLINGS )
 445                 flags |= DCX_CLIPSIBLINGS;
 446             }
 447       }
 448
 449     if (flags & DCX_CACHE)
 450     {
 451         for (hdce = firstDCE; (hdce); hdce = dce->hNext)
 452         {
 453             if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return 0;
 454             if ((dce->DCXflags & DCX_CACHE) && !(dce->DCXflags & DCX_DCEBUSY)) break;
 455         }
 456     }
 457     else
 458     {
 459         hdce = (wndPtr->class->style & CS_OWNDC)?wndPtr->hdce:wndPtr->class->hdce;
 460         dce = (DCE *) USER_HEAP_LIN_ADDR( hdce );
 461
 462         if( dce->hwndCurrent == hwnd )
 463           {
 464             dprintf_dc(stddeb,"\tskipping hVisRgn update\n");
 465             need_update = FALSE;
 466           }
 467
 468         if( hrgnClip && dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN))
 469           {
 470             fprintf(stdnimp,"GetDCEx: hClipRgn collision!\n");
 471             DeleteObject(dce->hClipRgn);
 472             need_update = TRUE;
 473           }
 474     }
 475
 476     dcx_flags = flags & ( DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_CACHE | DCX_WINDOW | DCX_WINDOWPAINT);
 477
 478     if (!hdce) return 0;
 479     dce = (DCE *) USER_HEAP_LIN_ADDR( hdce );
 480     dce->hwndCurrent = hwnd;
 481     dce->hClipRgn = 0;
 482     dce->DCXflags = dcx_flags | DCX_DCEBUSY;
 483     hdc = dce->hDC;
 484
 485     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 486
 487     DCE_SetDrawable( wndPtr, dc, flags );
 488     if( need_update || dc->w.flags & DC_DIRTY )
 489      {
 490       dprintf_dc(stddeb,"updating hDC anyway\n");
 491
 492       if (flags & DCX_PARENTCLIP)
 493         {
 494             WND *parentPtr = wndPtr->parent;
 495             dcx_flags = flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 496                                        DCX_WINDOW);
 497             if (parentPtr->dwStyle & WS_CLIPSIBLINGS)
 498                 dcx_flags |= DCX_CLIPSIBLINGS;
 499             hrgnVisible = DCE_GetVisRgn( parentPtr->hwndSelf, dcx_flags );
 500             if (flags & DCX_WINDOW)
 501                 OffsetRgn( hrgnVisible, -wndPtr->rectWindow.left,
 502                                         -wndPtr->rectWindow.top );
 503             else OffsetRgn( hrgnVisible, -wndPtr->rectClient.left,
 504                                          -wndPtr->rectClient.top );
 505         }
 506            /* optimize away GetVisRgn for desktop if it isn't there */
 507
 508       else if( hwnd==GetDesktopWindow() && !Options.desktopGeometry )
 509                hrgnVisible = CreateRectRgn( 0, 0, SYSMETRICS_CXSCREEN,
 510                                                   SYSMETRICS_CYSCREEN);
 511       else hrgnVisible = DCE_GetVisRgn( hwnd, flags );
 512
 513       dc->w.flags &= ~DC_DIRTY;
 514
 515       SelectVisRgn( hdc, hrgnVisible );
 516      }
 517     else hrgnVisible = CreateRectRgn(0,0,0,0);
 518
 519     if ((flags & DCX_INTERSECTRGN) || (flags & DCX_EXCLUDERGN))
 520     {
 521         dce->DCXflags |= flags & (DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_EXCLUDERGN);
 522         dce->hClipRgn = hrgnClip;
 523
 524         dprintf_dc(stddeb, "\tsaved VisRgn, clipRgn = %04x\n", hrgnClip);
 525
 526         SaveVisRgn( hdc );
 527         CombineRgn( hrgnVisible, InquireVisRgn( hdc ), hrgnClip,
 528                     (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF );
 529         SelectVisRgn( hdc, hrgnVisible );
 530     }
 531     DeleteObject( hrgnVisible );
 532
 533     dprintf_dc(stddeb, "GetDCEx(%04x,%04x,0x%lx): returning %04x\n",
 534                hwnd, hrgnClip, flags, hdc);
 535     return hdc;
 536 }
 537
 538 /***********************************************************************
 539  *           GetDC    (USER.66)
 540  */
 541 HDC GetDC( HWND hwnd )
 542 {
 543     if( !hwnd ) return GetDCEx( GetDesktopWindow(), 0, DCX_CACHE | DCX_WINDOW );
 544
 545     return GetDCEx( hwnd, 0, DCX_USESTYLE );
 546 }
 547
 548
 549 /***********************************************************************
 550  *           GetWindowDC    (USER.67)
 551  */
 552 HDC GetWindowDC( HWND hwnd )
 553 {
 554     if (hwnd)
 555     {
 556         WND * wndPtr;
 557         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 558     }
 559     else hwnd = GetDesktopWindow();
 560
 561     return GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 562 }
 563
 564
 565 /***********************************************************************
 566  *           ReleaseDC    (USER.68)
 567  */
 568 int ReleaseDC( HWND hwnd, HDC hdc )
 569 {
 570     HANDLE hdce;
 571     DCE * dce = NULL;
 572
 573     dprintf_dc(stddeb, "ReleaseDC: %04x %04x\n", hwnd, hdc );
 574
 575     for (hdce = firstDCE; (hdce); hdce = dce->hNext)
 576     {
 577         if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return 0;
 578         if (dce->hDC == hdc) break;
 579     }
 580     if (!hdce) return 0;
 581     if (!(dce->DCXflags & DCX_DCEBUSY) ) return 0;
 582
 583     /* restore previous visible region */
 584
 585     if ( dce->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN) &&
 586         (dce->DCXflags & DCX_CACHE || dce->DCXflags & DCX_WINDOWPAINT) )
 587     {
 588         dprintf_dc(stddeb,"\tcleaning up visrgn...\n");
 589         dce->DCXflags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN | DCX_WINDOWPAINT);
 590
 591         if( dce->DCXflags & DCX_KEEPCLIPRGN )
 592             dce->DCXflags &= ~DCX_KEEPCLIPRGN;
 593         else
 594             if( dce->hClipRgn > 1 )
 595                 DeleteObject( dce->hClipRgn );
 596
 597         dce->hClipRgn = 0;
 598         RestoreVisRgn(dce->hDC);
 599     }
 600
 601     if (dce->DCXflags & DCX_CACHE)
 602     {
 603         SetDCState( dce->hDC, defaultDCstate );
 604         dce->DCXflags = DCX_CACHE;
 605     }
 606     return 1;
 607 }
 608
 609 /***********************************************************************
 610  *           DCHook    (USER.362)
 611  *
 612  * See "Undoc. Windows" for hints (DC, SetDCHook, SetHookFlags)..
 613  */
 614 BOOL DCHook(HDC hDC, WORD code, DWORD data, DWORD lParam)
 615 {
 616   HANDLE hdce;
 617   HRGN hVisRgn;
 618
 619   dprintf_dc(stddeb,"DCHook: hDC = %04x, %i\n", hDC, code);
 620
 621   if( HIWORD(data) == DC_MAGIC )
 622       hdce = (HANDLE)LOWORD(data);
 623   else
 624       hdce = DCE_FindDCE(hDC);
 625
 626   if( !hdce ) return 0;
 627
 628   switch( code )
 629     {
 630       case DCHC_INVALIDVISRGN:
 631          {
 632            DCE* dce = (DCE*) USER_HEAP_LIN_ADDR(hdce);
 633
 634            if( dce->DCXflags & DCX_DCEBUSY )
 635              {
 636                SetHookFlags(hDC, DCHF_VALIDATEVISRGN);
 637                hVisRgn = DCE_GetVisRgn(dce->hwndCurrent, dce->DCXflags);
 638
 639                dprintf_dc(stddeb,"\tapplying saved clipRgn\n");
 640
 641                /* clip this region with saved clipping region */
 642
 643                if ( (dce->DCXflags & DCX_INTERSECTRGN && dce->hClipRgn != 1) ||
 644                   (  dce->DCXflags & DCX_EXCLUDERGN && dce->hClipRgn) )
 645                   {
 646
 647                     if( (!dce->hClipRgn && dce->DCXflags & DCX_INTERSECTRGN) ||
 648                          (dce->hClipRgn == 1 && dce->DCXflags & DCX_EXCLUDERGN) )
 649                          SetRectRgn(hVisRgn,0,0,0,0);
 650                     else
 651                          CombineRgn(hVisRgn, hVisRgn, dce->hClipRgn,
 652                                       (dce->DCXflags & DCX_EXCLUDERGN)? RGN_DIFF:RGN_AND);
 653                   }
 654                SelectVisRgn(hDC, hVisRgn);
 655                DeleteObject(hVisRgn);
 656              }
 657            else
 658              dprintf_dc(stddeb,"DCHook: DC is not in use!\n");
 659          }
 660          break;
 661
 662       case DCHC_DELETEDC: /* FIXME: ?? */
 663          break;
 664
 665       default:
 666          fprintf(stdnimp,"DCHook: unknown code\n");
 667     }
 668   return 0;
 669 }
 670