objects/clipping.c

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