objects/region.c

   1 /*
   2  * GDI region objects
   3  *
   4  * Copyright 1993, 1994, 1995 Alexandre Julliard
   5  *
   6  * RGNOBJ is documented in the Dr. Dobbs Journal March 1993.
   7  */
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include "region.h"
  12 #include "stddebug.h"
  13 #include "debug.h"
  14
  15
  16 /***********************************************************************
  17  *           REGION_DeleteObject
  18  */
  19 BOOL32 REGION_DeleteObject( HRGN32 hrgn, RGNOBJ * obj )
  20 {
  21     dprintf_region(stddeb, "DeleteRegion: %04x\n", hrgn );
  22     if (obj->xrgn) XDestroyRegion( obj->xrgn );
  23     return GDI_FreeObject( hrgn );
  24 }
  25
  26
  27 /***********************************************************************
  28  *           OffsetRgn16    (GDI.101)
  29  */
  30 INT16 WINAPI OffsetRgn16( HRGN16 hrgn, INT16 x, INT16 y )
  31 {
  32     return OffsetRgn32( hrgn, x, y );
  33 }
  34
  35
  36 /***********************************************************************
  37  *           OffsetRgn32   (GDI32.256)
  38  */
  39 INT32 WINAPI OffsetRgn32( HRGN32 hrgn, INT32 x, INT32 y )
  40 {
  41     RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
  42
  43     if (obj)
  44     {
  45         INT32 ret;
  46         dprintf_region(stddeb, "OffsetRgn: %04x %d,%d\n", hrgn, x, y );
  47         if (obj->xrgn)
  48         {
  49             XOffsetRegion( obj->xrgn, x, y );
  50             ret = COMPLEXREGION;
  51         }
  52         else
  53             ret = NULLREGION;
  54         GDI_HEAP_UNLOCK( hrgn );
  55         return ret;
  56     }
  57     return ERROR;
  58 }
  59
  60
  61 /***********************************************************************
  62  *           GetRgnBox16    (GDI.134)
  63  */
  64 INT16 WINAPI GetRgnBox16( HRGN16 hrgn, LPRECT16 rect )
  65 {
  66     RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
  67     if (obj)
  68     {
  69         INT16 ret;
  70         dprintf_region(stddeb, "GetRgnBox: %04x\n", hrgn );
  71         if (obj->xrgn)
  72         {
  73             XRectangle xrect;
  74             XClipBox( obj->xrgn, &xrect );
  75             SetRect16( rect, xrect.x, xrect.y,
  76                        xrect.x + xrect.width, xrect.y + xrect.height);
  77             ret = COMPLEXREGION;
  78         }
  79         else
  80         {
  81             SetRectEmpty16( rect );
  82             ret = NULLREGION;
  83         }
  84         GDI_HEAP_UNLOCK(hrgn);
  85         return ret;
  86     }
  87     return ERROR;
  88 }
  89
  90
  91 /***********************************************************************
  92  *           GetRgnBox32    (GDI32.219)
  93  */
  94 INT32 WINAPI GetRgnBox32( HRGN32 hrgn, LPRECT32 rect )
  95 {
  96     RECT16 r;
  97     INT16 ret = GetRgnBox16( hrgn, &r );
  98     CONV_RECT16TO32( &r, rect );
  99     return ret;
 100 }
 101
 102
 103 /***********************************************************************
 104  *           CreateRectRgn16    (GDI.64)
 105  */
 106 HRGN16 WINAPI CreateRectRgn16(INT16 left, INT16 top, INT16 right, INT16 bottom)
 107 {
 108     return (HRGN16)CreateRectRgn32( left, top, right, bottom );
 109 }
 110
 111
 112 /***********************************************************************
 113  *           CreateRectRgn32   (GDI32.59)
 114  */
 115 HRGN32 WINAPI CreateRectRgn32(INT32 left, INT32 top, INT32 right, INT32 bottom)
 116 {
 117     HRGN32 hrgn;
 118     RGNOBJ *obj;
 119
 120     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
 121     obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
 122     if ((right > left) && (bottom > top))
 123     {
 124         XRectangle rect = { left, top, right - left, bottom - top };
 125         if (!(obj->xrgn = XCreateRegion()))
 126         {
 127             GDI_FreeObject( hrgn );
 128             return 0;
 129         }
 130         XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 131     }
 132     else obj->xrgn = 0;
 133     dprintf_region( stddeb, "CreateRectRgn(%d,%d-%d,%d): returning %04x\n",
 134                     left, top, right, bottom, hrgn );
 135     GDI_HEAP_UNLOCK( hrgn );
 136     return hrgn;
 137 }
 138
 139
 140 /***********************************************************************
 141  *           CreateRectRgnIndirect16    (GDI.65)
 142  */
 143 HRGN16 WINAPI CreateRectRgnIndirect16( const RECT16* rect )
 144 {
 145     return CreateRectRgn32( rect->left, rect->top, rect->right, rect->bottom );
 146 }
 147
 148
 149 /***********************************************************************
 150  *           CreateRectRgnIndirect32    (GDI32.60)
 151  */
 152 HRGN32 WINAPI CreateRectRgnIndirect32( const RECT32* rect )
 153 {
 154     return CreateRectRgn32( rect->left, rect->top, rect->right, rect->bottom );
 155 }
 156
 157
 158 /***********************************************************************
 159  *           SetRectRgn16    (GDI.172)
 160  */
 161 VOID WINAPI SetRectRgn16( HRGN16 hrgn, INT16 left, INT16 top,
 162                           INT16 right, INT16 bottom )
 163 {
 164     SetRectRgn32( hrgn, left, top, right, bottom );
 165 }
 166
 167
 168 /***********************************************************************
 169  *           SetRectRgn32    (GDI32.332)
 170  */
 171 VOID WINAPI SetRectRgn32( HRGN32 hrgn, INT32 left, INT32 top,
 172                           INT32 right, INT32 bottom )
 173 {
 174     RGNOBJ * obj;
 175
 176     dprintf_region(stddeb, "SetRectRgn: %04x %d,%d-%d,%d\n",
 177                    hrgn, left, top, right, bottom );
 178
 179     if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return;
 180     if (obj->xrgn) XDestroyRegion( obj->xrgn );
 181     if ((right > left) && (bottom > top))
 182     {
 183         XRectangle rect = { left, top, right - left, bottom - top };
 184         if ((obj->xrgn = XCreateRegion()) != 0)
 185             XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 186     }
 187     else obj->xrgn = 0;
 188     GDI_HEAP_UNLOCK( hrgn );
 189 }
 190
 191
 192 /***********************************************************************
 193  *           CreateRoundRectRgn16    (GDI.444)
 194  */
 195 HRGN16 WINAPI CreateRoundRectRgn16( INT16 left, INT16 top,
 196                                     INT16 right, INT16 bottom,
 197                                     INT16 ellipse_width, INT16 ellipse_height )
 198 {
 199     return (HRGN16)CreateRoundRectRgn32( left, top, right, bottom,
 200                                          ellipse_width, ellipse_height );
 201 }
 202
 203
 204 /***********************************************************************
 205  *           CreateRoundRectRgn32    (GDI32.61)
 206  */
 207 HRGN32 WINAPI CreateRoundRectRgn32( INT32 left, INT32 top,
 208                                     INT32 right, INT32 bottom,
 209                                     INT32 ellipse_width, INT32 ellipse_height )
 210 {
 211     RGNOBJ * obj;
 212     HRGN32 hrgn;
 213     XRectangle rect;
 214     int asq, bsq, d, xd, yd;
 215
 216       /* Check if we can do a normal rectangle instead */
 217
 218     if ((right <= left) || (bottom <= top) ||
 219         (ellipse_width <= 0) || (ellipse_height <= 0))
 220         return CreateRectRgn32( left, top, right, bottom );
 221
 222       /* Create region */
 223
 224     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
 225     obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
 226     obj->xrgn = XCreateRegion();
 227     dprintf_region(stddeb,"CreateRoundRectRgn(%d,%d-%d,%d %dx%d): return=%04x\n",
 228                left, top, right, bottom, ellipse_width, ellipse_height, hrgn );
 229
 230       /* Check parameters */
 231
 232     if (ellipse_width > right-left) ellipse_width = right-left;
 233     if (ellipse_height > bottom-top) ellipse_height = bottom-top;
 234
 235       /* Ellipse algorithm, based on an article by K. Porter */
 236       /* in DDJ Graphics Programming Column, 8/89 */
 237
 238     asq = ellipse_width * ellipse_width / 4;        /* a^2 */
 239     bsq = ellipse_height * ellipse_height / 4;      /* b^2 */
 240     d = bsq - asq * ellipse_height / 2 + asq / 4;   /* b^2 - a^2b + a^2/4 */
 241     xd = 0;
 242     yd = asq * ellipse_height;                      /* 2a^2b */
 243
 244     rect.x      = left + ellipse_width / 2;
 245     rect.width  = right - left - ellipse_width;
 246     rect.height = 1;
 247
 248       /* Loop to draw first half of quadrant */
 249
 250     while (xd < yd)
 251     {
 252         if (d > 0)  /* if nearest pixel is toward the center */
 253         {
 254               /* move toward center */
 255             rect.y = top++;
 256             XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 257             rect.y = --bottom;
 258             XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 259             yd -= 2*asq;
 260             d  -= yd;
 261         }
 262         rect.x--;        /* next horiz point */
 263         rect.width += 2;
 264         xd += 2*bsq;
 265         d  += bsq + xd;
 266     }
 267
 268       /* Loop to draw second half of quadrant */
 269
 270     d += (3 * (asq-bsq) / 2 - (xd+yd)) / 2;
 271     while (yd >= 0)
 272     {
 273           /* next vertical point */
 274         rect.y = top++;
 275         XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 276         rect.y = --bottom;
 277         XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 278         if (d < 0)   /* if nearest pixel is outside ellipse */
 279         {
 280             rect.x--;     /* move away from center */
 281             rect.width += 2;
 282             xd += 2*bsq;
 283             d  += xd;
 284         }
 285         yd -= 2*asq;
 286         d  += asq - yd;
 287     }
 288
 289       /* Add the inside rectangle */
 290
 291     if (top <= bottom)
 292     {
 293         rect.y = top;
 294         rect.height = bottom - top + 1;
 295         XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
 296     }
 297     GDI_HEAP_UNLOCK( hrgn );
 298     return hrgn;
 299 }
 300
 301
 302 /***********************************************************************
 303  *           CreateEllipticRgn16    (GDI.54)
 304  */
 305 HRGN16 WINAPI CreateEllipticRgn16( INT16 left, INT16 top,
 306                                    INT16 right, INT16 bottom )
 307 {
 308     return (HRGN16)CreateRoundRectRgn32( left, top, right, bottom,
 309                                          right-left, bottom-top );
 310 }
 311
 312
 313 /***********************************************************************
 314  *           CreateEllipticRgn32    (GDI32.39)
 315  */
 316 HRGN32 WINAPI CreateEllipticRgn32( INT32 left, INT32 top,
 317                                    INT32 right, INT32 bottom )
 318 {
 319     return CreateRoundRectRgn32( left, top, right, bottom,
 320                                  right-left, bottom-top );
 321 }
 322
 323
 324 /***********************************************************************
 325  *           CreateEllipticRgnIndirect16    (GDI.55)
 326  */
 327 HRGN16 WINAPI CreateEllipticRgnIndirect16( const RECT16 *rect )
 328 {
 329     return CreateRoundRectRgn32( rect->left, rect->top, rect->right,
 330                                  rect->bottom, rect->right - rect->left,
 331                                  rect->bottom - rect->top );
 332 }
 333
 334
 335 /***********************************************************************
 336  *           CreateEllipticRgnIndirect32    (GDI32.40)
 337  */
 338 HRGN32 WINAPI CreateEllipticRgnIndirect32( const RECT32 *rect )
 339 {
 340     return CreateRoundRectRgn32( rect->left, rect->top, rect->right,
 341                                  rect->bottom, rect->right - rect->left,
 342                                  rect->bottom - rect->top );
 343 }
 344
 345
 346 /***********************************************************************
 347  *           CreatePolygonRgn16    (GDI.63)
 348  */
 349 HRGN16 WINAPI CreatePolygonRgn16( const POINT16 * points, INT16 count,
 350                                   INT16 mode )
 351 {
 352     return CreatePolyPolygonRgn16( points, &count, 1, mode );
 353 }
 354
 355
 356 /***********************************************************************
 357  *           CreatePolyPolygonRgn16    (GDI.451)
 358  */
 359 HRGN16 WINAPI CreatePolyPolygonRgn16( const POINT16 * points,
 360                                       const INT16 * count,
 361                                       INT16 nbpolygons, INT16 mode )
 362 {
 363     int         i,nrofpts;
 364     LPINT32     count32;
 365     LPPOINT32   points32;
 366     HRGN32      ret;
 367
 368     nrofpts=0;
 369     for (i=nbpolygons;i--;)
 370         nrofpts+=count[i];
 371     points32 = (LPPOINT32)HeapAlloc( GetProcessHeap(), 0,
 372                                      nrofpts*sizeof(POINT32) );
 373     for (i=nrofpts;i--;)
 374         CONV_POINT16TO32( &(points[i]), &(points32[i]) );
 375     count32 = (LPINT32)HeapAlloc( GetProcessHeap(), 0,
 376                                   sizeof(INT32)*nbpolygons );
 377     for (i=nbpolygons;i--;)
 378         count32[i]=count[i];
 379     ret = CreatePolyPolygonRgn32(points32,count32,nbpolygons,mode);
 380     HeapFree( GetProcessHeap(), 0, count32 );
 381     HeapFree( GetProcessHeap(), 0, points32 );
 382     return ret;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           CreatePolygonRgn32    (GDI32.58)
 388  */
 389 HRGN32 WINAPI CreatePolygonRgn32( const POINT32 *points, INT32 count,
 390                                   INT32 mode )
 391 {
 392     return CreatePolyPolygonRgn32( points, &count, 1, mode );
 393 }
 394
 395
 396 /***********************************************************************
 397  *           CreatePolyPolygonRgn32    (GDI32.57)
 398  */
 399 HRGN32 WINAPI CreatePolyPolygonRgn32( const POINT32 * points,
 400                                       const INT32 * count,
 401                                       INT32 nbpolygons, INT32 mode )
 402 {
 403     RGNOBJ * obj;
 404     HRGN32 hrgn;
 405     int i, j, maxPoints;
 406     XPoint *xpoints, *pt;
 407     Region xrgn;
 408
 409       /* Allocate points array */
 410
 411     if (!nbpolygons) return 0;
 412     for (i = maxPoints = 0; i < nbpolygons; i++)
 413         if (maxPoints < count[i]) maxPoints = count[i];
 414     if (!maxPoints) return 0;
 415     if (!(xpoints = (XPoint *)HeapAlloc( GetProcessHeap(), 0,
 416                                          sizeof(XPoint) * maxPoints )))
 417         return 0;
 418
 419       /* Allocate region */
 420
 421     if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC )))
 422     {
 423         HeapFree( GetProcessHeap(), 0, xpoints );
 424         return 0;
 425     }
 426     obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
 427     obj->xrgn = 0;
 428     dprintf_region(stddeb, "CreatePolyPolygonRgn: %d polygons, returning %04x\n",
 429                    nbpolygons, hrgn );
 430
 431       /* Create X region */
 432
 433     for (i = 0; i < nbpolygons; i++, count++)
 434     {
 435         if (*count <= 1) continue;
 436         for (j = *count, pt = xpoints; j > 0; j--, points++, pt++)
 437         {
 438             pt->x = points->x;
 439             pt->y = points->y;
 440         }
 441         xrgn = XPolygonRegion( xpoints, *count,
 442                                (mode == WINDING) ? WindingRule : EvenOddRule );
 443         if (!xrgn)
 444         {
 445             if (obj->xrgn) XDestroyRegion( obj->xrgn );
 446             HeapFree( GetProcessHeap(), 0, xpoints );
 447             GDI_FreeObject( hrgn );
 448             return 0;
 449         }
 450         if (obj->xrgn)
 451         {
 452             Region tmprgn = XCreateRegion();
 453             if (mode == WINDING) XUnionRegion( xrgn, obj->xrgn, tmprgn );
 454             else XXorRegion( xrgn, obj->xrgn, tmprgn );
 455             XDestroyRegion( obj->xrgn );
 456             obj->xrgn = tmprgn;
 457         }
 458         else obj->xrgn = xrgn;
 459     }
 460
 461     HeapFree( GetProcessHeap(), 0, xpoints );
 462     GDI_HEAP_UNLOCK( hrgn );
 463     return hrgn;
 464 }
 465
 466
 467 /***********************************************************************
 468  *           PtInRegion16    (GDI.161)
 469  */
 470 BOOL16 WINAPI PtInRegion16( HRGN16 hrgn, INT16 x, INT16 y )
 471 {
 472     return PtInRegion32( hrgn, x, y );
 473 }
 474
 475
 476 /***********************************************************************
 477  *           PtInRegion32    (GDI32.278)
 478  */
 479 BOOL32 WINAPI PtInRegion32( HRGN32 hrgn, INT32 x, INT32 y )
 480 {
 481     RGNOBJ * obj;
 482
 483     if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
 484     {
 485         BOOL32 ret;
 486         if (obj->xrgn)
 487             ret = XPointInRegion( obj->xrgn, x, y );
 488         else
 489             ret = FALSE;
 490         GDI_HEAP_UNLOCK( hrgn );
 491         return ret;
 492     }
 493     return FALSE;
 494 }
 495
 496
 497 /***********************************************************************
 498  *           RectInRegion16    (GDI.181)
 499  */
 500 BOOL16 WINAPI RectInRegion16( HRGN16 hrgn, const RECT16 *rect )
 501 {
 502     RGNOBJ * obj;
 503
 504     if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
 505     {
 506         BOOL16 ret;
 507         if (obj->xrgn)
 508             ret = (XRectInRegion( obj->xrgn, rect->left, rect->top,
 509                    rect->right-rect->left, rect->bottom-rect->top ) != RectangleOut);
 510         else
 511             ret = FALSE;
 512         GDI_HEAP_UNLOCK( hrgn );
 513         return ret;
 514     }
 515     return FALSE;
 516 }
 517
 518
 519 /***********************************************************************
 520  *           RectInRegion32    (GDI32.281)
 521  */
 522 BOOL32 WINAPI RectInRegion32( HRGN32 hrgn, const RECT32 *rect )
 523 {
 524     RGNOBJ * obj;
 525
 526     if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
 527     {
 528         BOOL32 ret;
 529         if (obj->xrgn)
 530             ret = (XRectInRegion( obj->xrgn, rect->left, rect->top,
 531                    rect->right-rect->left, rect->bottom-rect->top ) != RectangleOut);
 532         else
 533             ret = FALSE;
 534         GDI_HEAP_UNLOCK( hrgn );
 535         return ret;
 536     }
 537     return FALSE;
 538 }
 539
 540
 541 /***********************************************************************
 542  *           EqualRgn16    (GDI.72)
 543  */
 544 BOOL16 WINAPI EqualRgn16( HRGN16 rgn1, HRGN16 rgn2 )
 545 {
 546     return EqualRgn32( rgn1, rgn2 );
 547 }
 548
 549
 550 /***********************************************************************
 551  *           EqualRgn32    (GDI32.90)
 552  */
 553 BOOL32 WINAPI EqualRgn32( HRGN32 rgn1, HRGN32 rgn2 )
 554 {
 555     RGNOBJ *obj1, *obj2;
 556     BOOL32 ret = FALSE;
 557
 558     if ((obj1 = (RGNOBJ *) GDI_GetObjPtr( rgn1, REGION_MAGIC )))
 559     {
 560         if ((obj2 = (RGNOBJ *) GDI_GetObjPtr( rgn2, REGION_MAGIC )))
 561         {
 562             if (!obj1->xrgn || !obj2->xrgn)
 563                 ret = (!obj1->xrgn && !obj2->xrgn);
 564             else
 565                 ret = XEqualRegion( obj1->xrgn, obj2->xrgn );
 566             GDI_HEAP_UNLOCK( rgn2 );
 567         }
 568         GDI_HEAP_UNLOCK( rgn1 );
 569     }
 570     return ret;
 571 }
 572
 573
 574 /***********************************************************************
 575  *           REGION_CopyRegion
 576  *
 577  * Copy region src into dest.
 578  */
 579 static INT32 REGION_CopyRegion( RGNOBJ *src, RGNOBJ *dest )
 580 {
 581     Region tmprgn;
 582     if (src->xrgn)
 583     {
 584         if (src->xrgn == dest->xrgn) return COMPLEXREGION;
 585         tmprgn = XCreateRegion();
 586         if (!dest->xrgn) dest->xrgn = XCreateRegion();
 587         XUnionRegion( tmprgn, src->xrgn, dest->xrgn );
 588         XDestroyRegion( tmprgn );
 589         return COMPLEXREGION;
 590     }
 591     else
 592     {
 593         if (dest->xrgn) XDestroyRegion( dest->xrgn );
 594         dest->xrgn = 0;
 595         return NULLREGION;
 596     }
 597 }
 598
 599
 600 /***********************************************************************
 601  *           REGION_IsEmpty
 602  */
 603 BOOL32 REGION_IsEmpty( HRGN32 hRgn )
 604 {
 605     RGNOBJ*     rgnObj = (RGNOBJ*) GDI_GetObjPtr( hRgn, REGION_MAGIC );
 606     BOOL32      ret = TRUE;
 607
 608     if( rgnObj )
 609     {
 610         if( rgnObj->xrgn && !XEmptyRegion(rgnObj->xrgn) ) ret = FALSE;
 611         GDI_HEAP_UNLOCK( hRgn );
 612     }
 613     return ret;
 614 }
 615
 616
 617 /***********************************************************************
 618  *           REGION_UnionRectWithRgn
 619  *
 620  * Add rc rectangle to the region.
 621  */
 622 BOOL32 REGION_UnionRectWithRgn( HRGN32 hRgn, const RECT32 *rc )
 623 {
 624     RGNOBJ*     rgnObj = (RGNOBJ*) GDI_GetObjPtr( hRgn, REGION_MAGIC );
 625     XRectangle  rect = { rc->left, rc->top, rc->right - rc->left, rc->bottom - rc->top };
 626     BOOL32      ret = ERROR;
 627
 628     if( rgnObj )
 629     {
 630         if( !rgnObj->xrgn )
 631         {
 632             if ((rgnObj->xrgn = XCreateRegion()))
 633                 ret = SIMPLEREGION;
 634             else
 635                 goto done;
 636         }
 637         else
 638             ret = COMPLEXREGION;
 639         XUnionRectWithRegion( &rect, rgnObj->xrgn, rgnObj->xrgn );
 640 done:
 641         GDI_HEAP_UNLOCK( hRgn );
 642     }
 643     return ret;
 644 }
 645
 646
 647 /***********************************************************************
 648  *           REGION_CreateFrameRgn
 649  *
 650  * Create a region that is a frame around another region
 651  */
 652 BOOL32 REGION_FrameRgn( HRGN32 hDest, HRGN32 hSrc, INT32 x, INT32 y )
 653 {
 654     BOOL32 bRet;
 655     RGNOBJ *srcObj = (RGNOBJ*) GDI_GetObjPtr( hSrc, REGION_MAGIC );
 656
 657     if (srcObj->xrgn)
 658     {
 659         RGNOBJ* destObj = (RGNOBJ*) GDI_GetObjPtr( hDest, REGION_MAGIC );
 660         Region  resRgn;
 661
 662         REGION_CopyRegion( srcObj, destObj );
 663         XShrinkRegion( destObj->xrgn, -x, -y );
 664         resRgn = XCreateRegion();
 665         XSubtractRegion( destObj->xrgn, srcObj->xrgn, resRgn );
 666         XDestroyRegion( destObj->xrgn );
 667         destObj->xrgn = resRgn;
 668         GDI_HEAP_UNLOCK( hDest );
 669         bRet = TRUE;
 670     }
 671     else
 672         bRet = FALSE;
 673     GDI_HEAP_UNLOCK( hSrc );
 674     return bRet;
 675 }
 676
 677
 678 /***********************************************************************
 679  *           CombineRgn16    (GDI.451)
 680  */
 681 INT16 WINAPI CombineRgn16(HRGN16 hDest, HRGN16 hSrc1, HRGN16 hSrc2, INT16 mode)
 682 {
 683     return (INT16)CombineRgn32( hDest, hSrc1, hSrc2, mode );
 684 }
 685
 686
 687 /***********************************************************************
 688  *           CombineRgn32   (GDI32.19)
 689  *
 690  * Note: The behavior is correct even if src and dest regions are the same.
 691  */
 692 INT32 WINAPI CombineRgn32(HRGN32 hDest, HRGN32 hSrc1, HRGN32 hSrc2, INT32 mode)
 693 {
 694     RGNOBJ *destObj = (RGNOBJ *) GDI_GetObjPtr( hDest, REGION_MAGIC);
 695     INT32 result = ERROR;
 696
 697     dprintf_region(stddeb, "CombineRgn: %04x,%04x -> %04x mode=%x\n",
 698                    hSrc1, hSrc2, hDest, mode );
 699     if (destObj)
 700     {
 701         RGNOBJ *src1Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc1, REGION_MAGIC);
 702
 703         if (src1Obj)
 704         {
 705             if (mode == RGN_COPY)
 706                 result = REGION_CopyRegion( src1Obj, destObj );
 707             else
 708             {
 709                 RGNOBJ *src2Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc2, REGION_MAGIC);
 710
 711                 if (src2Obj)
 712                 {
 713                     if (!src1Obj->xrgn || !src2Obj->xrgn)
 714                     {
 715                         /* Some optimizations for null regions */
 716                         switch( mode )
 717                         {
 718                             case RGN_DIFF:
 719                                  if (src1Obj->xrgn)
 720                                  {
 721                                      result = REGION_CopyRegion( src1Obj, destObj );
 722                                      break;
 723                                  }
 724                                  /* else fall through */
 725                             case RGN_AND:
 726                                  if (destObj->xrgn)
 727                                  {
 728                                      XDestroyRegion( destObj->xrgn );
 729                                      destObj->xrgn = 0;
 730                                  }
 731                                  result = NULLREGION;
 732                                  break;
 733
 734                             case RGN_OR:
 735                             case RGN_XOR:
 736 #define __SRC_RGN ((src1Obj->xrgn) ? src1Obj : src2Obj)
 737                                  result = REGION_CopyRegion( __SRC_RGN, destObj );
 738 #undef  __SRC_RGN
 739                                  break;
 740
 741                             case 0:
 742                             default:
 743                                  /* makes gcc generate more efficient code */
 744                         }
 745                     }
 746                     else /* both regions are present */
 747                     {
 748                         Region  destRgn = XCreateRegion();
 749
 750                         if (destRgn)
 751                         {
 752                             switch (mode)
 753                             {
 754                                 case RGN_AND:
 755                                      XIntersectRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
 756                                      break;
 757                                 case RGN_OR:
 758                                      XUnionRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
 759                                      break;
 760                                 case RGN_XOR:
 761                                      XXorRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
 762                                      break;
 763                                 case RGN_DIFF:
 764                                      XSubtractRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
 765                                      break;
 766
 767                                 case 0: /* makes gcc generate more efficient code */
 768                                 default:
 769                                      XDestroyRegion( destRgn );
 770                                      goto done;
 771                             }
 772
 773                             if ( destObj->xrgn )
 774                                  XDestroyRegion( destObj->xrgn );
 775                             if ( XEmptyRegion( destRgn ) )
 776                             {
 777                                  XDestroyRegion( destRgn );
 778                                  destObj->xrgn = 0;
 779                                  result = NULLREGION;
 780                             }
 781                             else
 782                             {
 783                                  destObj->xrgn = destRgn;
 784                                  result = COMPLEXREGION;
 785                             }
 786                         }
 787                     }
 788 done:
 789                     GDI_HEAP_UNLOCK( hSrc2 );
 790                 }
 791             }
 792             GDI_HEAP_UNLOCK( hSrc1 );
 793         }
 794         GDI_HEAP_UNLOCK( hDest );
 795     }
 796     return result;
 797 }
 798