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

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