Partie Bezier de curve

1 files changed, 1138 insertions, 0 deletions

diff --git a/Bezier.c b/Bezier.c
new file mode 100644
index 0000000..b966593
--- /dev/null
+++ b/Bezier.c
@@ -0,0 +1,1138 @@
+/*
+ * Bezier.c -- Implementation of bezier item.
+ *
+ * Authors		: Patrick Lecoanet.
+ * Creation date	: Fri May  5 12:33:32 2000
+ *
+ * $Id$
+ */
+
+/*
+ *  Copyright (c) 1993 - 2000 CENA, Patrick Lecoanet --
+ *
+ * This code is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This code is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this code; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+
+#include "Draw.h"
+#include "Item.h"
+#include "Geo.h"
+#include "Types.h"
+#include "WidgetInfo.h"
+#include "Image.h"
+#include "Color.h"
+
+#include <ctype.h>
+#include <malloc.h>
+
+
+static const char rcsid[] = "$Id$";
+static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $";
+
+
+/*
+ * Bit offset of flags.
+ */
+#define	FILLED_BIT	1<<0	/* If the item is filled with color/pattern */
+#define CLOSED_BIT	1<<1	/* If the item should be closed */
+#define CCW		1<<2	/* Tell if the controls are described in
+				 * clockwise or ccw order. */
+#define FIRST_END_OK	1<<3
+#define LAST_END_OK	1<<4
+#define FILLED_OK	1<<5
+#define RELIEF_OK	1<<6
+
+
+/*
+ **********************************************************************************
+ *
+ * Specific Bezier item record
+ *
+ **********************************************************************************
+ */
+typedef struct _BezierItemStruct {
+  ItemStruct	header;
+
+  /* Public data */
+  ZnList	points;
+  unsigned int	flags;
+  ZnLineEnd	first_end;	/* These two are considered only if relief is flat */
+  ZnLineEnd	last_end;
+  LineStyle	line_style;	/* This is considered only if relief is flat */
+  int		cap_style;
+  ReliefStyle	relief;
+  int		line_width;	/* If 0 the path is not drawn, if <2 relief is flat */
+  Pixmap	fill_pattern;
+  ZnColorGradient fill_color;
+  ZnGradientGeom  grad_geom;
+  Pixmap	line_pattern;
+  ZnColor	line_color;
+  char		*tile_name;
+  
+  /* Private data */
+  ZnImage	tile;
+  ZnList	dev_points;
+  ZnColorGradient gradient;
+} BezierItemStruct, *BezierItem;
+
+
+static ZnAttrConfig	bz_attrs[] = {
+  { ZN_CONFIG_CAP_STYLE, "-capstyle", NULL,
+    Tk_Offset(BezierItemStruct, cap_style), 0,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-composerotation", NULL,
+    Tk_Offset(BezierItemStruct, header.flags), COMPOSE_ROTATION_BIT,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-composescale", NULL,
+    Tk_Offset(BezierItemStruct, header.flags), COMPOSE_SCALE_BIT,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_GRADIENT_COLOR, "-fillcolor", NULL,
+    Tk_Offset(BezierItemStruct, fill_color), 0,
+    ZN_DRAW_FLAG|ZN_BORDER_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-fillpattern", NULL,
+    Tk_Offset(BezierItemStruct, fill_pattern), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-filled", NULL,
+    Tk_Offset(BezierItemStruct, flags), FILLED_BIT, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_LINE_END, "-firstend", NULL,
+    Tk_Offset(BezierItemStruct, first_end), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_GRADIENT_GEOM, "-gradient", NULL,
+    Tk_Offset(BezierItemStruct, grad_geom), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_LINE_END, "-lastend", NULL,
+    Tk_Offset(BezierItemStruct, last_end), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-linecolor", NULL,
+    Tk_Offset(BezierItemStruct, line_color), 0,
+    ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-linepattern", NULL,
+    Tk_Offset(BezierItemStruct, line_pattern), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-linestyle", NULL,
+    Tk_Offset(BezierItemStruct, line_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_DIM, "-linewidth", NULL,
+    Tk_Offset(BezierItemStruct, line_width), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_PRI, "-priority", NULL,
+    Tk_Offset(BezierItemStruct, header.priority), 0,
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_RELIEF, "-relief", NULL, Tk_Offset(BezierItemStruct, relief), 0,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(BezierItemStruct, header.flags), SENSITIVE_BIT,
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_TAGS, "-tags", NULL,
+    Tk_Offset(BezierItemStruct, header.tags), 0, 0, False },
+  { ZN_CONFIG_IMAGE, "-tile", NULL,
+    Tk_Offset(BezierItemStruct, tile_name), 0,
+    ZN_DRAW_FLAG|ZN_TILE_FLAG, False },
+  { ZN_CONFIG_BOOL, "-visible", NULL,
+    Tk_Offset(BezierItemStruct, header.flags), VISIBLE_BIT,
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG|ZN_VIS_FLAG, False },
+  
+  { ZN_CONFIG_END, NULL, NULL, 0, 0, 0 }
+};
+
+
+/*
+ **********************************************************************************
+ *
+ * BzTileChange --
+ *
+ **********************************************************************************
+ */
+static void
+BzTileChange(ClientData	client_data,
+	     int	x,
+	     int	y,
+	     int	width,
+	     int	height,
+	     int	image_width,
+	     int	image_height)
+{
+  BezierItem	bz = (BezierItem) client_data;
+
+  InvalidateImage(bz->tile_name);
+  ITEM.Invalidate((Item) bz, ZN_COORDS_FLAG);
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Init --
+ *
+ **********************************************************************************
+ */
+static int
+Init(Item	item,
+     int	*argc,
+     Arg	**args)
+{
+  WidgetInfo	*wi = item->wi;
+  BezierItem	bz = (BezierItem) item;
+  Arg		*elems;
+  int		i, result, num_elems;
+  ZnPoint	p;
+#ifdef PTK
+  LangFreeProc *freeProc = NULL;
+#endif
+
+  bz->dev_points = NULL;
+  bz->gradient = NULL;
+
+  /* Init attributes */
+  SET(item->flags, VISIBLE_BIT);
+  SET(item->flags, SENSITIVE_BIT);
+  SET(item->flags, COMPOSE_ROTATION_BIT);
+  SET(item->flags, COMPOSE_SCALE_BIT);
+  item->priority = DEFAULT_BEZIER_PRIORITY;
+
+  if (*argc < 1) {
+    Tcl_AppendResult(wi->interp, " bezier coords expected", NULL);
+    return ZN_ERROR;
+  }
+  result = Lang_SplitList(wi->interp, (*args)[0], &num_elems, &elems, &freeProc);
+  if ((result == ZN_ERROR) || ((num_elems%2) != 0)) {
+  bz_error:
+#ifdef PTK
+    if (elems != NULL && freeProc) {
+      (*freeProc)(num_elems, elems);
+    }
+#endif
+    Tcl_AppendResult(wi->interp, " malformed bezier coords", NULL);
+    return ZN_ERROR;
+  }
+
+  bz->points = ZnListNew(num_elems/2, sizeof(ZnPoint));
+  for (i = 0; i < num_elems; i += 2) {
+    if (Tcl_GetDouble(wi->interp, elems[i], &p.x) == ZN_ERROR) {
+    bz_error2:
+#ifndef PTK
+      Tcl_Free((char *) elems);
+#endif
+      ZnListFree(bz->points);
+      bz->points = NULL;
+      goto bz_error;
+    }
+    if (Tcl_GetDouble(wi->interp, elems[i+1], &p.y) == ZN_ERROR) {
+      goto bz_error2;
+    }
+    ZnListAdd(bz->points, &p, ZnListTail);
+  }
+  (*args)++;
+  (*argc)--;
+#ifndef PTK
+  Tcl_Free((char *) elems);
+#else
+  if (freeProc) {
+    (*freeProc)(num_elems, elems);
+  }
+#endif
+ 
+  CLEAR(bz->flags, FILLED_BIT);
+  bz->first_end = NULL;
+  bz->last_end = NULL;
+  bz->line_style = LINE_SIMPLE;
+  bz->relief = RELIEF_FLAT;
+  bz->line_width = 1;
+  bz->tile_name = "";
+  bz->tile = ZnUnspecifiedImage;
+  bz->fill_pattern = ZnUnspecifiedPattern;
+  bz->line_pattern = ZnUnspecifiedPattern;
+  bz->cap_style = CapRound;
+  
+  bz->fill_color = ZnGetColorGradient(wi->interp, wi->win,
+				      ZnNameOfColor(wi->fore_color));
+  bz->line_color = ZnGetColorByValue(wi->win, wi->fore_color);
+  bz->grad_geom = NULL;
+
+  return ZN_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Clone --
+ *
+ **********************************************************************************
+ */
+static void
+Clone(Item	item)
+{
+  BezierItem	bz = (BezierItem) item;
+  WidgetInfo	*wi = item->wi;
+  char		*text;
+  
+  bz->dev_points = NULL;
+
+  if (bz->gradient) {
+    bz->gradient = ZnGetColorGradientByValue(bz->gradient);
+  }
+  if (bz->points) {
+    bz->points = ZnListDuplicate(bz->points);
+  }
+  if (bz->line_pattern != ZnUnspecifiedPattern) {
+    bz->line_pattern = Tk_GetBitmap(wi->interp, wi->win,
+				    Tk_NameOfBitmap(wi->dpy, bz->line_pattern));
+  }
+  if (bz->first_end) {
+    LineEndDuplicate(bz->first_end);
+  }
+  if (bz->last_end) {
+    LineEndDuplicate(bz->last_end);
+  }
+  if (strlen(bz->tile_name) != 0) {
+    text = ZnMalloc((strlen(bz->tile_name) + 1) * sizeof(char));
+    strcpy(text, bz->tile_name);
+    bz->tile_name = text;
+    bz->tile = Tk_GetImage(wi->interp, wi->win, bz->tile_name,
+			   BzTileChange, (ClientData) bz);
+  }
+  if (bz->fill_pattern != ZnUnspecifiedPattern) {
+    bz->fill_pattern = Tk_GetBitmap(wi->interp, wi->win,
+				    Tk_NameOfBitmap(wi->dpy, bz->fill_pattern));
+  }
+  bz->line_color = ZnGetColorByValue(wi->win, bz->line_color);
+  bz->fill_color = ZnGetColorGradientByValue(bz->fill_color);
+  if (bz->grad_geom) {
+    bz->grad_geom = GradientGeomDuplicate(bz->grad_geom);
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Destroy --
+ *
+ **********************************************************************************
+ */
+static void
+Destroy(Item	item)
+{
+  WidgetInfo	*wi = item->wi;
+  BezierItem	bz = (BezierItem) item;
+
+  if (bz->points) {
+    ZnListFree(bz->points);
+  }
+  if (bz->dev_points) {
+    ZnListFree(bz->dev_points);
+  }
+  if (bz->first_end) {
+    LineEndDelete(bz->first_end);
+  }
+  if (bz->last_end) {
+    LineEndDelete(bz->last_end);
+  }
+  if (bz->gradient) {
+    ZnFreeColorGradient(bz->gradient);
+  }
+  if (bz->tile != ZnUnspecifiedImage) {
+    Tk_FreeImage(bz->tile);
+    bz->tile = ZnUnspecifiedImage;
+  }
+  if (strlen(bz->tile_name) != 0) {
+    ZnFree(bz->tile_name);
+  }
+  if (bz->line_pattern != ZnUnspecifiedPattern) {
+    Tk_FreeBitmap(wi->dpy, bz->line_pattern);
+  }
+  if (bz->fill_pattern != ZnUnspecifiedPattern) {
+    Tk_FreeBitmap(wi->dpy, bz->fill_pattern);
+  }
+  ZnFreeColorGradient(bz->fill_color);
+  ZnFreeColor(bz->line_color);
+  if (bz->grad_geom) {
+    GradientGeomDelete(bz->grad_geom);
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Setup flags to control the precedence between the
+ * graphical attributes.
+ *
+ **********************************************************************************
+ */
+static void
+SetRenderFlags(BezierItem	bz)
+{
+  ASSIGN(bz->flags, FILLED_OK,
+	 ISSET(bz->flags, FILLED_BIT) && (ZnListSize(bz->points) > 2));
+
+  ASSIGN(bz->flags, RELIEF_OK,
+	 (bz->relief != RELIEF_FLAT) && (ZnListSize(bz->points) > 1) &&
+	 (bz->line_width > 1));
+
+  ASSIGN(bz->flags, FIRST_END_OK,
+	 (bz->first_end != NULL) && (ZnListSize(bz->points) > 1) &&
+	 ISCLEAR(bz->flags, FILLED_BIT) && bz->line_width &&
+	 ISCLEAR(bz->flags, RELIEF_OK));
+
+  ASSIGN(bz->flags, LAST_END_OK,
+	 (bz->last_end != NULL) && (ZnListSize(bz->points) > 1) &&
+	 ISCLEAR(bz->flags, FILLED_BIT) && bz->line_width &&
+	 ISCLEAR(bz->flags, RELIEF_OK));
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Configure --
+ *
+ **********************************************************************************
+ */
+static int
+Configure(Item		item,
+	  int		argc,
+	  ZnAttrList	argv,
+	  int		*flags)
+{
+  WidgetInfo	*wi = item->wi;
+  BezierItem	bz = (BezierItem) item;
+  int		status = ZN_OK;
+  
+  status = ITEM_P.ConfigureAttributes((char *) item, -1, argc, argv, flags);
+
+  if (bz->gradient &&
+      (ISSET(*flags, ZN_BORDER_FLAG) || (bz->relief == RELIEF_FLAT))) {
+    ZnFreeColorGradient(bz->gradient);
+    bz->gradient = NULL;
+  }
+  if ((bz->relief != RELIEF_FLAT) && !bz->gradient) {
+    bz->gradient = ZnGetReliefGradient(wi->interp, wi->win,
+				       ZnNameOfColor(ZnColorGradientMidColor(wi->win, bz->fill_color)));
+  }
+  if (ISSET(*flags, ZN_TILE_FLAG)) {
+    Tk_Image	tile;
+
+    if (strcmp(bz->tile_name, "") != 0) {
+      tile = Tk_GetImage(wi->interp, wi->win, bz->tile_name,
+			  BzTileChange, (ClientData) bz);
+      if (tile == NULL) {
+	/*
+	 * The name will not be in sync with the image in
+	 * this case.
+	 */
+	status = ZN_ERROR;
+      }
+    }
+    else {
+      tile = ZnUnspecifiedImage;
+    }
+    if (bz->tile != ZnUnspecifiedImage) {
+      Tk_FreeImage(bz->tile);
+    }
+    bz->tile = tile;
+  }
+
+  return status;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Query --
+ *
+ **********************************************************************************
+ */
+static int
+Query(Item		item,
+      int		argc,
+      ZnAttrList	argv)
+{
+  if (ITEM_P.QueryAttribute((char *) item, -1, argv[0]) == ZN_ERROR) {
+    return ZN_ERROR;
+  }
+
+  return ZN_OK;
+}
+
+
+static ZnBool
+TestCCW(ZnPoint	*points,
+	int	num_points)
+{
+  ZnPoint	*p, *p_p, *p_n, min;
+  ZnReal	xprod;
+  int		i, min_index;
+  
+  if (num_points < 3) {
+    return True;
+  }
+
+  /*
+   * First find the lowest rightmost vertex. In X11 this is the
+   * topmost one.
+   */
+  p = points;
+  min = *p;
+  min_index = 0;
+  for (i = 1, p++; i < num_points; i++, p++) {
+    if ((p->y < min.y) ||
+	((p->y == min.y) && (p->x > min.x))) {
+      min_index = i;
+      min = *p;
+    }
+  }
+  /*
+   * Then find the indices of the previous and next
+   * vertices.
+   */
+  p = &points[min_index];
+  p_p = &points[(min_index+(num_points-1))%num_points]; /* min_index-1 */
+  p_n = &points[(min_index+1)%num_points];
+  xprod = ((p_p->x*p->y - p_p->y*p->x) +
+	   (p_p->y*p_n->x - p_p->x*p_n->y) +
+	   (p->x*p_n->y - p->y*p_n->x));
+  return (xprod <= 0.0); /* Should be >= 0 but X11 has Y axis reverted. */
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * ComputeCoordinates --
+ *
+ **********************************************************************************
+ */
+static void
+ComputeCoordinates(Item		item,
+		   ZnBool	force)
+{
+  WidgetInfo	*wi = item->wi;
+  BezierItem	bz = (BezierItem) item;
+  ZnPoint	*points;
+  ZnPoint	end_points[LINE_END_POINTS];
+  ZnPoint	*dev_points;
+  int		num_points;
+  ZnBBox	bbox;
+  int		lw;
+  
+  ResetBBox(&item->item_bounding_box);
+  if (bz->points == NULL) {
+    return;
+  }
+
+  SetRenderFlags(bz);
+
+  points = (ZnPoint *) ZnListArray(bz->points);
+  num_points = ZnListSize(bz->points);
+
+  /*
+   * Allocate space for devices coordinates
+   */
+  if (bz->dev_points == NULL) {
+    bz->dev_points = ZnListNew(num_points, sizeof(ZnPoint));
+  }
+  ZnListAssertSize(bz->dev_points, num_points);
+  dev_points = (ZnPoint *) ZnListArray(bz->dev_points);
+
+  /*
+   * Compute device coordinates.
+   */
+  ZnTransformPoints(wi->current_transfo, points, dev_points, num_points);
+
+  lw = bz->line_width;
+  
+  if (ISSET(bz->flags, RELIEF_OK)) {
+    ASSIGN(bz->flags, CCW, TestCCW(dev_points, num_points));
+
+    /*
+     * Compute the bounding box. 
+     */
+    GetPolygonReliefBBox(dev_points, num_points,
+			 ISCLEAR(bz->flags, CCW)?-lw:lw, &bbox);
+    AddBBoxToBBox(&item->item_bounding_box, &bbox);
+    return;
+  }
+  
+  /*
+   * Compute the bounding box. 
+   */
+  AddPointsToBBox(&item->item_bounding_box, dev_points, num_points);
+  
+  /*
+   * Add the line width in all directions.
+   * This overestimates the space needed to draw the polyline
+   * but is simple. This is even more true for smoothed polygons but is
+   * even faster.
+   */
+  item->item_bounding_box.orig.x -= lw;
+  item->item_bounding_box.orig.y -= lw;
+  item->item_bounding_box.corner.x += lw;
+  item->item_bounding_box.corner.y += lw;
+
+  /*
+   * Process arrows.
+   */
+  if (ISSET(bz->flags, FIRST_END_OK)) {
+    GetLineEnd(&dev_points[0], &dev_points[1], lw, bz->cap_style,
+	       bz->first_end, end_points);
+    AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+  }
+  if (ISSET(bz->flags, LAST_END_OK)) {
+    GetLineEnd(&dev_points[num_points-1], &dev_points[num_points-2],
+	       lw, bz->cap_style, bz->last_end, end_points);
+    AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+  }
+
+  /*
+   * Expand again the bounding box by one pixel in all
+   * directions to take care of rounding errors.
+   */
+  item->item_bounding_box.orig.x -= 1;
+  item->item_bounding_box.orig.y -= 1;
+  item->item_bounding_box.corner.x += 1;
+  item->item_bounding_box.corner.y += 1;
+}
+
+
+
+/*
+ **********************************************************************************
+ *
+ * ToArea --
+ *	Tell if the object is entirely outside (-1),
+ *	entirely inside (1) or in between (0).
+ *
+ **********************************************************************************
+ */
+static int
+ToArea(Item	item,
+       ZnBBox	*area,
+       Tk_Uid	tag_uid,
+       int	enclosed,
+       ZnBool	report)
+{
+  BezierItem	bz = (BezierItem) item;
+  WidgetInfo	*wi = item->wi;
+  ZnPoint	*points;
+  ZnPoint	end_points[LINE_END_POINTS];
+  int		num_points, result, result2;
+  int		lw = bz->line_width;
+
+  if (bz->dev_points == NULL) {
+    return -1;
+  }
+
+  /*printf("============== bezier %d ==============\n", item->id);*/
+  GetBezierPath(bz->dev_points, wi->work_pts);
+  points = (ZnPoint *) ZnListArray(wi->work_pts);
+  num_points = ZnListSize(wi->work_pts);
+
+  if (ISSET(bz->flags, FILLED_OK)) {
+    result = PolygonInBBox(points, num_points, area, NULL);
+    if (result == 0) {
+      return 0;
+    }
+  }
+
+  if (lw > 0) {
+    if (ISCLEAR(bz->flags, RELIEF_OK)) {
+      result2 = PolylineInBBox(points, num_points, lw,
+			       bz->cap_style, JoinRound, area);
+    }
+    else {
+      result2 = PolygonReliefInBBox(points, num_points,
+				    ISCLEAR(bz->flags, CCW)?-lw:lw, area);
+    }
+    if (ISCLEAR(bz->flags, FILLED_OK)) {
+      if (result2 == 0) {
+	return 0;
+      }
+      result = result2;
+    }
+    else if (result2 != result) {
+      return 0;
+    }
+    
+    /*
+     * Check line ends.
+     */
+    if (ISSET(bz->flags, FIRST_END_OK)) {
+      GetLineEnd(&points[0], &points[1], lw, bz->cap_style,
+		 bz->first_end, end_points);
+      if (PolygonInBBox(end_points, LINE_END_POINTS, area, NULL) != result) {
+	return 0;
+      }
+    }
+    if (ISSET(bz->flags, LAST_END_OK)) {
+      GetLineEnd(&points[num_points-1], &points[num_points-2], lw,
+		 bz->cap_style, bz->last_end, end_points);
+      if (PolygonInBBox(end_points, LINE_END_POINTS, area, NULL) != result) {
+	return 0;
+      }
+    }
+  }
+  
+  return result;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Draw --
+ *
+ **********************************************************************************
+ */
+static void
+Draw(Item	item)
+{
+  WidgetInfo	*wi = item->wi;
+  BezierItem	bz = (BezierItem) item;
+  XGCValues 	values;
+  int		i, num_points;
+  unsigned int	gc_mask;
+  ZnPoint	*points;
+  XPoint	*xpoints = NULL;
+  int		lw = bz->line_width;
+  
+  if (bz->dev_points == NULL) {
+    return;
+  }
+
+  GetBezierPath(bz->dev_points, wi->work_pts);
+  points = (ZnPoint *) ZnListArray(wi->work_pts);
+  num_points = ZnListSize(wi->work_pts);
+  
+  /*
+   * Fill if requested.
+   */
+  if (ISSET(bz->flags, FILLED_OK)) {
+    if (bz->grad_geom) {
+      ZnPoly	poly;
+      POLY_CONTOUR1(&poly, points, num_points);
+      DrawPolygonGradient(wi, bz->grad_geom, bz->fill_color, &poly,
+			  &item->item_bounding_box);
+    }
+    else {
+      values.foreground = ZnPixel(ZnColorGradientMidColor(wi->win, bz->fill_color));
+      gc_mask = GCFillStyle;
+      if (bz->tile != ZnUnspecifiedImage) { /* Fill tiled */
+	Pixmap pmap = GetImagePixmap(wi->win, bz->tile_name, bz->tile, NULL);
+	values.fill_style = FillTiled;
+	values.tile = pmap;
+	values.ts_x_origin = REAL_TO_INT(item->item_bounding_box.orig.x);
+	values.ts_y_origin = REAL_TO_INT(item->item_bounding_box.orig.y);
+	gc_mask |= GCTileStipXOrigin|GCTileStipYOrigin|GCTile;
+      }
+      else if (bz->fill_pattern != ZnUnspecifiedPattern) { /* Fill stippled */
+	values.fill_style = FillStippled;
+	values.stipple = bz->fill_pattern;
+	values.ts_x_origin = REAL_TO_INT(item->item_bounding_box.orig.x);
+	values.ts_y_origin = REAL_TO_INT(item->item_bounding_box.orig.y);
+	gc_mask |= GCTileStipXOrigin|GCTileStipYOrigin|GCStipple|GCForeground;
+      }
+      else { /* Fill solid */
+	values.fill_style = FillSolid;
+	gc_mask |= GCForeground;
+      }
+      XChangeGC(wi->dpy, wi->gc, gc_mask, &values);
+
+      if (!xpoints) {
+	ZnListAssertSize(wi->work_xpts, num_points);
+	xpoints = (XPoint *) ZnListArray(wi->work_xpts);
+	for (i = 0; i < num_points; i++) {
+	  xpoints[i].x = REAL_TO_INT(points[i].x);
+	  xpoints[i].y = REAL_TO_INT(points[i].y);
+	}
+      }
+      XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc,
+		   xpoints, num_points, Complex, CoordModeOrigin);
+    }
+  }
+  
+  /*
+   * Draw the lines between points
+   */
+  if (lw) {
+    ZnPoint end_points[LINE_END_POINTS];
+    XPoint     xp[LINE_END_POINTS];
+    
+    /*
+     * Drawing with relief disables: ends, line style and line pattern.
+     */
+    if (ISSET(bz->flags, RELIEF_OK)) {
+      DrawPolygonRelief(wi, bz->relief, bz->gradient,
+			points, num_points, ISCLEAR(bz->flags, CCW)?-lw:lw);
+    }
+    else {
+      SetLineStyle(wi->dpy, wi->gc, bz->line_style);
+      values.foreground = ZnPixel(bz->line_color);
+      values.line_width = (lw == 1) ? 0 : lw;
+      values.join_style = JoinRound;
+      values.cap_style = bz->cap_style;
+      if (bz->line_pattern == ZnUnspecifiedPattern) {
+	values.fill_style = FillSolid;
+	XChangeGC(wi->dpy, wi->gc,
+		  GCFillStyle|GCLineWidth|GCJoinStyle|GCCapStyle|GCForeground, &values);
+      }
+      else {
+	values.fill_style = FillStippled;
+	values.stipple = bz->line_pattern;
+	XChangeGC(wi->dpy, wi->gc,
+		  GCFillStyle|GCStipple|GCLineWidth|GCJoinStyle|GCCapStyle|GCForeground,
+		  &values);
+      }
+      if (!xpoints) {
+	ZnListAssertSize(wi->work_xpts, num_points);
+	xpoints = (XPoint *) ZnListArray(wi->work_xpts);
+	for (i = 0; i < num_points; i++) {
+	  xpoints[i].x = REAL_TO_INT(points[i].x);
+	  xpoints[i].y = REAL_TO_INT(points[i].y);
+	}
+      }
+      XDrawLines(wi->dpy, wi->draw_buffer, wi->gc,
+		 xpoints, num_points, CoordModeOrigin);
+      
+      if (ISSET(bz->flags, FIRST_END_OK)) {
+	GetLineEnd(&points[0], &points[1], lw, bz->cap_style,
+		   bz->first_end, end_points);
+	for (i = 0; i < LINE_END_POINTS; i++) {
+	  xp[i].x = end_points[i].x;
+	  xp[i].y = end_points[i].y;
+	}
+	XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xp, LINE_END_POINTS,
+		     Nonconvex, CoordModeOrigin);
+      }
+      if (ISSET(bz->flags, LAST_END_OK)) {
+	GetLineEnd(&points[num_points-1], &points[num_points-2], lw,
+		   bz->cap_style, bz->last_end, end_points);
+	for (i = 0; i < LINE_END_POINTS; i++) {
+	  xp[i].x = end_points[i].x;
+	  xp[i].y = end_points[i].y;
+	}
+	XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xp, LINE_END_POINTS,
+		     Nonconvex, CoordModeOrigin);
+      }
+    }
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * IsSensitive --
+ *
+ **********************************************************************************
+ */
+static ZnBool
+IsSensitive(Item	item,
+	    int		item_part)
+{
+  return (ISSET(item->flags, SENSITIVE_BIT) &&
+	  item->parent->class->IsSensitive(item->parent, ZN_NO_PART));
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Pick --
+ *
+ **********************************************************************************
+ */
+static double
+Pick(Item	item,
+     ZnPoint	*p,
+     Item	start_item,
+     int	aperture,
+     Item	*a_item,
+     int	*part)
+{
+  BezierItem	bz = (BezierItem) item;
+  WidgetInfo	*wi = item->wi;
+  double	dist=1.0e40, new_dist;
+  ZnPoint	*points;
+  ZnPoint	end_points[LINE_END_POINTS];
+  int		num_points;
+  int		lw = bz->line_width;
+
+  if (bz->dev_points == NULL) {
+    return dist;
+  }
+  
+/*printf("Pick in curve\n");*/
+  GetBezierPath(bz->dev_points, wi->work_pts);
+  points = (ZnPoint *) ZnListArray(wi->work_pts);
+  num_points = ZnListSize(wi->work_pts);
+
+  if (ISSET(bz->flags, FILLED_OK)) {
+    dist = PolygonToPointDist(points, num_points, p);
+    if (dist <= 0.0) {
+      return 0.0;
+    }
+  }
+
+  if (lw > 0) {
+    if (ISCLEAR(bz->flags, RELIEF_OK)) {
+      new_dist = PolylineToPointDist(points, num_points, lw,
+				     bz->cap_style, JoinRound, p);
+      if (new_dist < dist) {
+	dist = new_dist;
+      }
+      if (dist <= 0.0) {
+	return 0.0;
+      }
+    }
+    else {
+      new_dist = PolygonReliefToPointDist(points, num_points,
+					  ISCLEAR(bz->flags, CCW)?-lw:lw, p);
+      if (new_dist < dist) {
+	dist = new_dist;
+      }
+      if (dist <= 0.0) {
+	return 0.0;
+      }
+    }
+  }
+  
+  /*
+   * Check line ends.
+   */
+  if (ISSET(bz->flags, FIRST_END_OK)) {
+    GetLineEnd(&points[0], &points[1], lw, bz->cap_style,
+	       bz->first_end, end_points);
+    new_dist = PolygonToPointDist(end_points, LINE_END_POINTS, p);
+    if (new_dist < dist) {
+      dist = new_dist;
+    }
+    if (dist <= 0.0) {
+      return 0.0;
+    }
+  }
+  if (ISSET(bz->flags, LAST_END_OK)) {
+    GetLineEnd(&points[num_points-1], &points[num_points-2], lw,
+	       bz->cap_style, bz->last_end, end_points);
+    new_dist = PolygonToPointDist(end_points, LINE_END_POINTS, p);
+    if (new_dist < dist) {
+      dist = new_dist;
+    }
+    if (dist <= 0.0) {
+      return 0.0;
+    }
+  }
+  
+  return dist;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * PostScript --
+ *
+ **********************************************************************************
+ */
+static void
+PostScript(Item			item,
+	   PostScriptInfo	ps_info)
+{
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetClipVertices --
+ *	Get the clipping shape.
+ *
+ **********************************************************************************
+ */
+static ZnBool
+GetClipVertices(Item	item,
+		ZnPoly	*poly)
+{
+  BezierItem	bz = (BezierItem) item;
+  WidgetInfo	*wi = item->wi;
+
+  if (bz->dev_points) {
+    GetBezierPath(bz->dev_points, wi->work_pts);
+    
+    POLY_CONTOUR1(poly, (ZnPoint *) ZnListArray(wi->work_pts),
+		  ZnListSize(wi->work_pts));
+  }
+  
+  return False;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Coords --
+ *	Return or edit the item vertices.
+ *
+ **********************************************************************************
+ */
+static int
+Coords(Item	item,
+       int	contour,
+       int	index,
+       int	cmd,
+       ZnPoint	**pts,
+       int	*num_pts)
+{
+  BezierItem	bz = (BezierItem) item;
+  int		num_points, i;
+  ZnPoint	*points;
+
+  if ((cmd == COORDS_REPLACE) || (cmd == COORDS_REPLACE_ALL)) {
+    if (*num_pts == 0) {
+      Tcl_AppendResult(item->wi->interp,
+		       " coords command need at least 1 point on beziers", NULL);
+      return ZN_ERROR;
+    }
+    if (cmd == COORDS_REPLACE_ALL) {
+      ZnList	tmp;
+    replace_all:
+      tmp = ZnListFromArray(*pts, *num_pts, sizeof(ZnPoint));
+      if (!bz->points) {
+	ZnListEmpty(bz->points);
+      }
+      else {
+	bz->points = ZnListNew(*num_pts, sizeof(ZnPoint));
+      }
+      ZnListAppend(bz->points, tmp);
+      ZnListFree(tmp);
+    }
+    else {
+      if (!bz->points) {
+      edit_err:
+	Tcl_AppendResult(item->wi->interp,
+			 " coords command cannot edit empty beziers", NULL);
+	return ZN_ERROR;
+      }
+      points = ZnListArray(bz->points);
+      num_points = ZnListSize(bz->points);
+      if (index < 0) {
+	index += num_points;
+      }
+      if ((index < 0) || (index >= num_points)) {
+      range_err:
+	Tcl_AppendResult(item->wi->interp, " coord index out of range", NULL);
+	return ZN_ERROR;
+      }
+      points[index] = (*pts)[0];
+    }
+    ITEM.Invalidate(item, ZN_COORDS_FLAG);
+  }
+  else if ((cmd == COORDS_READ) || (cmd == COORDS_READ_ALL)) {
+    if (!bz->points) {
+      *num_pts = 0;
+      *pts = NULL;
+      return ZN_OK;
+    }
+    points = ZnListArray(bz->points);
+    num_points = ZnListSize(bz->points);
+    if (cmd == COORDS_READ_ALL) {
+      *num_pts = num_points;
+      *pts = points;
+    }
+    else {
+      if (index < 0) {
+	index += num_points;
+      }
+      if ((index < 0) || (index >= num_points)) {
+	goto range_err;
+      }
+      *num_pts = 1;
+      *pts = &points[index];
+    }
+  }
+  else if ((cmd == COORDS_ADD) || (cmd == COORDS_ADD_LAST)) {
+    if (!bz->points) {
+      goto replace_all;
+    }
+    else if (cmd == COORDS_ADD) {
+      num_points = ZnListSize(bz->points);
+      if (index < 0) {
+	index += num_points;
+      }
+      if ((index < 0) || (index >= num_points)) {
+	goto range_err;
+      }
+      for (i = 0; i < *num_pts; i++, index++) {
+	ZnListAdd(bz->points, &(*pts)[i], index);
+      }
+    }
+    else {
+      ZnList	tmp;
+      tmp = ZnListFromArray(*pts, *num_pts, sizeof(ZnPoint));
+      ZnListAppend(bz->points, tmp);
+      ZnListFree(tmp);
+    }
+    ITEM.Invalidate(item, ZN_COORDS_FLAG);
+  }
+  else if (cmd == COORDS_REMOVE) {
+    if (!bz->points) {
+      goto edit_err;
+    }
+    points = ZnListArray(bz->points);
+    num_points = ZnListSize(bz->points);
+    if (index < 0) {
+      index += num_points;
+    }
+    if ((index < 0) || (index >= num_points)) {
+      goto range_err;
+    }
+    ZnListDelete(bz->points, index);
+    ITEM.Invalidate(item, ZN_COORDS_FLAG);
+  }
+  
+  return ZN_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Exported functions struct --
+ *
+ **********************************************************************************
+ */
+static ItemClassStruct BEZIER_ITEM_CLASS = {
+  sizeof(BezierItemStruct),
+  False,
+  False,
+  False,
+  "bezier",
+  bz_attrs,
+  Init,
+  Clone,
+  Destroy,
+  Configure,
+  Query,
+  NULL,
+  NULL,
+  GetClipVertices,
+  Coords,
+  NULL,			/* Contour */
+  ComputeCoordinates,
+  ToArea,
+  Draw,
+  IsSensitive,
+  Pick,
+  NULL,			/* PickVertex */
+  PostScript
+};
+
+ZnItemClassId ZnBezier = (ZnItemClassId) &BEZIER_ITEM_CLASS;