objects/clipping.c

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