Pileus Git - ~andy/gtk/blob - gdk/gdkregion.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 Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <X11/Xlib.h>
  20 #include <X11/Xutil.h>
  21 #include "gdk.h"
  22 #include "gdkprivate.h"
  23
  24
  25
  26
  27 GdkRegion*
  28 gdk_region_new (void)
  29 {
  30   GdkRegionPrivate *private;
  31   GdkRegion *region;
  32   Region xregion;
  33
  34   xregion = XCreateRegion();
  35   private = g_new (GdkRegionPrivate, 1);
  36   private->xregion = xregion;
  37   region = (GdkRegion*) private;
  38   region->user_data = NULL;
  39
  40   return region;
  41 }
  42
  43 void
  44 gdk_region_destroy (GdkRegion *region)
  45 {
  46   GdkRegionPrivate *private;
  47
  48   g_return_if_fail (region != NULL);
  49
  50   private = (GdkRegionPrivate *) region;
  51   XDestroyRegion (private->xregion);
  52
  53   g_free (private);
  54 }
  55
  56 gboolean
  57 gdk_region_empty (GdkRegion      *region)
  58 {
  59   GdkRegionPrivate *private;
  60
  61   g_return_val_if_fail (region != NULL, 0);
  62
  63   private = (GdkRegionPrivate *) region;
  64
  65   return XEmptyRegion (private->xregion);
  66 }
  67
  68 gboolean
  69 gdk_region_equal (GdkRegion      *region1,
  70                   GdkRegion      *region2)
  71 {
  72   GdkRegionPrivate *private1;
  73   GdkRegionPrivate *private2;
  74
  75   g_return_val_if_fail (region1 != NULL, 0);
  76   g_return_val_if_fail (region2 != NULL, 0);
  77
  78   private1 = (GdkRegionPrivate *) region1;
  79   private2 = (GdkRegionPrivate *) region2;
  80
  81   return XEqualRegion (private1->xregion, private2->xregion);
  82 }
  83
  84 gboolean
  85 gdk_region_point_in (GdkRegion      *region,
  86                      gint           x,
  87                      gint           y)
  88 {
  89   GdkRegionPrivate *private;
  90
  91   g_return_val_if_fail (region != NULL, 0);
  92
  93   private = (GdkRegionPrivate *) region;
  94
  95   return XPointInRegion (private->xregion, x, y);
  96 }
  97
  98 GdkOverlapType
  99 gdk_region_rect_in (GdkRegion      *region,
 100                     GdkRectangle   *rect)
 101 {
 102   GdkRegionPrivate *private;
 103   int res;
 104
 105   g_return_val_if_fail (region != NULL, 0);
 106
 107   private = (GdkRegionPrivate *) region;
 108
 109   res = XRectInRegion (private->xregion, rect->x, rect->y, rect->width, rect->height);
 110
 111   switch (res)
 112   {
 113     case RectangleIn:   return GDK_OVERLAP_RECTANGLE_IN;
 114     case RectangleOut:  return GDK_OVERLAP_RECTANGLE_OUT;
 115     case RectanglePart: return GDK_OVERLAP_RECTANGLE_PART;
 116   }
 117
 118   return GDK_OVERLAP_RECTANGLE_OUT;  /*what else ? */
 119 }
 120
 121 void
 122 gdk_region_offset (GdkRegion      *region,
 123                    gint           dx,
 124                    gint           dy)
 125 {
 126   GdkRegionPrivate *private;
 127
 128   g_return_if_fail (region != NULL);
 129
 130   private = (GdkRegionPrivate *) region;
 131
 132   XOffsetRegion (private->xregion, dx, dy);
 133 }
 134
 135 void
 136 gdk_region_shrink (GdkRegion      *region,
 137                    gint           dx,
 138                    gint           dy)
 139 {
 140   GdkRegionPrivate *private;
 141
 142   g_return_if_fail (region != NULL);
 143
 144   private = (GdkRegionPrivate *) region;
 145
 146   XShrinkRegion (private->xregion, dx, dy);
 147 }
 148
 149 GdkRegion*
 150 gdk_region_union_with_rect (GdkRegion      *region,
 151                             GdkRectangle   *rect)
 152 {
 153   GdkRegionPrivate *private;
 154   GdkRegion *res;
 155   GdkRegionPrivate *res_private;
 156   XRectangle xrect;
 157
 158   g_return_val_if_fail (region != NULL, NULL);
 159
 160   private = (GdkRegionPrivate *) region;
 161
 162   xrect.x = rect->x;
 163   xrect.y = rect->y;
 164   xrect.width = rect->width;
 165   xrect.height = rect->height;
 166
 167   res = gdk_region_new ();
 168   res_private = (GdkRegionPrivate *) res;
 169
 170   XUnionRectWithRegion (&xrect, private->xregion, res_private->xregion);
 171
 172   return res;
 173 }
 174
 175 GdkRegion*
 176 gdk_regions_intersect (GdkRegion      *source1,
 177                        GdkRegion      *source2)
 178 {
 179   GdkRegionPrivate *private1;
 180   GdkRegionPrivate *private2;
 181   GdkRegion *res;
 182   GdkRegionPrivate *res_private;
 183
 184   g_return_val_if_fail (source1 != NULL, NULL);
 185   g_return_val_if_fail (source2 != NULL, NULL);
 186
 187   private1 = (GdkRegionPrivate *) source1;
 188   private2 = (GdkRegionPrivate *) source2;
 189
 190   res = gdk_region_new ();
 191   res_private = (GdkRegionPrivate *) res;
 192
 193   XIntersectRegion (private1->xregion, private2->xregion, res_private->xregion);
 194
 195   return res;
 196 }
 197
 198 GdkRegion*
 199 gdk_regions_union (GdkRegion      *source1,
 200                    GdkRegion      *source2)
 201 {
 202   GdkRegionPrivate *private1;
 203   GdkRegionPrivate *private2;
 204   GdkRegion *res;
 205   GdkRegionPrivate *res_private;
 206
 207   g_return_val_if_fail (source1 != NULL, NULL);
 208   g_return_val_if_fail (source2 != NULL, NULL);
 209
 210   private1 = (GdkRegionPrivate *) source1;
 211   private2 = (GdkRegionPrivate *) source2;
 212
 213   res = gdk_region_new ();
 214   res_private = (GdkRegionPrivate *) res;
 215
 216   XUnionRegion (private1->xregion, private2->xregion, res_private->xregion);
 217
 218   return res;
 219 }
 220
 221 GdkRegion*
 222 gdk_regions_subtract (GdkRegion      *source1,
 223                       GdkRegion      *source2)
 224 {
 225   GdkRegionPrivate *private1;
 226   GdkRegionPrivate *private2;
 227   GdkRegion *res;
 228   GdkRegionPrivate *res_private;
 229
 230   g_return_val_if_fail (source1 != NULL, NULL);
 231   g_return_val_if_fail (source2 != NULL, NULL);
 232
 233   private1 = (GdkRegionPrivate *) source1;
 234   private2 = (GdkRegionPrivate *) source2;
 235
 236   res = gdk_region_new ();
 237   res_private = (GdkRegionPrivate *) res;
 238
 239   XSubtractRegion (private1->xregion, private2->xregion, res_private->xregion);
 240
 241   return res;
 242 }
 243
 244 GdkRegion*
 245 gdk_regions_xor (GdkRegion      *source1,
 246                  GdkRegion      *source2)
 247 {
 248   GdkRegionPrivate *private1;
 249   GdkRegionPrivate *private2;
 250   GdkRegion *res;
 251   GdkRegionPrivate *res_private;
 252
 253   g_return_val_if_fail (source1 != NULL, NULL);
 254   g_return_val_if_fail (source2 != NULL, NULL);
 255
 256   private1 = (GdkRegionPrivate *) source1;
 257   private2 = (GdkRegionPrivate *) source2;
 258
 259   res = gdk_region_new ();
 260   res_private = (GdkRegionPrivate *) res;
 261
 262   XXorRegion (private1->xregion, private2->xregion, res_private->xregion);
 263
 264   return res;
 265 }
 266
 267
 268