objects/clipping.c

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