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