objects/clipping.c

   1 /*
   2  * DC clipping functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include "gdi.h"
   9 #include "metafile.h"
  10 #include "stddebug.h"
  11 /* #define DEBUG_CLIPPING */
  12 #include "debug.h"
  13
  14 /***********************************************************************
  15  *           CLIPPING_SetDeviceClipping
  16  *
  17  * Set the clip region of the physical device.
  18  */
  19 static void CLIPPING_SetDeviceClipping( DC * dc )
  20 {
  21     RGNOBJ *obj = (RGNOBJ *) GDI_GetObjPtr(dc->w.hGCClipRgn, REGION_MAGIC);
  22     if (!obj)
  23     {
  24         fprintf( stderr, "SetDeviceClipping: Rgn is 0. Please report this.\n");
  25         exit(1);
  26     }
  27     if (obj->region.xrgn)
  28     {
  29         XSetRegion( display, dc->u.x.gc, obj->region.xrgn );
  30         XSetClipOrigin( display, dc->u.x.gc, dc->w.DCOrgX, dc->w.DCOrgY );
  31     }
  32     else if (obj->region.pixmap)
  33     {
  34         XSetClipMask( display, dc->u.x.gc, obj->region.pixmap );
  35         XSetClipOrigin( display, dc->u.x.gc,
  36                        dc->w.DCOrgX + obj->region.box.left,
  37                        dc->w.DCOrgY + obj->region.box.top );
  38     }
  39     else  /* Clip everything */
  40     {
  41         XSetClipRectangles( display, dc->u.x.gc, 0, 0, NULL, 0, 0 );
  42     }
  43 }
  44
  45
  46 /***********************************************************************
  47  *           CLIPPING_UpdateGCRegion
  48  *
  49  * Update the GC clip region when the ClipRgn or VisRgn have changed.
  50  */
  51 void CLIPPING_UpdateGCRegion( DC * dc )
  52 {
  53     if (!dc->w.hGCClipRgn) dc->w.hGCClipRgn = CreateRectRgn( 0, 0, 0, 0 );
  54
  55     if (!dc->w.hVisRgn)
  56     {
  57         fprintf( stderr, "UpdateGCRegion: hVisRgn is zero. Please report this.\n" );
  58         exit(1);
  59     }
  60     if (!dc->w.hClipRgn)
  61         CombineRgn( dc->w.hGCClipRgn, dc->w.hVisRgn, 0, RGN_COPY );
  62     else
  63         CombineRgn( dc->w.hGCClipRgn, dc->w.hClipRgn, dc->w.hVisRgn, RGN_AND );
  64     CLIPPING_SetDeviceClipping( dc );
  65 }
  66
  67
  68 /***********************************************************************
  69  *           SelectClipRgn    (GDI.44)
  70  */
  71 int SelectClipRgn( HDC hdc, HRGN hrgn )
  72 {
  73     int retval;
  74     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
  75     if (!dc) return ERROR;
  76
  77     dprintf_clipping(stddeb, "SelectClipRgn: %d %d\n", hdc, hrgn );
  78
  79     if (hrgn)
  80     {
  81         if (!dc->w.hClipRgn) dc->w.hClipRgn = CreateRectRgn(0,0,0,0);
  82         retval = CombineRgn( dc->w.hClipRgn, hrgn, 0, RGN_COPY );
  83     }
  84     else
  85     {
  86         if (dc->w.hClipRgn) DeleteObject( dc->w.hClipRgn );
  87         dc->w.hClipRgn = 0;
  88         retval = SIMPLEREGION; /* Clip region == whole DC */
  89     }
  90     CLIPPING_UpdateGCRegion( dc );
  91     return retval;
  92 }
  93
  94
  95 /***********************************************************************
  96  *           SelectVisRgn    (GDI.105)
  97  */
  98 int SelectVisRgn( HDC hdc, HRGN hrgn )
  99 {
 100     int retval;
 101     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 102     if (!dc || !hrgn) return ERROR;
 103
 104     dprintf_clipping(stddeb, "SelectVisRgn: %d %d\n", hdc, hrgn );
 105
 106     retval = CombineRgn( dc->w.hVisRgn, hrgn, 0, RGN_COPY );
 107     CLIPPING_UpdateGCRegion( dc );
 108     return retval;
 109 }
 110
 111
 112 /***********************************************************************
 113  *           OffsetClipRgn    (GDI.32)
 114  */
 115 int OffsetClipRgn( HDC hdc, short x, short y )
 116 {
 117     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 118     if (!dc)
 119     {
 120         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 121         if (!dc) return ERROR;
 122         MF_MetaParam2(dc, META_OFFSETCLIPRGN, x, y);
 123         return NULLREGION;   /* ?? */
 124     }
 125
 126     dprintf_clipping(stddeb, "OffsetClipRgn: %d %d,%d\n", hdc, x, y );
 127
 128     if (dc->w.hClipRgn)
 129     {
 130         int retval = OffsetRgn( dc->w.hClipRgn, XLPTODP(dc,x), YLPTODP(dc,y) );
 131         CLIPPING_UpdateGCRegion( dc );
 132         return retval;
 133     }
 134     else return SIMPLEREGION; /* Clip region == client area */
 135 }
 136
 137
 138 /***********************************************************************
 139  *           OffsetVisRgn    (GDI.102)
 140  */
 141 int OffsetVisRgn( HDC hdc, short x, short y )
 142 {
 143     int retval;
 144     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 145     if (!dc) return ERROR;
 146     dprintf_clipping(stddeb, "OffsetVisRgn: %d %d,%d\n", hdc, x, y );
 147     retval = OffsetRgn( dc->w.hVisRgn, x, y );
 148     CLIPPING_UpdateGCRegion( dc );
 149     return retval;
 150 }
 151
 152
 153 /***********************************************************************
 154  *           CLIPPING_IntersectClipRect
 155  *
 156  * Helper function for {Intersect,Exclude}ClipRect
 157  */
 158 static int CLIPPING_IntersectClipRect( DC * dc, short left, short top,
 159                                        short right, short bottom, BOOL exclude)
 160 {
 161     HRGN tempRgn, newRgn;
 162     int ret;
 163
 164     left   = XLPTODP( dc, left );
 165     right  = XLPTODP( dc, right );
 166     top    = YLPTODP( dc, top );
 167     bottom = YLPTODP( dc, bottom );
 168
 169     if (!(newRgn = CreateRectRgn( 0, 0, 0, 0 ))) return ERROR;
 170     if (!(tempRgn = CreateRectRgn( left, top, right, bottom )))
 171     {
 172         DeleteObject( newRgn );
 173         return ERROR;
 174     }
 175     ret = CombineRgn( newRgn, dc->w.hClipRgn ? dc->w.hClipRgn : dc->w.hVisRgn,
 176                       tempRgn, exclude ? RGN_DIFF : RGN_AND);
 177     DeleteObject( tempRgn );
 178
 179     if (ret != ERROR)
 180     {
 181         if (dc->w.hClipRgn) DeleteObject( dc->w.hClipRgn );
 182         dc->w.hClipRgn = newRgn;
 183         CLIPPING_UpdateGCRegion( dc );
 184     }
 185     else DeleteObject( newRgn );
 186     return ret;
 187 }
 188
 189
 190 /***********************************************************************
 191  *           ExcludeClipRect    (GDI.21)
 192  */
 193 int ExcludeClipRect( HDC hdc, short left, short top,
 194                      short right, short bottom )
 195 {
 196     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 197     if (!dc)
 198     {
 199         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 200         if (!dc) return ERROR;
 201         MF_MetaParam4(dc, META_EXCLUDECLIPRECT, left, top, right, bottom);
 202         return NULLREGION;   /* ?? */
 203     }
 204
 205     dprintf_clipping(stddeb, "ExcludeClipRect: %d %dx%d,%dx%d\n",
 206             hdc, left, top, right, bottom );
 207     return CLIPPING_IntersectClipRect( dc, left, top, right, bottom, TRUE );
 208 }
 209
 210
 211 /***********************************************************************
 212  *           IntersectClipRect    (GDI.22)
 213  */
 214 int IntersectClipRect( HDC hdc, short left, short top,
 215                        short right, short bottom )
 216 {
 217     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 218     if (!dc)
 219     {
 220         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 221         if (!dc) return ERROR;
 222         MF_MetaParam4(dc, META_INTERSECTCLIPRECT, left, top, right, bottom);
 223         return NULLREGION;   /* ?? */
 224     }
 225
 226     dprintf_clipping(stddeb, "IntersectClipRect: %d %dx%d,%dx%d\n",
 227             hdc, left, top, right, bottom );
 228     return CLIPPING_IntersectClipRect( dc, left, top, right, bottom, FALSE );
 229 }
 230
 231
 232 /***********************************************************************
 233  *           CLIPPING_IntersectVisRect
 234  *
 235  * Helper function for {Intersect,Exclude}VisRect
 236  */
 237 static int CLIPPING_IntersectVisRect( DC * dc, short left, short top,
 238                                       short right, short bottom, BOOL exclude )
 239 {
 240     HRGN tempRgn, newRgn;
 241     int ret;
 242
 243     left   = XLPTODP( dc, left );
 244     right  = XLPTODP( dc, right );
 245     top    = YLPTODP( dc, top );
 246     bottom = YLPTODP( dc, bottom );
 247
 248     if (!(newRgn = CreateRectRgn( 0, 0, 0, 0 ))) return ERROR;
 249     if (!(tempRgn = CreateRectRgn( left, top, right, bottom )))
 250     {
 251         DeleteObject( newRgn );
 252         return ERROR;
 253     }
 254     ret = CombineRgn( newRgn, dc->w.hVisRgn, tempRgn,
 255                       exclude ? RGN_DIFF : RGN_AND);
 256     DeleteObject( tempRgn );
 257
 258     if (ret != ERROR)
 259     {
 260         RGNOBJ *newObj  = (RGNOBJ*)GDI_GetObjPtr( newRgn, REGION_MAGIC);
 261         RGNOBJ *prevObj = (RGNOBJ*)GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC);
 262         if (newObj && prevObj) newObj->header.hNext = prevObj->header.hNext;
 263         DeleteObject( dc->w.hVisRgn );
 264         dc->w.hVisRgn = newRgn;
 265         CLIPPING_UpdateGCRegion( dc );
 266     }
 267     else DeleteObject( newRgn );
 268     return ret;
 269 }
 270
 271
 272 /***********************************************************************
 273  *           ExcludeVisRect    (GDI.73)
 274  */
 275 int ExcludeVisRect( HDC hdc, short left, short top, short right, short bottom )
 276 {
 277     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 278     if (!dc) return ERROR;
 279     dprintf_clipping(stddeb, "ExcludeVisRect: %d %dx%d,%dx%d\n",
 280             hdc, left, top, right, bottom );
 281     return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, TRUE );
 282 }
 283
 284
 285 /***********************************************************************
 286  *           IntersectVisRect    (GDI.98)
 287  */
 288 int IntersectVisRect( HDC hdc, short left, short top,
 289                       short right, short bottom )
 290 {
 291     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 292     if (!dc) return ERROR;
 293     dprintf_clipping(stddeb, "IntersectVisRect: %d %dx%d,%dx%d\n",
 294             hdc, left, top, right, bottom );
 295     return CLIPPING_IntersectVisRect( dc, left, top, right, bottom, FALSE );
 296 }
 297
 298
 299 /***********************************************************************
 300  *           PtVisible    (GDI.103)
 301  */
 302 BOOL PtVisible( HDC hdc, short x, short y )
 303 {
 304     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 305     if (!dc) return ERROR;
 306
 307     dprintf_clipping(stddeb, "PtVisible: %d %d,%d\n", hdc, x, y );
 308     if (!dc->w.hGCClipRgn) return FALSE;
 309     return PtInRegion( dc->w.hGCClipRgn, XLPTODP(dc,x), YLPTODP(dc,y) );
 310 }
 311
 312
 313 /***********************************************************************
 314  *           RectVisible    (GDI.104)
 315  */
 316 BOOL RectVisible( HDC hdc, LPRECT rect )
 317 {
 318     RECT tmpRect;
 319     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 320     if (!dc) return FALSE;
 321     dprintf_clipping(stddeb,"RectVisible: %d %p\n", hdc, rect );
 322     if (!dc->w.hGCClipRgn) return FALSE;
 323     LPtoDP( hdc, (LPPOINT)rect, 2 );
 324     return RectInRegion( dc->w.hGCClipRgn, &tmpRect );
 325 }
 326
 327
 328 /***********************************************************************
 329  *           GetClipBox    (GDI.77)
 330  */
 331 int GetClipBox( HDC hdc, LPRECT rect )
 332 {
 333     int ret;
 334     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 335     if (!dc) return ERROR;
 336     dprintf_clipping(stddeb, "GetClipBox: %d %p\n", hdc, rect );
 337     ret = GetRgnBox( dc->w.hGCClipRgn, rect );
 338     DPtoLP( hdc, (LPPOINT)rect, 2 );
 339     return ret;
 340 }
 341
 342
 343 /***********************************************************************
 344  *           SaveVisRgn    (GDI.129)
 345  */
 346 HRGN SaveVisRgn( HDC hdc )
 347 {
 348     HRGN copy;
 349     RGNOBJ *obj, *copyObj;
 350     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 351     if (!dc) return 0;
 352     dprintf_clipping(stddeb, "SaveVisRgn: %d\n", hdc );
 353     if (!dc->w.hVisRgn)
 354     {
 355         fprintf( stderr, "SaveVisRgn: hVisRgn is zero. Please report this.\n" );
 356         exit(1);
 357     }
 358     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
 359         return 0;
 360     if (!(copy = CreateRectRgn( 0, 0, 0, 0 ))) return 0;
 361     CombineRgn( copy, dc->w.hVisRgn, 0, RGN_COPY );
 362     if (!(copyObj = (RGNOBJ *) GDI_GetObjPtr( copy, REGION_MAGIC )))
 363         return 0;
 364     copyObj->header.hNext = obj->header.hNext;
 365     obj->header.hNext = copy;
 366     return copy;
 367 }
 368
 369
 370 /***********************************************************************
 371  *           RestoreVisRgn    (GDI.130)
 372  */
 373 int RestoreVisRgn( HDC hdc )
 374 {
 375     HRGN saved;
 376     RGNOBJ *obj, *savedObj;
 377     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 378     if (!dc || !dc->w.hVisRgn) return ERROR;
 379     dprintf_clipping(stddeb, "RestoreVisRgn: %d\n", hdc );
 380     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( dc->w.hVisRgn, REGION_MAGIC )))
 381         return ERROR;
 382     if (!(saved = obj->header.hNext)) return ERROR;
 383     if (!(savedObj = (RGNOBJ *) GDI_GetObjPtr( saved, REGION_MAGIC )))
 384         return ERROR;
 385     DeleteObject( dc->w.hVisRgn );
 386     dc->w.hVisRgn = saved;
 387     CLIPPING_UpdateGCRegion( dc );
 388     return savedObj->region.type;
 389 }