objects/region.c

   1 /*
   2  * GDI region objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <X11/Xlib.h>
  12 #include <X11/Xutil.h>
  13 #include "gdi.h"
  14
  15   /* GC used for region operations */
  16 static GC regionGC = 0;
  17
  18 /***********************************************************************
  19  *           REGION_Init
  20  */
  21 BOOL REGION_Init()
  22 {
  23     Pixmap tmpPixmap;
  24
  25       /* CreateGC needs a drawable */
  26     tmpPixmap = XCreatePixmap( display, rootWindow, 1, 1, 1 );
  27     if (tmpPixmap)
  28     {
  29         regionGC = XCreateGC( XT_display, tmpPixmap, 0, NULL );
  30         XFreePixmap( XT_display, tmpPixmap );
  31         if (!regionGC) return FALSE;
  32         XSetForeground( XT_display, regionGC, 1 );
  33         XSetGraphicsExposures( XT_display, regionGC, False );
  34         return TRUE;
  35     }
  36     else return FALSE;
  37 }
  38
  39
  40 /***********************************************************************
  41  *           REGION_SetRect
  42  *
  43  * Set the bounding box of the region and create the pixmap.
  44  * The hrgn must be valid.
  45  */
  46 static BOOL REGION_SetRect( HRGN hrgn, LPRECT rect )
  47 {
  48     int width, height;
  49
  50       /* Fill region */
  51
  52     REGION * region = &((RGNOBJ *)GDI_HEAP_ADDR( hrgn ))->region;
  53     width  = rect->right - rect->left;
  54     height = rect->bottom - rect->top;
  55     if ((width <= 0) || (height <= 0))
  56     {
  57         region->type       = NULLREGION;
  58         region->box.left   = 0;
  59         region->box.right  = 0;
  60         region->box.top    = 0;
  61         region->box.bottom = 0;
  62         region->pixmap     = 0;
  63         return TRUE;
  64     }
  65     region->type = SIMPLEREGION;
  66     region->box  = *rect;
  67
  68       /* Create pixmap */
  69
  70     region->pixmap = XCreatePixmap( display, rootWindow, width, height, 1 );
  71     if (!region->pixmap) return FALSE;
  72
  73       /* Fill pixmap */
  74
  75     XSetFunction( XT_display, regionGC, GXclear );
  76     XFillRectangle( XT_display, region->pixmap, regionGC,
  77                     0, 0, width, height );
  78     return TRUE;
  79 }
  80
  81
  82 /***********************************************************************
  83  *           REGION_DeleteObject
  84  */
  85 BOOL REGION_DeleteObject( HRGN hrgn, RGNOBJ * obj )
  86 {
  87     if (obj->region.pixmap) XFreePixmap( XT_display, obj->region.pixmap );
  88     return GDI_FreeObject( hrgn );
  89 }
  90
  91
  92 /***********************************************************************
  93  *           OffsetRgn    (GDI.101)
  94  */
  95 int OffsetRgn( HRGN hrgn, short x, short y )
  96 {
  97     RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
  98     if (!obj) return ERROR;
  99 #ifdef DEBUG_REGION
 100     printf( "OffsetRgn: %d %d,%d\n", hrgn, x, y );
 101 #endif
 102     OffsetRect( &obj->region.box, x, y );
 103     return obj->region.type;
 104 }
 105
 106
 107 /***********************************************************************
 108  *           GetRgnBox    (GDI.134)
 109  */
 110 int GetRgnBox( HRGN hrgn, LPRECT rect )
 111 {
 112     RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
 113     if (!obj) return ERROR;
 114 #ifdef DEBUG_REGION
 115     printf( "GetRgnBox: %d\n", hrgn );
 116 #endif
 117     *rect = obj->region.box;
 118     return obj->region.type;
 119 }
 120
 121
 122 /***********************************************************************
 123  *           CreateRectRgn    (GDI.64)
 124  */
 125 HRGN CreateRectRgn( short left, short top, short right, short bottom )
 126 {
 127     RECT rect = { left, top, right, bottom };
 128     return CreateRectRgnIndirect( &rect );
 129 }
 130
 131
 132 /***********************************************************************
 133  *           CreateRectRgnIndirect    (GDI.65)
 134  */
 135 HRGN CreateRectRgnIndirect( LPRECT rect )
 136 {
 137     RGNOBJ * rgnObj;
 138     HRGN hrgn;
 139
 140 #ifdef DEBUG_REGION
 141     printf( "CreateRectRgnIndirect: %d,%d-%d,%d\n",
 142             rect->left, rect->top, rect->right, rect->bottom );
 143 #endif
 144
 145       /* Create region */
 146
 147     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
 148     if (!REGION_SetRect( hrgn, rect ))
 149     {
 150         GDI_FreeObject( hrgn );
 151         return 0;
 152     }
 153     rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
 154
 155       /* Fill pixmap */
 156
 157     if (rgnObj->region.type != NULLREGION)
 158     {
 159         int width  = rgnObj->region.box.right - rgnObj->region.box.left;
 160         int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
 161         XSetFunction( XT_display, regionGC, GXcopy );
 162         XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
 163                         0, 0, width, height );
 164     }
 165
 166     return hrgn;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           CreateRoundRectRgn    (GDI.444)
 172  */
 173 HRGN CreateRoundRectRgn( short left, short top, short right, short bottom,
 174                          short ellipse_width, short ellipse_height )
 175 {
 176     RECT rect = { left, top, right, bottom };
 177     RGNOBJ * rgnObj;
 178     HRGN hrgn;
 179
 180 #ifdef DEBUG_REGION
 181     printf( "CreateRoundRectRgn: %d,%d-%d,%d %dx%d\n",
 182             left, top, right, bottom, ellipse_width, ellipse_height );
 183 #endif
 184
 185       /* Create region */
 186
 187     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
 188     if (!REGION_SetRect( hrgn, &rect ))
 189     {
 190         GDI_FreeObject( hrgn );
 191         return 0;
 192     }
 193     rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
 194
 195       /* Fill pixmap */
 196
 197     if (rgnObj->region.type != NULLREGION)
 198     {
 199         int width  = rgnObj->region.box.right - rgnObj->region.box.left;
 200         int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
 201         XSetFunction( XT_display, regionGC, GXcopy );
 202         XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
 203                         0, ellipse_height / 2,
 204                         width, height - ellipse_height );
 205         XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
 206                         ellipse_width / 2, 0,
 207                         width - ellipse_width, height );
 208         XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
 209                   0, 0,
 210                   ellipse_width, ellipse_height, 0, 360*64 );
 211         XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
 212                   width - ellipse_width, 0,
 213                   ellipse_width, ellipse_height, 0, 360*64 );
 214         XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
 215                   0, height - ellipse_height,
 216                   ellipse_width, ellipse_height, 0, 360*64 );
 217         XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
 218                   width - ellipse_width, height - ellipse_height,
 219                   ellipse_width, ellipse_height, 0, 360*64 );
 220     }
 221
 222     return hrgn;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           SetRectRgn    (GDI.172)
 228  */
 229 void SetRectRgn( HRGN hrgn, short left, short top, short right, short bottom )
 230 {
 231     RECT rect = { left, top, right, bottom };
 232     RGNOBJ * rgnObj;
 233
 234 #ifdef DEBUG_REGION
 235     printf( "SetRectRgn: %d %d,%d-%d,%d\n", hrgn, left, top, right, bottom );
 236 #endif
 237
 238       /* Free previous pixmap */
 239
 240     if (!(rgnObj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return;
 241     if (rgnObj->region.pixmap)
 242         XFreePixmap( XT_display, rgnObj->region.pixmap );
 243
 244     if (!REGION_SetRect( hrgn, &rect )) return;
 245
 246       /* Fill pixmap */
 247
 248     if (rgnObj->region.type != NULLREGION)
 249     {
 250         int width  = rgnObj->region.box.right - rgnObj->region.box.left;
 251         int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
 252         XSetFunction( XT_display, regionGC, GXcopy );
 253         XFillRectangle( XT_display, rgnObj->region.pixmap, regionGC,
 254                         0, 0, width, height );
 255     }
 256 }
 257
 258
 259 /***********************************************************************
 260  *           CreateEllipticRgn    (GDI.54)
 261  */
 262 HRGN CreateEllipticRgn( short left, short top, short right, short bottom )
 263 {
 264     RECT rect = { left, top, right, bottom };
 265     return CreateEllipticRgnIndirect( &rect );
 266 }
 267
 268
 269 /***********************************************************************
 270  *           CreateEllipticRgnIndirect    (GDI.55)
 271  */
 272 HRGN CreateEllipticRgnIndirect( LPRECT rect )
 273 {
 274     RGNOBJ * rgnObj;
 275     HRGN hrgn;
 276
 277 #ifdef DEBUG_REGION
 278     printf( "CreateEllipticRgnIndirect: %d,%d-%d,%d\n",
 279             rect->left, rect->top, rect->right, rect->bottom );
 280 #endif
 281
 282       /* Create region */
 283
 284     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
 285     if (!REGION_SetRect( hrgn, rect ))
 286     {
 287         GDI_FreeObject( hrgn );
 288         return 0;
 289     }
 290     rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
 291
 292       /* Fill pixmap */
 293
 294     if (rgnObj->region.type != NULLREGION)
 295     {
 296         int width  = rgnObj->region.box.right - rgnObj->region.box.left;
 297         int height = rgnObj->region.box.bottom - rgnObj->region.box.top;
 298         XSetFunction( XT_display, regionGC, GXcopy );
 299         XFillArc( XT_display, rgnObj->region.pixmap, regionGC,
 300                   0, 0, width, height, 0, 360*64 );
 301     }
 302
 303     return hrgn;
 304 }
 305
 306
 307 /***********************************************************************
 308  *           CreatePolygonRgn    (GDI.63)
 309  */
 310 HRGN CreatePolygonRgn( POINT * points, short count, short mode )
 311 {
 312     return CreatePolyPolygonRgn( points, &count, 1, mode );
 313 }
 314
 315
 316 /***********************************************************************
 317  *           CreatePolyPolygonRgn    (GDI.451)
 318  */
 319 HRGN CreatePolyPolygonRgn( POINT * points, short * count,
 320                            short nbpolygons, short mode )
 321 {
 322     RGNOBJ * rgnObj;
 323     HRGN hrgn;
 324     RECT box;
 325     int i, j, totalPoints;
 326     POINT * pt;
 327     XPoint * xpoints;
 328
 329     if (!nbpolygons) return 0;
 330 #ifdef DEBUG_REGION
 331     printf( "CreatePolyPolygonRgn: %d polygons\n", nbpolygons );
 332 #endif
 333
 334       /* Find bounding box */
 335
 336     box.top   = box.left   = 32767;
 337     box.right = box.bottom = 0;
 338     for (i = totalPoints = 0, pt = points; i < nbpolygons; i++)
 339     {
 340         totalPoints += count[i];
 341         for (j = 0; j < count[i]; j++, pt++)
 342         {
 343             if (pt->x < box.left) box.left = pt->x;
 344             if (pt->x > box.right) box.right = pt->x;
 345             if (pt->y < box.top) box.top = pt->y;
 346             if (pt->y > box.bottom) box.bottom = pt->y;
 347         }
 348     }
 349     if (!totalPoints) return 0;
 350
 351       /* Build points array */
 352
 353     xpoints = (XPoint *) malloc( sizeof(XPoint) * totalPoints );
 354     if (!xpoints) return 0;
 355     for (i = 0, pt = points; i < totalPoints; i++, pt++)
 356     {
 357         xpoints[i].x = pt->x - box.left;
 358         xpoints[i].y = pt->y - box.top;
 359     }
 360
 361       /* Create region */
 362
 363     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC )) ||
 364         !REGION_SetRect( hrgn, &box ))
 365     {
 366         if (hrgn) GDI_FreeObject( hrgn );
 367         free( xpoints );
 368         return 0;
 369     }
 370     rgnObj = (RGNOBJ *) GDI_HEAP_ADDR( hrgn );
 371
 372       /* Fill pixmap */
 373
 374     if (rgnObj->region.type != NULLREGION)
 375     {
 376         XSetFunction( XT_display, regionGC, GXcopy );
 377         if (mode == WINDING) XSetFillRule( XT_display, regionGC, WindingRule );
 378         else XSetFillRule( XT_display, regionGC, EvenOddRule );
 379         for (i = j = 0; i < nbpolygons; i++)
 380         {
 381             XFillPolygon( XT_display, rgnObj->region.pixmap, regionGC,
 382                           &xpoints[j], count[i], Complex, CoordModeOrigin );
 383             j += count[i];
 384         }
 385     }
 386
 387     free( xpoints );
 388     return hrgn;
 389 }
 390
 391
 392 /***********************************************************************
 393  *           PtInRegion    (GDI.161)
 394  */
 395 BOOL PtInRegion( HRGN hrgn, short x, short y )
 396 {
 397     XImage * image;
 398     BOOL res;
 399     RGNOBJ * obj;
 400     POINT pt = { x, y };
 401
 402     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return FALSE;
 403     if (!PtInRect( &obj->region.box, pt )) return FALSE;
 404     image = XGetImage( XT_display, obj->region.pixmap,
 405                        x - obj->region.box.left, y - obj->region.box.top,
 406                        1, 1, AllPlanes, ZPixmap );
 407     if (!image) return FALSE;
 408     res = (XGetPixel( image, 0, 0 ) != 0);
 409     XDestroyImage( image );
 410     return res;
 411 }
 412
 413
 414 /***********************************************************************
 415  *           RectInRegion    (GDI.181)
 416  */
 417 BOOL RectInRegion( HRGN hrgn, LPRECT rect )
 418 {
 419     XImage * image;
 420     RGNOBJ * obj;
 421     RECT intersect;
 422     int x, y;
 423
 424     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return FALSE;
 425     if (!IntersectRect( &intersect, &obj->region.box, rect )) return FALSE;
 426
 427     image = XGetImage( XT_display, obj->region.pixmap,
 428                        intersect.left - obj->region.box.left,
 429                        intersect.top - obj->region.box.top,
 430                        intersect.right - intersect.left,
 431                        intersect.bottom - intersect.top,
 432                        AllPlanes, ZPixmap );
 433     if (!image) return FALSE;
 434     for (y = 0; y < image->height; y++)
 435         for (x = 0; x < image->width; x++)
 436             if (XGetPixel( image, x, y ) != 0)
 437             {
 438                 XDestroyImage( image );
 439                 return TRUE;
 440             }
 441
 442     XDestroyImage( image );
 443     return FALSE;
 444 }
 445
 446
 447 /***********************************************************************
 448  *           EqualRgn    (GDI.72)
 449  */
 450 BOOL EqualRgn( HRGN rgn1, HRGN rgn2 )
 451 {
 452     RGNOBJ *obj1, *obj2;
 453     XImage *image1, *image2;
 454     int width, height, x, y;
 455
 456       /* Compare bounding boxes */
 457
 458     if (!(obj1 = (RGNOBJ *) GDI_GetObjPtr( rgn1, REGION_MAGIC ))) return FALSE;
 459     if (!(obj2 = (RGNOBJ *) GDI_GetObjPtr( rgn2, REGION_MAGIC ))) return FALSE;
 460     if (obj1->region.type == NULLREGION)
 461         return (obj2->region.type == NULLREGION);
 462     else if (obj2->region.type == NULLREGION) return FALSE;
 463     if (!EqualRect( &obj1->region.box, &obj2->region.box )) return FALSE;
 464
 465       /* Get pixmap contents */
 466
 467     width  = obj1->region.box.right - obj1->region.box.left;
 468     height = obj1->region.box.bottom - obj1->region.box.top;
 469     image1 = XGetImage( XT_display, obj1->region.pixmap,
 470                         0, 0, width, height, AllPlanes, ZPixmap );
 471     if (!image1) return FALSE;
 472     image2 = XGetImage( XT_display, obj2->region.pixmap,
 473                         0, 0, width, height, AllPlanes, ZPixmap );
 474     if (!image2)
 475     {
 476         XDestroyImage( image1 );
 477         return FALSE;
 478     }
 479
 480       /* Compare pixmaps */
 481     for (y = 0; y < height; y++)
 482         for (x = 0; x < width; x++)
 483             if (XGetPixel( image1, x, y ) != XGetPixel( image2, x, y))
 484             {
 485                 XDestroyImage( image1 );
 486                 XDestroyImage( image2 );
 487                 return FALSE;
 488             }
 489
 490     XDestroyImage( image1 );
 491     XDestroyImage( image2 );
 492     return TRUE;
 493 }
 494
 495
 496 /***********************************************************************
 497  *           REGION_CopyIntersection
 498  *
 499  * Copy to dest->pixmap the area of src->pixmap delimited by
 500  * the intersection of dest and src regions, using the current GC function.
 501  */
 502 void REGION_CopyIntersection( REGION * dest, REGION * src )
 503 {
 504     RECT inter;
 505     if (!IntersectRect( &inter, &dest->box, &src->box )) return;
 506     XCopyArea( XT_display, src->pixmap, dest->pixmap, regionGC,
 507                inter.left - src->box.left, inter.top - src->box.top,
 508                inter.right - inter.left, inter.bottom - inter.top,
 509                inter.left - dest->box.left, inter.top - dest->box.top );
 510 }
 511
 512
 513 /***********************************************************************
 514  *           CombineRgn    (GDI.451)
 515  */
 516 int CombineRgn( HRGN hDest, HRGN hSrc1, HRGN hSrc2, short mode )
 517 {
 518     RGNOBJ *destObj, *src1Obj, *src2Obj;
 519     REGION * region;
 520     int width, height;
 521     BOOL res;
 522
 523 #ifdef DEBUG_REGION
 524     printf( "CombineRgn: %d %d %d %d\n", hDest, hSrc1, hSrc2, mode );
 525 #endif
 526
 527     if (!(destObj = (RGNOBJ *) GDI_GetObjPtr( hDest, REGION_MAGIC )))
 528         return ERROR;
 529     if (!(src1Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc1, REGION_MAGIC )))
 530         return ERROR;
 531     if (mode != RGN_COPY)
 532         if (!(src2Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc2, REGION_MAGIC )))
 533             return ERROR;
 534     region = &destObj->region;
 535
 536     switch(mode)
 537     {
 538       case RGN_AND:
 539         res = IntersectRect( &region->box, &src1Obj->region.box,
 540                              &src2Obj->region.box );
 541         region->type = COMPLEXREGION;
 542         break;
 543
 544       case RGN_OR:
 545       case RGN_XOR:
 546         res = UnionRect( &region->box, &src1Obj->region.box,
 547                          &src2Obj->region.box );
 548         region->type = COMPLEXREGION;
 549         break;
 550
 551       case RGN_DIFF:
 552         res = SubtractRect( &region->box, &src1Obj->region.box,
 553                             &src2Obj->region.box );
 554         region->type = COMPLEXREGION;
 555         break;
 556
 557       case RGN_COPY:
 558         region->box  = src1Obj->region.box;
 559         region->type = src1Obj->region.type;
 560         res = (region->type != NULLREGION);
 561         break;
 562
 563       default:
 564         return ERROR;
 565     }
 566
 567     if (region->pixmap) XFreePixmap( XT_display, region->pixmap );
 568     if (!res)
 569     {
 570         region->type   = NULLREGION;
 571         region->pixmap = 0;
 572         return NULLREGION;
 573     }
 574
 575     width  = region->box.right - region->box.left;
 576     height = region->box.bottom - region->box.top;
 577     if (!width || !height)
 578     {
 579         printf( "CombineRgn: width or height is 0. Please report this.\n" );
 580         printf( "src1=%d,%d-%d,%d  src2=%d,%d-%d,%d  dst=%d,%d-%d,%d  op=%d\n",
 581                 src1Obj->region.box.left, src1Obj->region.box.top,
 582                 src1Obj->region.box.right, src1Obj->region.box.bottom,
 583                 src2Obj->region.box.left, src2Obj->region.box.top,
 584                 src2Obj->region.box.right, src2Obj->region.box.bottom,
 585                 region->box.left, region->box.top,
 586                 region->box.right, region->box.bottom, mode );
 587         exit(1);
 588     }
 589     region->pixmap = XCreatePixmap( display, rootWindow, width, height, 1 );
 590
 591     switch(mode)
 592     {
 593       case RGN_AND:
 594           XSetFunction( XT_display, regionGC, GXcopy );
 595           REGION_CopyIntersection( region, &src1Obj->region );
 596           XSetFunction( XT_display, regionGC, GXand );
 597           REGION_CopyIntersection( region, &src2Obj->region );
 598           break;
 599
 600       case RGN_OR:
 601       case RGN_XOR:
 602           XSetFunction( XT_display, regionGC, GXclear );
 603           XFillRectangle( XT_display, region->pixmap, regionGC,
 604                           0, 0, width, height );
 605           XSetFunction( XT_display, regionGC, (mode == RGN_OR) ? GXor : GXxor);
 606           REGION_CopyIntersection( region, &src1Obj->region );
 607           REGION_CopyIntersection( region, &src2Obj->region );
 608           break;
 609
 610       case RGN_DIFF:
 611           XSetFunction( XT_display, regionGC, GXclear );
 612           XFillRectangle( XT_display, region->pixmap, regionGC,
 613                           0, 0, width, height );
 614           XSetFunction( XT_display, regionGC, GXcopy );
 615           REGION_CopyIntersection( region, &src1Obj->region );
 616           XSetFunction( XT_display, regionGC, GXandInverted );
 617           REGION_CopyIntersection( region, &src2Obj->region );
 618           break;
 619
 620       case RGN_COPY:
 621           XSetFunction( XT_display, regionGC, GXcopy );
 622           XCopyArea( XT_display, src1Obj->region.pixmap, region->pixmap,
 623                      regionGC, 0, 0, width, height, 0, 0 );
 624           break;
 625     }
 626     return region->type;
 627 }