git.oblomov.eu Git - wine/blob - 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                 if( wndCurrent->parent != wndScope )
 163                     MapWindowPoints16(wndCurrent->parent->hwndSelf, wndScope->hwndSelf,
 164                                                                  (LPPOINT16)&wndRect, 2);
 165                 if( IntersectRect16(&wndRect,&wndRect,pRectUpdate) )
 166                     SetHookFlags(dce->hDC, DCHF_INVALIDATEVISRGN);
 167                 break;
 168               }
 169       }
 170   }
 171  return 1;
 172 }
 173
 174 /***********************************************************************
 175  *           DCE_Init
 176  */
 177 void DCE_Init()
 178 {
 179     int i;
 180     HANDLE handle;
 181     DCE * dce;
 182
 183     for (i = 0; i < NB_DCE; i++)
 184     {
 185         if (!(handle = DCE_AllocDCE( 0, DCE_CACHE_DC ))) return;
 186         dce = (DCE *) USER_HEAP_LIN_ADDR( handle );
 187         if (!defaultDCstate) defaultDCstate = GetDCState( dce->hDC );
 188     }
 189 }
 190
 191
 192 /***********************************************************************
 193  *           DCE_GetVisRect
 194  *
 195  * Calc the visible rectangle of a window, i.e. the client or
 196  * window area clipped by the client area of all ancestors.
 197  * Return FALSE if the visible region is empty.
 198  */
 199 static BOOL DCE_GetVisRect( WND *wndPtr, BOOL clientArea, RECT16 *lprect )
 200 {
 201     int xoffset, yoffset;
 202
 203     *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow;
 204     xoffset = lprect->left;
 205     yoffset = lprect->top;
 206
 207     if (!(wndPtr->dwStyle & WS_VISIBLE) || (wndPtr->flags & WIN_NO_REDRAW))
 208     {
 209         SetRectEmpty16( lprect );  /* Clip everything */
 210         return FALSE;
 211     }
 212
 213     while (wndPtr->parent)
 214     {
 215         wndPtr = wndPtr->parent;
 216         if (!(wndPtr->dwStyle & WS_VISIBLE) ||
 217             (wndPtr->flags & WIN_NO_REDRAW) ||
 218             (wndPtr->dwStyle & WS_ICONIC))
 219         {
 220             SetRectEmpty16( lprect );  /* Clip everything */
 221             return FALSE;
 222         }
 223         xoffset += wndPtr->rectClient.left;
 224         yoffset += wndPtr->rectClient.top;
 225         OffsetRect16( lprect, wndPtr->rectClient.left,
 226                       wndPtr->rectClient.top );
 227
 228           /* Warning!! we assume that IntersectRect() handles the case */
 229           /* where the destination is the same as one of the sources.  */
 230         if (!IntersectRect16( lprect, lprect, &wndPtr->rectClient ))
 231             return FALSE;  /* Visible rectangle is empty */
 232     }
 233     OffsetRect16( lprect, -xoffset, -yoffset );
 234     return TRUE;
 235 }
 236
 237
 238 /***********************************************************************
 239  *           DCE_ClipWindows
 240  *
 241  * Go through the linked list of windows from hwndStart to hwndEnd,
 242  * removing from the given region the rectangle of each window offset
 243  * by a given amount.  The new region is returned, and the original one
 244  * is destroyed.  Used to implement DCX_CLIPSIBLINGS and
 245  * DCX_CLIPCHILDREN styles.
 246  */
 247 static HRGN DCE_ClipWindows( WND *pWndStart, WND *pWndEnd,
 248                              HRGN hrgn, int xoffset, int yoffset )
 249 {
 250     HRGN hrgnNew;
 251
 252     if (!pWndStart) return hrgn;
 253     if (!(hrgnNew = CreateRectRgn( 0, 0, 0, 0 )))
 254     {
 255         DeleteObject( hrgn );
 256         return 0;
 257     }
 258     for (; pWndStart != pWndEnd; pWndStart = pWndStart->next)
 259     {
 260         if (!(pWndStart->dwStyle & WS_VISIBLE)) continue;
 261         SetRectRgn( hrgnNew, pWndStart->rectWindow.left + xoffset,
 262                     pWndStart->rectWindow.top + yoffset,
 263                     pWndStart->rectWindow.right + xoffset,
 264                     pWndStart->rectWindow.bottom + yoffset );
 265         if (!CombineRgn( hrgn, hrgn, hrgnNew, RGN_DIFF )) break;
 266     }
 267     DeleteObject( hrgnNew );
 268     if (pWndStart != pWndEnd)  /* something went wrong */
 269     {
 270         DeleteObject( hrgn );
 271         return 0;
 272     }
 273     return hrgn;
 274 }
 275
 276
 277 /***********************************************************************
 278  *           DCE_GetVisRgn
 279  *
 280  * Return the visible region of a window, i.e. the client or window area
 281  * clipped by the client area of all ancestors, and then optionally
 282  * by siblings and children.
 283  */
 284 HRGN DCE_GetVisRgn( HWND hwnd, WORD flags )
 285 {
 286     RECT16 rect;
 287     HRGN hrgn;
 288     int xoffset, yoffset;
 289     WND *wndPtr = WIN_FindWndPtr( hwnd );
 290
 291       /* Get visible rectangle and create a region with it
 292        * FIXME: do we really need to calculate vis rgns for X windows?
 293        */
 294
 295     if (!wndPtr || !DCE_GetVisRect( wndPtr, !(flags & DCX_WINDOW), &rect ))
 296     {
 297         return CreateRectRgn( 0, 0, 0, 0 );  /* Visible region is empty */
 298     }
 299     if (!(hrgn = CreateRectRgnIndirect16( &rect ))) return 0;
 300
 301       /* Clip all children from the visible region */
 302
 303     if (flags & DCX_CLIPCHILDREN)
 304     {
 305         if (flags & DCX_WINDOW)
 306         {
 307             xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left;
 308             yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top;
 309         }
 310         else xoffset = yoffset = 0;
 311         hrgn = DCE_ClipWindows( wndPtr->child, NULL, hrgn, xoffset, yoffset );
 312         if (!hrgn) return 0;
 313     }
 314
 315       /* Clip siblings placed above this window */
 316
 317     if (flags & DCX_WINDOW)
 318     {
 319         xoffset = -wndPtr->rectWindow.left;
 320         yoffset = -wndPtr->rectWindow.top;
 321     }
 322     else
 323     {
 324         xoffset = -wndPtr->rectClient.left;
 325         yoffset = -wndPtr->rectClient.top;
 326     }
 327     if (flags & DCX_CLIPSIBLINGS)
 328     {
 329         hrgn = DCE_ClipWindows( wndPtr->parent ? wndPtr->parent->child : NULL,
 330                                 wndPtr, hrgn, xoffset, yoffset );
 331         if (!hrgn) return 0;
 332     }
 333
 334       /* Clip siblings of all ancestors that have the WS_CLIPSIBLINGS style */
 335
 336     while (wndPtr->dwStyle & WS_CHILD)
 337     {
 338         wndPtr = wndPtr->parent;
 339         xoffset -= wndPtr->rectClient.left;
 340         yoffset -= wndPtr->rectClient.top;
 341         hrgn = DCE_ClipWindows( wndPtr->parent->child, wndPtr,
 342                                 hrgn, xoffset, yoffset );
 343         if (!hrgn) return 0;
 344     }
 345     return hrgn;
 346 }
 347
 348
 349 /***********************************************************************
 350  *           DCE_SetDrawable
 351  *
 352  * Set the drawable, origin and dimensions for the DC associated to
 353  * a given window.
 354  */
 355 static void DCE_SetDrawable( WND *wndPtr, DC *dc, WORD flags )
 356 {
 357     if (!wndPtr)  /* Get a DC for the whole screen */
 358     {
 359         dc->w.DCOrgX = 0;
 360         dc->w.DCOrgY = 0;
 361         dc->u.x.drawable = rootWindow;
 362         XSetSubwindowMode( display, dc->u.x.gc, IncludeInferiors );
 363     }
 364     else
 365     {
 366         if (flags & DCX_WINDOW)
 367         {
 368             dc->w.DCOrgX  = wndPtr->rectWindow.left;
 369             dc->w.DCOrgY  = wndPtr->rectWindow.top;
 370         }
 371         else
 372         {
 373             dc->w.DCOrgX  = wndPtr->rectClient.left;
 374             dc->w.DCOrgY  = wndPtr->rectClient.top;
 375         }
 376         while (!wndPtr->window)
 377         {
 378             wndPtr = wndPtr->parent;
 379             dc->w.DCOrgX += wndPtr->rectClient.left;
 380             dc->w.DCOrgY += wndPtr->rectClient.top;
 381         }
 382         dc->w.DCOrgX -= wndPtr->rectWindow.left;
 383         dc->w.DCOrgY -= wndPtr->rectWindow.top;
 384         dc->u.x.drawable = wndPtr->window;
 385     }
 386 }
 387
 388 /***********************************************************************
 389  *           GetDCEx    (USER.359)
 390  *
 391  * Unimplemented flags: DCX_LOCKWINDOWUPDATE
 392  */
 393 HDC GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags )
 394 {
 395     HANDLE      hdce;
 396     HRGN        hrgnVisible;
 397     HDC         hdc = 0;
 398     DCE *       dce;
 399     DC *        dc;
 400     WND *       wndPtr;
 401     DWORD       dcx_flags = 0;
 402     BOOL        need_update = TRUE;
 403
 404     dprintf_dc(stddeb,"GetDCEx: hwnd %04x, hrgnClip %04x, flags %08x\n", hwnd, hrgnClip, (unsigned)flags);
 405
 406     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 407
 408     if (flags & DCX_USESTYLE)
 409     {
 410         flags &= ~( DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
 411
 412         if( wndPtr->dwStyle & WS_CLIPSIBLINGS )
 413             flags |= DCX_CLIPSIBLINGS;
 414
 415         if ( !(flags & DCX_WINDOW) )
 416         {
 417             if (!(wndPtr->class->style & (CS_OWNDC | CS_CLASSDC)))
 418                 flags |= DCX_CACHE;
 419
 420             if (wndPtr->class->style & CS_PARENTDC) flags |= DCX_PARENTCLIP;
 421
 422             if (wndPtr->dwStyle & WS_CLIPCHILDREN &&
 423                      !(wndPtr->dwStyle & WS_MINIMIZE) ) flags |= DCX_CLIPCHILDREN;
 424         }
 425         else flags |= DCX_CACHE;
 426     }
 427
 428     if( flags & DCX_NOCLIPCHILDREN )
 429       {
 430         flags |= DCX_CACHE;
 431         flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN);
 432       }
 433
 434     if (hwnd==GetDesktopWindow() || !(wndPtr->dwStyle & WS_CHILD)) flags &= ~DCX_PARENTCLIP;
 435
 436     if (flags & DCX_WINDOW) flags = (flags & ~DCX_CLIPCHILDREN) | DCX_CACHE;
 437
 438     if( flags & DCX_PARENTCLIP )
 439       {
 440         flags |= DCX_CACHE;
 441         if( !(flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) )
 442           if( (wndPtr->dwStyle & WS_VISIBLE) && (wndPtr->parent->dwStyle & WS_VISIBLE) )
 443             {
 444               flags &= ~DCX_CLIPCHILDREN;
 445               if( wndPtr->parent->dwStyle & WS_CLIPSIBLINGS )
 446                 flags |= DCX_CLIPSIBLINGS;
 447             }
 448       }
 449
 450     if (flags & DCX_CACHE)
 451     {
 452         for (hdce = firstDCE; (hdce); hdce = dce->hNext)
 453         {
 454             if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return 0;
 455             if ((dce->DCXflags & DCX_CACHE) && !(dce->DCXflags & DCX_DCEBUSY)) break;
 456         }
 457     }
 458     else
 459     {
 460         hdce = (wndPtr->class->style & CS_OWNDC)?wndPtr->hdce:wndPtr->class->hdce;
 461         dce = (DCE *) USER_HEAP_LIN_ADDR( hdce );
 462
 463         if( dce->hwndCurrent == hwnd )
 464           {
 465             dprintf_dc(stddeb,"\tskipping hVisRgn update\n");
 466             need_update = FALSE;
 467           }
 468
 469         if( hrgnClip && dce->hClipRgn && !(dce->DCXflags & DCX_KEEPCLIPRGN))
 470           {
 471             fprintf(stdnimp,"GetDCEx: hClipRgn collision!\n");
 472             DeleteObject(dce->hClipRgn);
 473             need_update = TRUE;
 474           }
 475     }
 476
 477     dcx_flags = flags & ( DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_CACHE | DCX_WINDOW | DCX_WINDOWPAINT);
 478
 479     if (!hdce) return 0;
 480     dce = (DCE *) USER_HEAP_LIN_ADDR( hdce );
 481     dce->hwndCurrent = hwnd;
 482     dce->hClipRgn = 0;
 483     dce->DCXflags = dcx_flags | DCX_DCEBUSY;
 484     hdc = dce->hDC;
 485
 486     if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0;
 487
 488     DCE_SetDrawable( wndPtr, dc, flags );
 489     if( need_update || dc->w.flags & DC_DIRTY )
 490      {
 491       dprintf_dc(stddeb,"updating hDC anyway\n");
 492
 493       if (flags & DCX_PARENTCLIP)
 494         {
 495             WND *parentPtr = wndPtr->parent;
 496             dcx_flags = flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN |
 497                                        DCX_WINDOW);
 498             if (parentPtr->dwStyle & WS_CLIPSIBLINGS)
 499                 dcx_flags |= DCX_CLIPSIBLINGS;
 500             hrgnVisible = DCE_GetVisRgn( parentPtr->hwndSelf, dcx_flags );
 501             if (flags & DCX_WINDOW)
 502                 OffsetRgn( hrgnVisible, -wndPtr->rectWindow.left,
 503                                         -wndPtr->rectWindow.top );
 504             else OffsetRgn( hrgnVisible, -wndPtr->rectClient.left,
 505                                          -wndPtr->rectClient.top );
 506         }
 507            /* optimize away GetVisRgn for desktop if it isn't there */
 508
 509       else if( hwnd==GetDesktopWindow() && !Options.desktopGeometry )
 510                hrgnVisible = CreateRectRgn( 0, 0, SYSMETRICS_CXSCREEN,
 511                                                   SYSMETRICS_CYSCREEN);
 512       else hrgnVisible = DCE_GetVisRgn( hwnd, flags );
 513
 514       dc->w.flags &= ~DC_DIRTY;
 515
 516       SelectVisRgn( hdc, hrgnVisible );
 517      }
 518     else hrgnVisible = CreateRectRgn(0,0,0,0);
 519
 520     if ((flags & DCX_INTERSECTRGN) || (flags & DCX_EXCLUDERGN))
 521     {
 522         dce->DCXflags |= flags & (DCX_KEEPCLIPRGN | DCX_INTERSECTRGN | DCX_EXCLUDERGN);
 523         dce->hClipRgn = hrgnClip;
 524
 525         dprintf_dc(stddeb, "\tsaved VisRgn, clipRgn = %04x\n", hrgnClip);
 526
 527         SaveVisRgn( hdc );
 528         CombineRgn( hrgnVisible, InquireVisRgn( hdc ), hrgnClip,
 529                     (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF );
 530         SelectVisRgn( hdc, hrgnVisible );
 531     }
 532     DeleteObject( hrgnVisible );
 533
 534     dprintf_dc(stddeb, "GetDCEx(%04x,%04x,0x%lx): returning %04x\n",
 535                hwnd, hrgnClip, flags, hdc);
 536     return hdc;
 537 }
 538
 539 /***********************************************************************
 540  *           GetDC    (USER.66)
 541  */
 542 HDC GetDC( HWND hwnd )
 543 {
 544     if( !hwnd ) return GetDCEx( GetDesktopWindow(), 0, DCX_CACHE | DCX_WINDOW );
 545
 546     return GetDCEx( hwnd, 0, DCX_USESTYLE );
 547 }
 548
 549
 550 /***********************************************************************
 551  *           GetWindowDC    (USER.67)
 552  */
 553 HDC GetWindowDC( HWND hwnd )
 554 {
 555     if (hwnd)
 556     {
 557         WND * wndPtr;
 558         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 559     }
 560     else hwnd = GetDesktopWindow();
 561
 562     return GetDCEx( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 563 }
 564
 565
 566 /***********************************************************************
 567  *           ReleaseDC    (USER.68)
 568  */
 569 int ReleaseDC( HWND hwnd, HDC hdc )
 570 {
 571     HANDLE hdce;
 572     DCE * dce = NULL;
 573
 574     dprintf_dc(stddeb, "ReleaseDC: %04x %04x\n", hwnd, hdc );
 575
 576     for (hdce = firstDCE; (hdce); hdce = dce->hNext)
 577     {
 578         if (!(dce = (DCE *) USER_HEAP_LIN_ADDR( hdce ))) return 0;
 579         if (dce->hDC == hdc) break;
 580     }
 581     if (!hdce) return 0;
 582     if (!(dce->DCXflags & DCX_DCEBUSY) ) return 0;
 583
 584     /* restore previous visible region */
 585
 586     if ( dce->DCXflags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN) &&
 587         (dce->DCXflags & DCX_CACHE || dce->DCXflags & DCX_WINDOWPAINT) )
 588     {
 589         dprintf_dc(stddeb,"\tcleaning up visrgn...\n");
 590         dce->DCXflags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN | DCX_WINDOWPAINT);
 591
 592         if( dce->DCXflags & DCX_KEEPCLIPRGN )
 593             dce->DCXflags &= ~DCX_KEEPCLIPRGN;
 594         else
 595             if( dce->hClipRgn > 1 )
 596                 DeleteObject( dce->hClipRgn );
 597
 598         dce->hClipRgn = 0;
 599         RestoreVisRgn(dce->hDC);
 600     }
 601
 602     if (dce->DCXflags & DCX_CACHE)
 603     {
 604         SetDCState( dce->hDC, defaultDCstate );
 605         dce->DCXflags = DCX_CACHE;
 606     }
 607     return 1;
 608 }
 609
 610 /***********************************************************************
 611  *           DCHook    (USER.362)
 612  *
 613  * See "Undoc. Windows" for hints (DC, SetDCHook, SetHookFlags)..
 614  */
 615 BOOL DCHook(HDC hDC, WORD code, DWORD data, DWORD lParam)
 616 {
 617   HANDLE hdce;
 618   HRGN hVisRgn;
 619
 620   dprintf_dc(stddeb,"DCHook: hDC = %04x, %i\n", hDC, code);
 621
 622   if( HIWORD(data) == DC_MAGIC )
 623       hdce = (HANDLE)LOWORD(data);
 624   else
 625       hdce = DCE_FindDCE(hDC);
 626
 627   if( !hdce ) return 0;
 628
 629   switch( code )
 630     {
 631       case DCHC_INVALIDVISRGN:
 632          {
 633            DCE* dce = (DCE*) USER_HEAP_LIN_ADDR(hdce);
 634
 635            if( dce->DCXflags & DCX_DCEBUSY )
 636              {
 637                SetHookFlags(hDC, DCHF_VALIDATEVISRGN);
 638                hVisRgn = DCE_GetVisRgn(dce->hwndCurrent, dce->DCXflags);
 639
 640                dprintf_dc(stddeb,"\tapplying saved clipRgn\n");
 641
 642                /* clip this region with saved clipping region */
 643
 644                if ( (dce->DCXflags & DCX_INTERSECTRGN && dce->hClipRgn != 1) ||
 645                   (  dce->DCXflags & DCX_EXCLUDERGN && dce->hClipRgn) )
 646                   {
 647
 648                     if( (!dce->hClipRgn && dce->DCXflags & DCX_INTERSECTRGN) ||
 649                          (dce->hClipRgn == 1 && dce->DCXflags & DCX_EXCLUDERGN) )
 650                          SetRectRgn(hVisRgn,0,0,0,0);
 651                     else
 652                          CombineRgn(hVisRgn, hVisRgn, dce->hClipRgn,
 653                                       (dce->DCXflags & DCX_EXCLUDERGN)? RGN_DIFF:RGN_AND);
 654                   }
 655                SelectVisRgn(hDC, hVisRgn);
 656                DeleteObject(hVisRgn);
 657              }
 658            else
 659              dprintf_dc(stddeb,"DCHook: DC is not in use!\n");
 660          }
 661          break;
 662
 663       case DCHC_DELETEDC: /* FIXME: ?? */
 664          break;
 665
 666       default:
 667          fprintf(stdnimp,"DCHook: unknown code\n");
 668     }
 669   return 0;
 670 }
 671