objects/clipping.c

   1 /*
   2  * DC clipping functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include "dc.h"
   9 #include "region.h"
  10 #include "debugtools.h"
  11 #include "windef.h"
  12 #include "wingdi.h"
  13 #include "wine/winuser16.h"
  14
  15 DEFAULT_DEBUG_CHANNEL(clipping)
  16 DECLARE_DEBUG_CHANNEL(region)
  17
  18 #define UPDATE_DIRTY_DC(dc) \
  19  do { \
  20    if ((dc)->hookThunk && !((dc)->w.flags & (DC_SAVED | DC_MEMORY))) \
  21      (dc)->hookThunk( (dc)->hSelf, DCHC_INVALIDVISRGN, (dc)->dwHookData, 0 ); \
  22  } while(0)
  23
  24
  25
  26 /***********************************************************************
  27  *           CLIPPING_UpdateGCRegion
  28  *
  29  * Update the GC clip region when the ClipRgn or VisRgn have changed.
  30  */
  31 void CLIPPING_UpdateGCRegion( DC * dc )
  32 {
  33     if (!dc->w.hGCClipRgn) dc->w.hGCClipRgn = CreateRectRgn( 0, 0, 0, 0 );
  34
  35     if (!dc->w.hVisRgn)
  36     {
  37         ERR_(region)("hVisRgn is zero. Please report this.\n" );
  38         exit(1);
  39     }
  40
  41     if (dc->w.flags & DC_DIRTY)
  42     {
  43         UPDATE_DIRTY_DC(dc);
  44         dc->w.flags &= ~DC_DIRTY;
  45     }
  46
  47     if (!dc->w.hClipRgn)
  48         CombineRgn( dc->w.hGCClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
  49     else
  50         CombineRgn(dc->w.hGCClipRgn, dc->w.hClipRgn, dc->w.hVisRgn, RGN_AND);
  51     if (dc->funcs->pSetDeviceClipping) dc->funcs->pSetDeviceClipping( dc );
  52 }
  53
  54
  55 /***********************************************************************
  56  *           SelectClipRgn16    (GDI.44)
  57  */
  58 INT16 WINAPI SelectClipRgn16( HDC16 hdc, HRGN16 hrgn )
  59 {
  60     return (INT16)SelectClipRgn( hdc, hrgn );
  61 }
  62
  63
  64 /***********************************************************************
  65  *           SelectClipRgn32    (GDI32.297)
  66  */
  67 INT WINAPI SelectClipRgn( HDC hdc, HRGN hrgn )
  68 {
  69     return ExtSelectClipRgn( hdc, hrgn, RGN_COPY );
  70 }
  71
  72 /******************************************************************************
  73  *              ExtSelectClipRgn16      [GDI.508]
  74  */
  75 INT16 WINAPI ExtSelectClipRgn16( HDC16 hdc, HRGN16 hrgn, INT16 fnMode )
  76 {
  77   return (INT16) ExtSelectClipRgn((HDC) hdc, (HRGN) hrgn, fnMode);
  78 }
  79
  80 /******************************************************************************
  81  *              ExtSelectClipRgn        [GDI32.97]
  82  */
  83 INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
  84 {
  85     INT retval;
  86     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
  87     if (!dc) return ERROR;
  88
  89     TRACE("%04x %04x %d\n", hdc, hrgn, fnMode );
  90
  91     if (!hrgn)
  92     {
  93         if (fnMode == RGN_COPY)
  94         {
  95             if (dc->w.hClipRgn) DeleteObject16( dc->w.hClipRgn );
  96             dc->w.hClipRgn = 0;
  97             retval = SIMPLEREGION; /* Clip region == whole DC */
  98         }
  99         else
 100         {
 101             FIXME("Unimplemented: hrgn NULL in mode: %d\n", fnMode);
 102             return ERROR;
 103         }
 104     }
 105     else
 106     {
 107         if (!dc->w.hClipRgn)
 108         {
 109             RECT rect;
 110             GetRgnBox( dc->w.hVisRgn, &rect );
 111             dc->w.hClipRgn = CreateRectRgnIndirect( &rect );
 112         }
 113
 114         OffsetRgn( dc->w.hClipRgn, -dc->w.DCOrgX, -dc->w.DCOrgY );
 115         if(fnMode == RGN_COPY)
 116             retval = CombineRgn( dc->w.hClipRgn, hrgn, 0, fnMode );
 117         else
 118             retval = CombineRgn( dc->w.hClipRgn, dc->w.hClipRgn, hrgn, fnMode);
 119         OffsetRgn( dc->w.hClipRgn, dc->w.DCOrgX, dc->w.DCOrgY );
 120     }
 121
 122
 123     CLIPPING_UpdateGCRegion( dc );
 124     GDI_HEAP_UNLOCK( hdc );
 125     return retval;
 126 }
 127
 128 /***********************************************************************
 129  *           SelectVisRgn    (GDI.105)
 130  */
 131 INT16 WINAPI SelectVisRgn16( HDC16 hdc, HRGN16 hrgn )
 132 {
 133     int retval;
 134     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 135     if (!dc || !hrgn) return ERROR;
 136
 137     TRACE("%04x %04x\n", hdc, hrgn );
 138
 139     dc->w.flags &= ~DC_DIRTY;
 140
 141     retval = CombineRgn16( dc->w.hVisRgn, hrgn, 0, RGN_COPY );
 142     CLIPPING_UpdateGCRegion( dc );
 143     GDI_HEAP_UNLOCK( hdc );
 144     return retval;
 145 }
 146
 147
 148 /***********************************************************************
 149  *           OffsetClipRgn16    (GDI.32)
 150  */
 151 INT16 WINAPI OffsetClipRgn16( HDC16 hdc, INT16 x, INT16 y )
 152 {
 153     return (INT16)OffsetClipRgn( hdc, x, y );
 154 }
 155
 156
 157 /***********************************************************************
 158  *           OffsetClipRgn32    (GDI32.255)
 159  */
 160 INT WINAPI OffsetClipRgn( HDC hdc, INT x, INT y )
 161 {
 162     INT ret = SIMPLEREGION;
 163     DC *dc = DC_GetDCPtr( hdc );
 164     if (!dc) return ERROR;
 165
 166     TRACE("%04x %d,%d\n", hdc, x, y );
 167
 168     if(dc->funcs->pOffsetClipRgn)
 169         ret = dc->funcs->pOffsetClipRgn( dc, x, y );
 170     else if (dc->w.hClipRgn) {
 171         ret = OffsetRgn( dc->w.hClipRgn, XLSTODS(dc,x), YLSTODS(dc,y));
 172         CLIPPING_UpdateGCRegion( dc );
 173     }
 174     GDI_HEAP_UNLOCK( hdc );
 175     return ret;
 176 }
 177
 178
 179 /***********************************************************************
 180  *           OffsetVisRgn    (GDI.102)
 181  */
 182 INT16 WINAPI OffsetVisRgn16( HDC16 hdc, INT16 x, INT16 y )
 183 {
 184     INT16 retval;
 185     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 186     if (!dc) return ERROR;
 187     TRACE("%04x %d,%d\n", hdc, x, y );
 188     retval = OffsetRgn( dc->w.hVisRgn, x, y );
 189     CLIPPING_UpdateGCRegion( dc );
 190     GDI_HEAP_UNLOCK( hdc );
 191     return retval;
 192 }
 193
 194
 195 /***********************************************************************
 196  *           CLIPPING_IntersectClipRect
 197  *
 198  * Helper function for {Intersect,Exclude}ClipRect, can be called from
 199  * elsewhere (like ExtTextOut()) to skip redundant metafile update and
 200  * coordinate conversion.
 201  */
 202 INT CLIPPING_IntersectClipRect( DC * dc, INT left, INT top,
 203                                   INT right, INT bottom, UINT flags )
 204 {
 205     HRGN newRgn;
 206     INT ret;
 207
 208     left   += dc->w.DCOrgX;
 209     right  += dc->w.DCOrgX;
 210     top    += dc->w.DCOrgY;
 211     bottom += dc->w.DCOrgY;
 212
 213     if (!(newRgn = CreateRectRgn( left, top, right, bottom ))) return ERROR;
 214     if (!dc->w.hClipRgn)
 215     {
 216        if( flags & CLIP_INTERSECT )
 217        {
 218            dc->w.hClipRgn = newRgn;
 219            CLIPPING_UpdateGCRegion( dc );
 220            return SIMPLEREGION;
 221        }
 222        else if( flags & CLIP_EXCLUDE )
 223        {
 224            dc->w.hClipRgn = CreateRectRgn( 0, 0, 0, 0 );
 225            CombineRgn( dc->w.hClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
 226        }
 227        else WARN("No hClipRgn and flags are %x\n",flags);
 228     }
 229
 230     ret = CombineRgn( newRgn, dc->w.hClipRgn, newRgn,
 231                         (flags & CLIP_EXCLUDE) ? RGN_DIFF : RGN_AND );
 232     if (ret != ERROR)
 233     {
 234         if (!(flags & CLIP_KEEPRGN)) DeleteObject( dc->w.hClipRgn );
 235         dc->w.hClipRgn = newRgn;
 236         CLIPPING_UpdateGCRegion( dc );
 237     }
 238     else DeleteObject( newRgn );
 239     return ret;
 240 }
 241
 242
 243 /***********************************************************************
 244  *           ExcludeClipRect16    (GDI.21)
 245  */
 246 INT16 WINAPI ExcludeClipRect16( HDC16 hdc, INT16 left, INT16 top,
 247                                 INT16 right, INT16 bottom )
 248 {
 249     return (INT16)ExcludeClipRect( hdc, left, top, right, bottom );
 250 }
 251
 252
 253 /***********************************************************************
 254  *           ExcludeClipRect32    (GDI32.92)
 255  */
 256 INT WINAPI ExcludeClipRect( HDC hdc, INT left, INT top,
 257                                 INT right, INT bottom )
 258 {
 259     INT ret;
 260     DC *dc = DC_GetDCPtr( hdc );
 261     if (!dc) return ERROR;
 262
 263     TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
 264
 265     if(dc->funcs->pExcludeClipRect)
 266         ret = dc->funcs->pExcludeClipRect( dc, left, top, right, bottom );
 267     else {
 268         left   = XLPTODP( dc, left );
 269         right  = XLPTODP( dc, right );
 270         top    = YLPTODP( dc, top );
 271         bottom = YLPTODP( dc, bottom );
 272
 273         ret = CLIPPING_IntersectClipRect( dc, left, top, right, bottom, CLIP_EXCLUDE );
 274     }
 275     GDI_HEAP_UNLOCK( hdc );
 276     return ret;
 277 }
 278
 279
 280 /***********************************************************************
 281  *           IntersectClipRect16    (GDI.22)
 282  */
 283 INT16 WINAPI IntersectClipRect16( HDC16 hdc, INT16 left, INT16 top,
 284                                   INT16 right, INT16 bottom )
 285 {
 286     return (INT16)IntersectClipRect( hdc, left, top, right, bottom );
 287 }
 288
 289
 290 /***********************************************************************
 291  *           IntersectClipRect32    (GDI32.245)
 292  */
 293 INT WINAPI IntersectClipRect( HDC hdc, INT left, INT top,
 294                                   INT right, INT bottom )
 295 {
 296     INT ret;
 297     DC *dc = DC_GetDCPtr( hdc );
 298     if (!dc) return ERROR;
 299
 300     TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
 301
 302     if(dc->funcs->pIntersectClipRect)
 303         ret = dc->funcs->pIntersectClipRect( dc, left, top, right, bottom );
 304     else {
 305         left   = XLPTODP( dc, left );
 306         right  = XLPTODP( dc, right );
 307         top    = YLPTODP( dc, top );
 308         bottom = YLPTODP( dc, bottom );
 309
 310         ret = CLIPPING_IntersectClipRect( dc, left, top, right, bottom, CLIP_INTERSECT );
 311     }
 312     GDI_HEAP_UNLOCK( hdc );
 313     return ret;
 314 }
 315
 316
 317 /***********************************************************************
 318  *           CLIPPING_IntersectVisRect
 319  *
 320  * Helper function for {Intersect,Exclude}VisRect, can be called from
 321  * elsewhere (like ExtTextOut()) to skip redundant metafile update and
 322  * coordinate conversion.
 323  */
 324 INT CLIPPING_IntersectVisRect( DC * dc, INT left, INT top,
 325                                  INT right, INT bottom,
 326                                  BOOL exclude )
 327 {
 328     HRGN tempRgn, newRgn;
 329     INT ret;
 330
 331     left   += dc->w.DCOrgX;
 332     right  += dc->w.DCOrgX;
 333     top    += dc->w.DCOrgY;
 334     bottom += dc->w.DCOrgY;
 335
 336     if (!(newRgn = CreateRectRgn( 0, 0, 0, 0 ))) return ERROR;
 337     if (!(tempRgn = CreateRectRgn( left, top, right, bottom )))
 338     {
 339         DeleteObject( newRgn );
 340         return ERROR;
 341     }
 342     ret = CombineRgn( newRgn, dc->w.hVisRgn, tempRgn,
 343                         exclude ? RGN_DIFF : RGN_AND );
 344     DeleteObject( tempRgn );
 345
 346     if (ret != ERROR)
 347     {
 348         RGNOBJ *newObj  = (RGNOBJ*)GDI_GetObjPtr( newRgn, REGION_MAGIC);
 349         RGNOBJ *prevObj = (RGNOBJ*)GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC);
 350         if (newObj && prevObj) newObj->header.hNext = prevObj->header.hNext;
 351         DeleteObject( dc->w.hVisRgn );
 352         dc->w.hVisRgn = newRgn;
 353         CLIPPING_UpdateGCRegion( dc );
 354         GDI_HEAP_UNLOCK( newRgn );
 355     }
 356     else DeleteObject( newRgn );
 357     return ret;
 358 }
 359
 360
 361 /***********************************************************************
 362  *           ExcludeVisRect    (GDI.73)
 363  */
 364 INT16 WINAPI ExcludeVisRect16( HDC16 hdc, INT16 left, INT16 top,
 365                              INT16 right, INT16 bottom )
 366 {
 367     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 368     if (!dc) return ERROR;
 369
 370     left   = XLPTODP( dc, left );
 371     right  = XLPTODP( dc, right );
 372     top    = YLPTODP( dc, top );
 373     bottom = YLPTODP( dc, bottom );
 374
 375     TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
 376
 377     return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, TRUE );
 378 }
 379
 380
 381 /***********************************************************************
 382  *           IntersectVisRect    (GDI.98)
 383  */
 384 INT16 WINAPI IntersectVisRect16( HDC16 hdc, INT16 left, INT16 top,
 385                                INT16 right, INT16 bottom )
 386 {
 387     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 388     if (!dc) return ERROR;
 389
 390     left   = XLPTODP( dc, left );
 391     right  = XLPTODP( dc, right );
 392     top    = YLPTODP( dc, top );
 393     bottom = YLPTODP( dc, bottom );
 394
 395     TRACE("%04x %dx%d,%dx%d\n", hdc, left, top, right, bottom );
 396
 397     return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, FALSE );
 398 }
 399
 400
 401 /***********************************************************************
 402  *           PtVisible16    (GDI.103)
 403  */
 404 BOOL16 WINAPI PtVisible16( HDC16 hdc, INT16 x, INT16 y )
 405 {
 406     return PtVisible( hdc, x, y );
 407 }
 408
 409
 410 /***********************************************************************
 411  *           PtVisible32    (GDI32.279)
 412  */
 413 BOOL WINAPI PtVisible( HDC hdc, INT x, INT y )
 414 {
 415     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 416     if (!dc) return ERROR;
 417
 418     TRACE("%04x %d,%d\n", hdc, x, y );
 419     if (!dc->w.hGCClipRgn) return FALSE;
 420
 421     if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
 422     dc->w.flags &= ~DC_DIRTY;
 423
 424     return PtInRegion( dc->w.hGCClipRgn, XLPTODP(dc,x) + dc->w.DCOrgX,
 425                                            YLPTODP(dc,y) + dc->w.DCOrgY );
 426 }
 427
 428
 429 /***********************************************************************
 430  *           RectVisible16    (GDI.104)
 431  */
 432 BOOL16 WINAPI RectVisible16( HDC16 hdc, const RECT16* rect )
 433 {
 434     RECT16 tmpRect;
 435     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 436     if (!dc) return FALSE;
 437     TRACE("%04x %d,%dx%d,%d\n",
 438           hdc, rect->left, rect->top, rect->right, rect->bottom );
 439     if (!dc->w.hGCClipRgn) return FALSE;
 440     /* copy rectangle to avoid overwriting by LPtoDP */
 441     tmpRect = *rect;
 442     LPtoDP16( hdc, (LPPOINT16)&tmpRect, 2 );
 443     OffsetRect16( &tmpRect, dc->w.DCOrgX, dc->w.DCOrgY );
 444     return RectInRegion16( dc->w.hGCClipRgn, &tmpRect );
 445 }
 446
 447
 448 /***********************************************************************
 449  *           RectVisible32    (GDI32.282)
 450  */
 451 BOOL WINAPI RectVisible( HDC hdc, const RECT* rect )
 452 {
 453     RECT16 rect16;
 454     CONV_RECT32TO16( rect, &rect16 );
 455     return RectVisible16( (HDC16)hdc, &rect16 );
 456 }
 457
 458
 459 /***********************************************************************
 460  *           GetClipBox16    (GDI.77)
 461  */
 462 INT16 WINAPI GetClipBox16( HDC16 hdc, LPRECT16 rect )
 463 {
 464     int ret;
 465     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 466     if (!dc) return ERROR;
 467     ret = GetRgnBox16( dc->w.hGCClipRgn, rect );
 468     OffsetRect16( rect, -dc->w.DCOrgX, -dc->w.DCOrgY );
 469     DPtoLP16( hdc, (LPPOINT16)rect, 2 );
 470     TRACE("%d,%d-%d,%d\n", rect->left,rect->top,rect->right,rect->bottom );
 471     return ret;
 472 }
 473
 474
 475 /***********************************************************************
 476  *           GetClipBox32    (GDI32.162)
 477  */
 478 INT WINAPI GetClipBox( HDC hdc, LPRECT rect )
 479 {
 480     INT ret;
 481     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 482     if (!dc) return ERROR;
 483     ret = GetRgnBox( dc->w.hGCClipRgn, rect );
 484     OffsetRect( rect, -dc->w.DCOrgX, -dc->w.DCOrgY );
 485     DPtoLP( hdc, (LPPOINT)rect, 2 );
 486     return ret;
 487 }
 488
 489
 490 /***********************************************************************
 491  *           GetClipRgn32  (GDI32.163)
 492  */
 493 INT WINAPI GetClipRgn( HDC hdc, HRGN hRgn )
 494 {
 495     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 496     if( dc && hRgn )
 497     {
 498       if( dc->w.hClipRgn )
 499       {
 500         /* this assumes that dc->w.hClipRgn is in coordinates
 501            relative to the device (not DC origin) */
 502
 503         if( CombineRgn(hRgn, dc->w.hClipRgn, 0, RGN_COPY) != ERROR )
 504         {
 505             OffsetRgn( hRgn, -dc->w.DCOrgX, -dc->w.DCOrgY );
 506             return 1;
 507         }
 508       }
 509       else return 0;
 510     }
 511     return -1;
 512 }
 513
 514 /***********************************************************************
 515  *           SaveVisRgn    (GDI.129)
 516  */
 517 HRGN16 WINAPI SaveVisRgn16( HDC16 hdc )
 518 {
 519     HRGN copy;
 520     RGNOBJ *obj, *copyObj;
 521     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 522     if (!dc) return 0;
 523     TRACE("%04x\n", hdc );
 524     if (!dc->w.hVisRgn)
 525     {
 526         ERR_(region)("hVisRgn is zero. Please report this.\n" );
 527         exit(1);
 528     }
 529     if( dc->w.flags & DC_DIRTY ) UPDATE_DIRTY_DC(dc);
 530     dc->w.flags &= ~DC_DIRTY;
 531
 532     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
 533     {
 534         GDI_HEAP_UNLOCK( hdc );
 535         return 0;
 536     }
 537     if (!(copy = CreateRectRgn( 0, 0, 0, 0 )))
 538     {
 539         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 540         GDI_HEAP_UNLOCK( hdc );
 541         return 0;
 542     }
 543     CombineRgn( copy, dc->w.hVisRgn, 0, RGN_COPY );
 544     if (!(copyObj = (RGNOBJ *) GDI_GetObjPtr( copy, REGION_MAGIC )))
 545     {
 546         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 547         GDI_HEAP_UNLOCK( hdc );
 548         return 0;
 549     }
 550     copyObj->header.hNext = obj->header.hNext;
 551     obj->header.hNext = copy;
 552     GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 553     GDI_HEAP_UNLOCK( hdc );
 554     GDI_HEAP_UNLOCK( copy );
 555     return copy;
 556 }
 557
 558
 559 /***********************************************************************
 560  *           RestoreVisRgn    (GDI.130)
 561  */
 562 INT16 WINAPI RestoreVisRgn16( HDC16 hdc )
 563 {
 564     HRGN saved;
 565     RGNOBJ *obj, *savedObj;
 566     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 567     INT16 ret;
 568
 569     if (!dc) return ERROR;
 570     if (!dc->w.hVisRgn)
 571     {
 572         GDI_HEAP_UNLOCK( hdc );
 573         return ERROR;
 574     }
 575     TRACE("%04x\n", hdc );
 576     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
 577     {
 578         GDI_HEAP_UNLOCK( hdc );
 579         return ERROR;
 580     }
 581     if (!(saved = obj->header.hNext))
 582     {
 583         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 584         GDI_HEAP_UNLOCK( hdc );
 585         return ERROR;
 586     }
 587     if (!(savedObj = (RGNOBJ *) GDI_GetObjPtr( saved, REGION_MAGIC )))
 588     {
 589         GDI_HEAP_UNLOCK( dc->w.hVisRgn );
 590         GDI_HEAP_UNLOCK( hdc );
 591         return ERROR;
 592     }
 593     DeleteObject( dc->w.hVisRgn );
 594     dc->w.hVisRgn = saved;
 595     CLIPPING_UpdateGCRegion( dc );
 596     GDI_HEAP_UNLOCK( hdc );
 597     ret = savedObj->rgn->type; /* FIXME */
 598     GDI_HEAP_UNLOCK( saved );
 599     return ret;
 600 }