Pileus Git - ~andy/gtk/blob - gdk/x11/gdkregion-x11.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <X11/Xlib.h>
  21 #include <X11/Xutil.h>
  22 #include "gdk.h"
  23 #include "gdkprivate.h"
  24
  25
  26
  27
  28 GdkRegion*
  29 gdk_region_new (void)
  30 {
  31   GdkRegionPrivate *private;
  32   GdkRegion *region;
  33   Region xregion;
  34
  35   xregion = XCreateRegion();
  36   private = g_new (GdkRegionPrivate, 1);
  37   private->xregion = xregion;
  38   region = (GdkRegion*) private;
  39   region->user_data = NULL;
  40
  41   return region;
  42 }
  43
  44 void
  45 gdk_region_destroy (GdkRegion *region)
  46 {
  47   GdkRegionPrivate *private;
  48
  49   g_return_if_fail (region != NULL);
  50
  51   private = (GdkRegionPrivate *) region;
  52   XDestroyRegion (private->xregion);
  53
  54   g_free (private);
  55 }
  56
  57 gboolean
  58 gdk_region_empty (GdkRegion      *region)
  59 {
  60   GdkRegionPrivate *private;
  61
  62   g_return_val_if_fail (region != NULL, 0);
  63
  64   private = (GdkRegionPrivate *) region;
  65
  66   return XEmptyRegion (private->xregion);
  67 }
  68
  69 gboolean
  70 gdk_region_equal (GdkRegion      *region1,
  71                   GdkRegion      *region2)
  72 {
  73   GdkRegionPrivate *private1;
  74   GdkRegionPrivate *private2;
  75
  76   g_return_val_if_fail (region1 != NULL, 0);
  77   g_return_val_if_fail (region2 != NULL, 0);
  78
  79   private1 = (GdkRegionPrivate *) region1;
  80   private2 = (GdkRegionPrivate *) region2;
  81
  82   return XEqualRegion (private1->xregion, private2->xregion);
  83 }
  84
  85 void
  86 gdk_region_get_clipbox(GdkRegion    *region,
  87                        GdkRectangle *rectangle)
  88 {
  89         GdkRegionPrivate *rp;
  90         XRectangle r;
  91
  92         g_return_if_fail(region != NULL);
  93         g_return_if_fail(rectangle != NULL);
  94
  95         rp = (GdkRegionPrivate *)region;
  96         XClipBox(rp->xregion, &r);
  97
  98         rectangle->x = r.x;
  99         rectangle->y = r.y;
 100         rectangle->width = r.width;
 101         rectangle->height = r.height;
 102 }
 103
 104 gboolean
 105 gdk_region_point_in (GdkRegion      *region,
 106                      gint           x,
 107                      gint           y)
 108 {
 109   GdkRegionPrivate *private;
 110
 111   g_return_val_if_fail (region != NULL, 0);
 112
 113   private = (GdkRegionPrivate *) region;
 114
 115   return XPointInRegion (private->xregion, x, y);
 116 }
 117
 118 GdkOverlapType
 119 gdk_region_rect_in (GdkRegion      *region,
 120                     GdkRectangle   *rect)
 121 {
 122   GdkRegionPrivate *private;
 123   int res;
 124
 125   g_return_val_if_fail (region != NULL, 0);
 126
 127   private = (GdkRegionPrivate *) region;
 128
 129   res = XRectInRegion (private->xregion, rect->x, rect->y, rect->width, rect->height);
 130
 131   switch (res)
 132   {
 133     case RectangleIn:   return GDK_OVERLAP_RECTANGLE_IN;
 134     case RectangleOut:  return GDK_OVERLAP_RECTANGLE_OUT;
 135     case RectanglePart: return GDK_OVERLAP_RECTANGLE_PART;
 136   }
 137
 138   return GDK_OVERLAP_RECTANGLE_OUT;  /*what else ? */
 139 }
 140
 141 GdkRegion *
 142 gdk_region_polygon (GdkPoint    *points,
 143                     gint         npoints,
 144                     GdkFillRule  fill_rule)
 145 {
 146   GdkRegionPrivate *private;
 147   GdkRegion *region;
 148   Region xregion;
 149   gint xfill_rule = EvenOddRule;
 150
 151   g_return_val_if_fail (points != NULL, NULL);
 152   g_return_val_if_fail (npoints != 0, NULL); /* maybe we should check for at least three points */
 153
 154   switch (fill_rule)
 155     {
 156     case GDK_EVEN_ODD_RULE:
 157       xfill_rule = EvenOddRule;
 158       break;
 159
 160     case GDK_WINDING_RULE:
 161       xfill_rule = WindingRule;
 162       break;
 163     }
 164
 165   xregion = XPolygonRegion ((XPoint *) points, npoints, xfill_rule);
 166   private = g_new (GdkRegionPrivate, 1);
 167   private->xregion = xregion;
 168   region = (GdkRegion *) private;
 169   region->user_data = NULL;
 170
 171   return region;
 172 }
 173
 174 void
 175 gdk_region_offset (GdkRegion      *region,
 176                    gint           dx,
 177                    gint           dy)
 178 {
 179   GdkRegionPrivate *private;
 180
 181   g_return_if_fail (region != NULL);
 182
 183   private = (GdkRegionPrivate *) region;
 184
 185   XOffsetRegion (private->xregion, dx, dy);
 186 }
 187
 188 void
 189 gdk_region_shrink (GdkRegion      *region,
 190                    gint           dx,
 191                    gint           dy)
 192 {
 193   GdkRegionPrivate *private;
 194
 195   g_return_if_fail (region != NULL);
 196
 197   private = (GdkRegionPrivate *) region;
 198
 199   XShrinkRegion (private->xregion, dx, dy);
 200 }
 201
 202 GdkRegion*
 203 gdk_region_union_with_rect (GdkRegion      *region,
 204                             GdkRectangle   *rect)
 205 {
 206   GdkRegionPrivate *private;
 207   GdkRegion *res;
 208   GdkRegionPrivate *res_private;
 209   XRectangle xrect;
 210
 211   g_return_val_if_fail (region != NULL, NULL);
 212
 213   private = (GdkRegionPrivate *) region;
 214
 215   xrect.x = rect->x;
 216   xrect.y = rect->y;
 217   xrect.width = rect->width;
 218   xrect.height = rect->height;
 219
 220   res = gdk_region_new ();
 221   res_private = (GdkRegionPrivate *) res;
 222
 223   XUnionRectWithRegion (&xrect, private->xregion, res_private->xregion);
 224
 225   return res;
 226 }
 227
 228 GdkRegion*
 229 gdk_regions_intersect (GdkRegion      *source1,
 230                        GdkRegion      *source2)
 231 {
 232   GdkRegionPrivate *private1;
 233   GdkRegionPrivate *private2;
 234   GdkRegion *res;
 235   GdkRegionPrivate *res_private;
 236
 237   g_return_val_if_fail (source1 != NULL, NULL);
 238   g_return_val_if_fail (source2 != NULL, NULL);
 239
 240   private1 = (GdkRegionPrivate *) source1;
 241   private2 = (GdkRegionPrivate *) source2;
 242
 243   res = gdk_region_new ();
 244   res_private = (GdkRegionPrivate *) res;
 245
 246   XIntersectRegion (private1->xregion, private2->xregion, res_private->xregion);
 247
 248   return res;
 249 }
 250
 251 GdkRegion*
 252 gdk_regions_union (GdkRegion      *source1,
 253                    GdkRegion      *source2)
 254 {
 255   GdkRegionPrivate *private1;
 256   GdkRegionPrivate *private2;
 257   GdkRegion *res;
 258   GdkRegionPrivate *res_private;
 259
 260   g_return_val_if_fail (source1 != NULL, NULL);
 261   g_return_val_if_fail (source2 != NULL, NULL);
 262
 263   private1 = (GdkRegionPrivate *) source1;
 264   private2 = (GdkRegionPrivate *) source2;
 265
 266   res = gdk_region_new ();
 267   res_private = (GdkRegionPrivate *) res;
 268
 269   XUnionRegion (private1->xregion, private2->xregion, res_private->xregion);
 270
 271   return res;
 272 }
 273
 274 GdkRegion*
 275 gdk_regions_subtract (GdkRegion      *source1,
 276                       GdkRegion      *source2)
 277 {
 278   GdkRegionPrivate *private1;
 279   GdkRegionPrivate *private2;
 280   GdkRegion *res;
 281   GdkRegionPrivate *res_private;
 282
 283   g_return_val_if_fail (source1 != NULL, NULL);
 284   g_return_val_if_fail (source2 != NULL, NULL);
 285
 286   private1 = (GdkRegionPrivate *) source1;
 287   private2 = (GdkRegionPrivate *) source2;
 288
 289   res = gdk_region_new ();
 290   res_private = (GdkRegionPrivate *) res;
 291
 292   XSubtractRegion (private1->xregion, private2->xregion, res_private->xregion);
 293
 294   return res;
 295 }
 296
 297 GdkRegion*
 298 gdk_regions_xor (GdkRegion      *source1,
 299                  GdkRegion      *source2)
 300 {
 301   GdkRegionPrivate *private1;
 302   GdkRegionPrivate *private2;
 303   GdkRegion *res;
 304   GdkRegionPrivate *res_private;
 305
 306   g_return_val_if_fail (source1 != NULL, NULL);
 307   g_return_val_if_fail (source2 != NULL, NULL);
 308
 309   private1 = (GdkRegionPrivate *) source1;
 310   private2 = (GdkRegionPrivate *) source2;
 311
 312   res = gdk_region_new ();
 313   res_private = (GdkRegionPrivate *) res;
 314
 315   XXorRegion (private1->xregion, private2->xregion, res_private->xregion);
 316
 317   return res;
 318 }
 319
 320
 321