Correction des entetes.

Utilisation du module local de couleurs.
Suppression du code sur les lignes doubles.
Re�criture du codede coords.

1 files changed, 1100 insertions, 0 deletions

diff --git a/generic/Arc.c b/generic/Arc.c
new file mode 100644
index 0000000..77e655c
--- /dev/null
+++ b/generic/Arc.c
@@ -0,0 +1,1100 @@
+/*
+ * Arc.c -- Implementation of Arc item.
+ *
+ * Authors		: Patrick Lecoanet.
+ * Creation date	: Wed Mar 30 16:24:09 1994
+ *
+ * $Id$
+ */
+
+/*
+ *  Copyright (c) 1993 - 1999 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 <malloc.h>
+
+#include "Item.h"
+#include "Geo.h"
+#include "Draw.h"
+#include "Types.h"
+#include "WidgetInfo.h"
+#include "Image.h"
+
+
+static const char rcsid[] = "$Id$";
+static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $";
+
+
+/*
+ * Bit offset of flags.
+ */
+#define FILLED_BIT	1	/* If the arc is filled with color/pattern */
+#define CLOSED_BIT	2	/* If the arc outline is closed */
+#define PIE_SLICE_BIT	4	/* If the arc is closed as a pie slice or a chord */
+
+
+#define PTS_IN_SHAPE	64
+static RadarPoint oval_shape[PTS_IN_SHAPE] = {
+  {1.0, 0.0},				/* 0 */
+  {0.99518472653, 0.0980171417729},
+  {0.980785279837, 0.195090324861},
+  {0.956940334469, 0.290284681418},
+  {0.923879530291, 0.382683437725},
+  {0.88192126093, 0.471396743221},
+  {0.831469607468, 0.555570240255},
+  {0.773010446922, 0.634393292011},
+  {0.707106772982, 0.707106789391},
+  {0.634393274074, 0.773010461643},
+  {0.555570220961, 0.83146962036},
+  {0.471396722756, 0.881921271869},
+  {0.382683416286, 0.923879539171},
+  {0.290284659212, 0.956940341205},
+  {0.195090302102, 0.980785284364},
+  {0.0980171186795, 0.995184728805},
+  {0.0, 1.0},				/* PI/2 */
+  {-0.0980171648663, 0.995184724256},
+  {-0.19509034762, 0.98078527531},
+  {-0.290284703624, 0.956940327733},
+  {-0.382683459163, 0.923879521411},
+  {-0.471396763686, 0.881921249991},
+  {-0.555570259549, 0.831469594576},
+  {-0.634393309949, 0.773010432201},
+  {-0.707106805799, 0.707106756574},
+  {-0.773010476365, 0.634393256136},
+  {-0.831469633252, 0.555570201666},
+  {-0.881921282808, 0.471396702291},
+  {-0.923879548052, 0.382683394847},
+  {-0.956940347941, 0.290284637006},
+  {-0.980785288892, 0.195090279343},
+  {-0.995184731079, 0.0980170955862},
+  {-1.0, 0.0},				/* PI */
+  {-0.995184721981, -0.0980171879596},
+  {-0.980785270783, -0.195090370379},
+  {-0.956940320997, -0.29028472583},
+  {-0.923879512531, -0.382683480602},
+  {-0.881921239052, -0.471396784151},
+  {-0.831469581684, -0.555570278844},
+  {-0.77301041748, -0.634393327887},
+  {-0.707106740165, -0.707106822208},
+  {-0.634393238198, -0.773010491086},
+  {-0.555570182372, -0.831469646144},
+  {-0.471396681826, -0.881921293746},
+  {-0.382683373409, -0.923879556932},
+  {-0.2902846148, -0.956940354677},
+  {-0.195090256583, -0.980785293419},
+  {-0.0980170724928, -0.995184733354},
+  {0.0, -1.0},				/* 3*PI/2 */
+  {0.098017211053, -0.995184719707},
+  {0.195090393139, -0.980785266256},
+  {0.290284748036, -0.956940314261},
+  {0.382683502041, -0.923879503651},
+  {0.471396804617, -0.881921228114},
+  {0.555570298138, -0.831469568792},
+  {0.634393345825, -0.773010402759},
+  {0.707106838616, -0.707106723757},
+  {0.773010505807, -0.63439322026},
+  {0.831469659036, -0.555570163078},
+  {0.881921304685, -0.471396661361},
+  {0.923879565812, -0.38268335197},
+  {0.956940361414, -0.290284592594},
+  {0.980785297946, -0.195090233824},
+  {0.995184735628, -0.0980170493994}
+};
+
+
+/*
+ **********************************************************************************
+ *
+ * Specific Arc item record.
+ *
+ **********************************************************************************
+ */
+typedef struct _ArcItemStruct {
+  ItemStruct	header;
+  
+  /* Public data */
+  RadarPoint	coords[2];
+  int		start_angle;
+  int		angle_extent;
+  Pixmap	line_pattern;
+  Pixmap	fill_pattern;
+  RadarColor	fill_color;
+  RadarColor	line_color;
+  int		line_width;
+  LineStyle	line_style;
+  char		*tile_name;
+  unsigned char flags;
+
+  /* Private data */
+  RadarPoint	orig;
+  RadarPoint	corner;
+  RadarPoint	center1;
+  RadarPoint	center2;
+  RadarImage	tile;
+  RadarList	render_shape;
+} ArcItemStruct, *ArcItem;
+
+
+static RadarAttrConfig	arc_attrs[] = {
+  { RADAR_CONFIG_BOOL, "-closed", NULL,
+    Tk_Offset(ArcItemStruct, flags), CLOSED_BIT, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-composerotation", NULL,
+    Tk_Offset(ArcItemStruct, header.flags), COMPOSE_ROTATION_BIT,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-composescale", NULL,
+    Tk_Offset(ArcItemStruct, header.flags), COMPOSE_SCALE_BIT,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_ANGLE, "-extent", NULL,
+    Tk_Offset(ArcItemStruct, angle_extent), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-fillcolor", NULL,
+    Tk_Offset(ArcItemStruct, fill_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-filled", NULL,
+    Tk_Offset(ArcItemStruct, flags), FILLED_BIT, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_PATTERN, "-fillpattern", NULL,
+    Tk_Offset(ArcItemStruct, fill_pattern), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-linecolor", NULL,
+    Tk_Offset(ArcItemStruct, line_color), 0,
+    RADAR_DRAW_FLAG|RADAR_BORDER_FLAG, False },
+  { RADAR_CONFIG_PATTERN, "-linepattern", NULL,
+    Tk_Offset(ArcItemStruct, line_pattern), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-linestyle", NULL,
+    Tk_Offset(ArcItemStruct, line_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_DIM, "-linewidth", NULL,
+    Tk_Offset(ArcItemStruct, line_width), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-pieslice", NULL,
+    Tk_Offset(ArcItemStruct, flags), PIE_SLICE_BIT, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_PRI, "-priority", NULL,
+    Tk_Offset(ArcItemStruct, header.priority), 0,
+    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(ArcItemStruct, header.flags), SENSITIVE_BIT,
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_ANGLE, "-startangle", NULL,
+    Tk_Offset(ArcItemStruct, start_angle), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_TAGS, "-tags", NULL,
+    Tk_Offset(ArcItemStruct, header.tags), 0, 0, False },
+  { RADAR_CONFIG_IMAGE, "-tile", NULL,
+    Tk_Offset(ArcItemStruct, tile_name), 0,
+    RADAR_DRAW_FLAG|RADAR_TILE_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-visible", NULL,
+    Tk_Offset(ArcItemStruct, header.flags), VISIBLE_BIT,
+    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG|RADAR_VIS_FLAG, False },
+  
+  { RADAR_CONFIG_END, NULL, NULL, 0, 0, 0 }
+};
+
+
+/*
+ **********************************************************************************
+ *
+ * ArcTileChange --
+ *
+ **********************************************************************************
+ */
+static void
+ArcTileChange(ClientData	client_data,
+	      int		x,
+	      int		y,
+	      int		width,
+	      int		height,
+	      int		image_width,
+	      int		image_height)
+{
+  ArcItem	arc = (ArcItem) client_data;
+
+  InvalidateImage(arc->tile);
+  ITEM.Invalidate((Item) arc, RADAR_COORDS_FLAG);
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Init --
+ *
+ **********************************************************************************
+ */
+static int
+Init(Item	item,
+     int	*argc,
+     Arg	**args)
+{
+  WidgetInfo	*wi = item->wi;
+  ArcItem	arc = (ArcItem) item;
+  Arg		*elems;
+  int		result, num_elems;
+#ifdef PTK
+  LangFreeProc *freeProc = NULL;
+#endif
+
+  /* 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_ARC_PRIORITY;
+
+  arc->start_angle = 0;
+  arc->angle_extent = 360;
+  CLEAR(arc->flags, FILLED_BIT);
+  CLEAR(arc->flags, CLOSED_BIT);
+  CLEAR(arc->flags, PIE_SLICE_BIT);
+  arc->line_pattern = RadarUnspecifiedPattern;
+  arc->fill_pattern = RadarUnspecifiedPattern;
+  arc->line_style = LINE_SIMPLE;
+  arc->line_width = 1;
+  arc->tile_name = "";
+  arc->tile = RadarUnspecifiedImage;
+  arc->render_shape = NULL;
+  
+  if (*argc < 1) {
+    Tcl_AppendResult(wi->interp, " arc coords expected", NULL);
+    return RADAR_ERROR;
+  }
+  result = Lang_SplitList(wi->interp, (*args)[0], &num_elems, &elems, &freeProc);
+  if ((result == RADAR_ERROR) || (num_elems != 4)) {
+  arc_error:
+#ifdef PTK
+    if (elems != NULL && freeProc) {
+      (*freeProc)(num_elems, elems);
+    }
+#endif
+    Tcl_AppendResult(wi->interp, " malformed arc coords", NULL);
+    return RADAR_ERROR;
+  }
+  if (Tcl_GetDouble(wi->interp, elems[0], &arc->coords[0].x) == RADAR_ERROR) {
+  arc_error2:
+#ifndef PTK
+    Tcl_Free((char *) elems);
+#endif
+    goto arc_error;
+  };
+  if (Tcl_GetDouble(wi->interp, elems[1], &arc->coords[0].y) == RADAR_ERROR) {
+    goto arc_error2;
+  };
+  if (Tcl_GetDouble(wi->interp, elems[2], &arc->coords[1].x) == RADAR_ERROR) {
+    goto arc_error2;
+  };
+  if (Tcl_GetDouble(wi->interp, elems[3], &arc->coords[1].y) == RADAR_ERROR) {
+    goto arc_error2;
+  };
+  (*args)++;
+  (*argc)--;
+#ifndef PTK
+  Tcl_Free((char *) elems);
+#else
+  if (freeProc) {
+    (*freeProc)(num_elems, elems);
+  }
+#endif
+
+  arc->fill_color = RadarGetColorByValue(wi->win, wi->fore_color);
+  arc->line_color = RadarGetColorByValue(wi->win, wi->fore_color);
+
+  return RADAR_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Clone --
+ *
+ **********************************************************************************
+ */
+static void
+Clone(Item	item)
+{
+  ArcItem	arc = (ArcItem) item;
+  WidgetInfo	*wi = item->wi;
+  char		*text;
+
+  if (strlen(arc->tile_name) != 0) {
+    text = RadarMalloc((strlen(arc->tile_name) + 1) * sizeof(char));
+    strcpy(text, arc->tile_name);
+    arc->tile_name = text;
+    arc->tile = Tk_GetImage(wi->interp, wi->win, arc->tile_name,
+			    ArcTileChange, (ClientData) arc);
+  }
+  if (arc->line_pattern != RadarUnspecifiedPattern) {
+    arc->line_pattern = Tk_GetBitmap(wi->interp, wi->win,
+				     Tk_NameOfBitmap(wi->dpy, arc->line_pattern));
+  }
+  if (arc->fill_pattern != RadarUnspecifiedPattern) {
+    arc->fill_pattern = Tk_GetBitmap(wi->interp, wi->win,
+				     Tk_NameOfBitmap(wi->dpy, arc->fill_pattern));
+  }
+  arc->line_color = RadarGetColorByValue(wi->win, arc->line_color);
+  arc->fill_color = RadarGetColorByValue(wi->win, arc->fill_color);
+  arc->render_shape = NULL;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Destroy --
+ *
+ **********************************************************************************
+ */
+static void
+Destroy(Item	item)
+{
+  WidgetInfo	*wi = item->wi;
+  ArcItem	arc = (ArcItem) item;
+
+  if (arc->render_shape) {
+    RadarListFree(arc->render_shape);
+  }
+  if (strlen(arc->tile_name) != 0) {
+    RadarFree(arc->tile_name);
+  }
+  if (arc->tile != RadarUnspecifiedImage) {
+    Tk_FreeImage(arc->tile);
+    arc->tile = RadarUnspecifiedImage;
+  }
+  if (arc->line_pattern != RadarUnspecifiedPattern) {
+    Tk_FreeBitmap(wi->dpy, arc->line_pattern);
+  }
+  if (arc->fill_pattern != RadarUnspecifiedPattern) {
+    Tk_FreeBitmap(wi->dpy, arc->fill_pattern);
+  }
+  RadarFreeColor(arc->fill_color);
+  RadarFreeColor(arc->line_color);
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Configure --
+ *
+ **********************************************************************************
+ */
+static int
+Configure(Item		item,
+	  int		argc,
+	  RadarAttrList	argv,
+	  int		*flags)
+{
+  WidgetInfo	*wi = item->wi;
+  ArcItem	arc = (ArcItem) item;
+
+  if (ITEM_P.ConfigureAttributes((char *) item, -1, argc, argv, flags) == RADAR_ERROR) {
+    return RADAR_ERROR;
+  }  
+
+  if (ISSET(*flags, RADAR_TILE_FLAG)) {
+    Tk_Image	tile;
+
+    if (strcmp(arc->tile_name, "") != 0) {
+      tile = Tk_GetImage(wi->interp, wi->win, arc->tile_name,
+			  ArcTileChange, (ClientData) arc);
+      if (tile == NULL) {
+	/*
+	 * The name will not be in sync with the image in
+	 * this case.
+	 */
+	return RADAR_ERROR;
+      }
+    }
+    else {
+      tile = RadarUnspecifiedImage;
+    }
+    if (arc->tile != RadarUnspecifiedImage) {
+      Tk_FreeImage(arc->tile);
+    }
+    arc->tile = tile;
+  }
+
+  return RADAR_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Query --
+ *
+ **********************************************************************************
+ */
+static int
+Query(Item		item,
+      int		argc,
+      RadarAttrList	argv)
+{
+  if (ITEM_P.QueryAttribute((char *) item, -1, argv[0]) == RADAR_ERROR) {
+    return RADAR_ERROR;
+  }  
+
+  return RADAR_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * ComputeCoordinates --
+ *
+ **********************************************************************************
+ */
+static void
+ComputeCoordinates(Item		item,
+		   RadarBool	force)
+{
+  WidgetInfo	*wi = item->wi;
+  ArcItem	arc = (ArcItem) item;
+  RadarReal	angle, sin1, cos1, sin2, cos2;
+  int		tmp, w_2, h_2, center_x, center_y,i;
+  RadarPoint	*p_list, p;
+  RadarReal	width_2, height_2, ox, oy;
+  
+  ResetBBox(&item->item_bounding_box);
+  /*
+   * If it is neither filled nor outlined, then nothing to show.
+   */
+  if (!arc->line_width && ISCLEAR(arc->flags, FILLED_BIT)) {
+    return;
+  }
+
+  /*
+   * Special casing for rotation. This should eventually be the
+   * only code but it lacks the arc capability. 
+   */
+  RadarTransfoDecompose(wi->current_transfo, NULL, NULL, &angle, NULL);
+  if (angle >= PRECISION_LIMIT) {
+    if (!arc->render_shape) {
+      arc->render_shape = RadarListNew(PTS_IN_SHAPE, sizeof(RadarPoint));
+      RadarListAssertSize(arc->render_shape, PTS_IN_SHAPE);
+    }
+    p_list = (RadarPoint *) RadarListArray(arc->render_shape);
+    width_2 = (arc->coords[1].x - arc->coords[0].x)/2.0;
+    height_2 = (arc->coords[1].y - arc->coords[0].y)/2.0;
+    ox = (arc->coords[1].x + arc->coords[0].x)/2.0;
+    oy = (arc->coords[1].y + arc->coords[0].y)/2.0;
+    for (i = 0; i < PTS_IN_SHAPE; i++, p_list++) {
+      p.x = ox + oval_shape[i].x*width_2;
+      p.y = oy + oval_shape[i].y*height_2;
+      RadarTransformPoint(wi->current_transfo, &p, p_list);
+      AddPointToBBox(&item->item_bounding_box, p_list->x, p_list->y);
+    }
+
+    tmp = (arc->line_width + 1) / 2 + 1;
+    item->item_bounding_box.orig.x -= tmp;
+    item->item_bounding_box.orig.y -= tmp;
+    item->item_bounding_box.corner.x += tmp;
+    item->item_bounding_box.corner.y += tmp;
+    return;
+  }
+
+  RadarTransformPoint(wi->current_transfo, &arc->coords[0], &arc->orig);
+  RadarTransformPoint(wi->current_transfo, &arc->coords[1], &arc->corner);
+
+  if (arc->orig.x > arc->corner.x) {
+    tmp = arc->orig.x;
+    arc->orig.x = arc->corner.x;
+    arc->corner.x = tmp;
+  }
+  if (arc->orig.y > arc->corner.y) {
+    tmp = arc->orig.y;
+    arc->orig.y = arc->corner.y;
+    arc->corner.y = tmp;
+  }
+
+  /*
+   * now compute the two points at the centers of the ends of the arc.
+   * We first compute the position for a unit circle and then scale
+   * to fit the shape.
+   * Angles are running counter clockwise and y coordinates are inverted.
+   * To handle these, the angles are negated.
+   */
+  angle = -(arc->start_angle * M_PI / 180.0);
+  sin1 = sin(angle);
+  cos1 = cos(angle);
+  angle -= (arc->angle_extent * M_PI / 180.0);
+  sin2 = sin(angle);
+  cos2 = cos(angle);
+  
+  w_2 = (arc->corner.x - arc->orig.x) / 2;
+  h_2 = (arc->corner.y - arc->orig.y) / 2;
+  center_x = (arc->corner.x + arc->orig.x) / 2;
+  center_y = (arc->corner.y + arc->orig.y) / 2;
+
+  arc->center1.x = center_x + REAL_TO_INT(cos1*w_2);
+  arc->center1.y = center_y + REAL_TO_INT(sin1*h_2);
+  arc->center2.x = center_x + REAL_TO_INT(cos2*w_2);
+  arc->center2.y = center_y + REAL_TO_INT(sin2*h_2);
+  
+  /*
+   * Add the ends centers to the bbox.
+   */
+  AddPointToBBox(&item->item_bounding_box, arc->center1.x, arc->center1.y);
+  AddPointToBBox(&item->item_bounding_box, arc->center2.x, arc->center2.y);
+  
+  /*
+   * If the arc is filled or if the outline is closed in pie slice,
+   * add the center of the arc.
+   */
+  if ((ISSET(arc->flags, FILLED_BIT) || ISSET(arc->flags, CLOSED_BIT)) &&
+      ISSET(arc->flags, PIE_SLICE_BIT)) {
+    AddPointToBBox(&item->item_bounding_box, center_x, center_y);
+  }
+  
+  /*
+   * Then add the 3-o'clock, 6-o'clock, 9-o'clock, 12-o'clock position
+   * as required.
+   */
+  tmp = -arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp - 360) > arc->angle_extent)) {
+    AddPointToBBox(&item->item_bounding_box, arc->corner.x, center_y);
+  }
+
+  tmp = 90 - arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp - 360) > arc->angle_extent)) {
+    AddPointToBBox(&item->item_bounding_box, center_x, arc->orig.y);
+  }
+  
+  tmp = 180 - arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp - 360) > arc->angle_extent)) {
+    AddPointToBBox(&item->item_bounding_box, arc->orig.x, center_y);
+  }
+  
+  tmp = 270 - arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp - 360) > arc->angle_extent)) {
+    AddPointToBBox(&item->item_bounding_box, center_x, arc->corner.y);
+  }
+
+  /*
+   * Now take care of the arc outline width plus one pixel of margin.
+   */
+  tmp = (arc->line_width + 1) / 2 + 1;
+  item->item_bounding_box.orig.x -= tmp;
+  item->item_bounding_box.orig.y -= tmp;
+  item->item_bounding_box.corner.x += tmp;
+  item->item_bounding_box.corner.y += tmp;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * ToArea --
+ *	Tell if the object is entirely outside (-1),
+ *	entirely inside (1) or in between (0).
+ *
+ **********************************************************************************
+ */
+static int
+ToArea(Item		item,
+       RadarBBox	*area,
+       Tk_Uid		tag_uid,
+       int		enclosed,
+       RadarBool	report)
+{
+  ArcItem	arc = (ArcItem) item;
+  RadarPoint	center;
+  RadarBBox	tran_rect;
+  int		rx, ry;
+  int		lw = arc->line_width;
+
+  /*
+   * Translate both the arc and the area so that they are
+   * centered on the origin. rx,ry are the radiuses in x and y.
+   */
+  center.x = (arc->corner.x + arc->orig.x) / 2;
+  center.y = (arc->corner.y + arc->orig.y) / 2;
+  tran_rect.orig.x = area->orig.x - center.x;
+  tran_rect.orig.y = area->orig.y - center.y;
+  rx = arc->corner.x - center.x + lw/2;
+  ry = arc->corner.y - center.y + lw/2;
+  
+  return -1;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Draw --
+ *
+ **********************************************************************************
+ */
+static void
+Draw(Item	item)
+{
+  WidgetInfo	*wi = item->wi;
+  ArcItem	arc = (ArcItem) item;
+  XGCValues  	values;
+  int		width, height;
+  RadarPoint	*p;
+  XPoint	xp[PTS_IN_SHAPE+1];
+  int		num_points, i;
+  
+  width = arc->corner.x - arc->orig.x;
+  height = arc->corner.y - arc->orig.y;
+
+  if (arc->render_shape &&
+      (ISSET(arc->flags, FILLED_BIT) || (arc->line_width))) {
+    p = (RadarPoint *) RadarListArray(arc->render_shape);
+    num_points = RadarListSize(arc->render_shape);
+    for (i = 0; i < num_points; i++, p++) {
+      xp[i].x = (short) p->x;
+      xp[i].y = (short) p->y;
+    }
+    xp[i] = xp[0];
+    num_points++;
+  }
+  
+  /* Fill if requested */
+  if (ISSET(arc->flags, FILLED_BIT)) {
+    values.foreground = RadarPixel(arc->fill_color);
+    values.arc_mode = ISSET(arc->flags, PIE_SLICE_BIT) ? ArcPieSlice : ArcChord;
+    if (arc->tile != RadarUnspecifiedImage) { /* Fill Tiled */
+      Pixmap pmap = GetImagePixmap(wi->win, arc->tile);
+      values.fill_style = FillTiled;
+      values.tile = pmap;
+      values.ts_x_origin = (int) item->item_bounding_box.orig.x;
+      values.ts_y_origin = (int) item->item_bounding_box.orig.y;
+      XChangeGC(wi->dpy, wi->gc,
+		GCTileStipXOrigin|GCTileStipYOrigin|GCFillStyle|GCTile|GCArcMode,
+		&values);
+    }
+    else if (arc->fill_pattern != RadarUnspecifiedPattern) { /* Fill stippled */
+      values.fill_style = FillStippled;
+      values.stipple = arc->fill_pattern;
+      values.ts_x_origin = (int) item->item_bounding_box.orig.x;
+      values.ts_y_origin = (int) item->item_bounding_box.orig.y;
+      XChangeGC(wi->dpy, wi->gc,
+		GCTileStipXOrigin|GCTileStipYOrigin|GCFillStyle|GCStipple|GCForeground|GCArcMode,
+		&values);
+    }
+    else { /* Fill solid */
+      values.fill_style = FillSolid;
+      XChangeGC(wi->dpy, wi->gc, GCForeground|GCFillStyle|GCArcMode, &values);
+    }
+    if (arc->render_shape) {
+      XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc,
+		   xp, num_points, Convex, CoordModeOrigin);
+    }
+    else {
+      XFillArc(wi->dpy, wi->draw_buffer, wi->gc,
+	       arc->orig.x, arc->orig.y, width, height,
+	       arc->start_angle*64, arc->angle_extent*64);
+    }
+  }
+
+  /*
+   * Draw the arc.
+   */
+  if (arc->line_width) {
+    SetLineStyle(wi->dpy, wi->gc, arc->line_style);
+    values.foreground = RadarPixel(arc->line_color);
+    values.line_width = (arc->line_width == 1) ? 0 : arc->line_width;
+    values.cap_style = CapRound;
+    values.join_style = JoinRound;
+    if (arc->line_pattern == RadarUnspecifiedPattern) {
+      values.fill_style = FillSolid;
+      XChangeGC(wi->dpy, wi->gc,
+		GCFillStyle|GCLineWidth|GCCapStyle|GCJoinStyle|GCForeground, &values);
+    }
+    else {
+      values.fill_style = FillStippled;
+      values.stipple = arc->line_pattern;
+      XChangeGC(wi->dpy, wi->gc,
+		GCFillStyle|GCStipple|GCLineWidth|GCCapStyle|GCJoinStyle|GCForeground,
+		&values);
+    }
+    if (arc->render_shape) {
+      XDrawLines(wi->dpy, wi->draw_buffer, wi->gc,
+		 xp, num_points, CoordModeOrigin);
+    }
+    else {
+      XDrawArc(wi->dpy, wi->draw_buffer, wi->gc,
+	       arc->orig.x, arc->orig.y, width, height,
+	       arc->start_angle*64, arc->angle_extent*64);
+    }
+  
+    /*
+     * If the outline is closed, draw the closure.
+     */
+    if (ISSET(arc->flags, CLOSED_BIT)) {
+      if (ISSET(arc->flags, PIE_SLICE_BIT)) {
+	XPoint	points[3];
+	
+	points[0].x = arc->center1.x;
+	points[0].y = arc->center1.y;
+	points[1].x = (arc->corner.x + arc->orig.x) / 2;
+	points[1].y = (arc->corner.y + arc->orig.y) / 2;
+	points[2].x = arc->center2.x;
+	points[2].y = arc->center2.y;
+	XDrawLines(wi->dpy, wi->draw_buffer, wi->gc, points, 3, CoordModeOrigin);
+      }
+      else {
+	XDrawLine(wi->dpy, wi->draw_buffer, wi->gc,
+		  arc->center1.x, arc->center1.y, arc->center2.x, arc->center2.y);
+      }
+    }
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * IsSensitive --
+ *
+ **********************************************************************************
+ */
+static RadarBool
+IsSensitive(Item	item,
+	    int		item_part)
+{
+  return (ISSET(item->flags, SENSITIVE_BIT) &&
+	  item->parent->class->IsSensitive(item->parent, RADAR_NO_PART));
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Pick --
+ *
+ **********************************************************************************
+ */
+static double
+Pick(Item	item,
+     RadarPoint	*p,
+     Item	start_item,
+     int	aperture,
+     Item	*a_item,
+     int	*a_part)
+{
+  ArcItem	arc = (ArcItem) item;
+  double	dist, new_dist;
+  RadarBool	point_in_angle, filled, closed;
+  RadarBool	in_triangle, acute_angle;
+  RadarPoint	p1, center;
+  int		width, height;
+  RadarDim	lw = arc->line_width;
+
+  center.x = (arc->corner.x + arc->orig.x) / 2;
+  center.y = (arc->corner.y + arc->orig.y) / 2;
+  width = arc->corner.x - arc->orig.x;
+  height = arc->corner.y - arc->orig.y;
+  
+  /*
+   * Let see if the point is in the angular range. First
+   * transform the coordinates so that the oval is circular.
+   * The 8192 factor avoids rounding errors.
+   */
+  p1.y = ((int)(p->y - center.y)*8192) / height;
+  p1.x = ((int)(p->x - center.x)*8192) / width;
+  point_in_angle = PointInAngle(arc->start_angle, arc->angle_extent, &p1);
+
+  /*
+   * Now try to compute the distance dealing with the
+   * many possible configurations.
+   */
+  filled = !ISCLEAR(arc->flags, FILLED_BIT);
+  closed = !ISCLEAR(arc->flags, CLOSED_BIT);
+
+  /*
+   * First the case of an arc not filled, not closed. We suppose
+   * here that the outline is drawn since we cannot get here without
+   * filling or outlining.
+   */
+  if (!filled && !closed) {
+    if (point_in_angle) {
+      dist = OvalToPointDist(&center, width, height, lw, p);
+      if (dist < 0.0) {
+	dist = -dist;
+      }
+      return dist;
+    }
+    dist = hypot((p->x - arc->center1.x), (p->y - arc->center1.y));
+    new_dist = hypot((p->x - arc->center2.x), (p->y - arc->center2.y));
+    if (new_dist < dist) {
+      dist = new_dist;
+    }
+    /* Take into account CapRounded path. */
+    if (lw > 1) {
+      dist -= lw/2;
+      if (dist < 0.0) {
+	dist = 0.0;
+      }
+    }
+    return dist;
+  }
+  
+  /*
+   * Try to deal with filled and/or outline-closed arcs (not having full
+   * angular extent).
+   */
+  if (ISSET(arc->flags, PIE_SLICE_BIT)) {
+    dist = LineToPointDist(&center, &arc->center1, p);
+    new_dist = LineToPointDist(&center, &arc->center2, p);
+    if (new_dist < dist) {
+      dist = new_dist;
+    }
+    if (arc->line_width > 1) {
+      if (closed) {
+	dist -= arc->line_width/2;
+      }
+      /*
+       * The arc outline is CapRounded so if it is not
+       * full extent, includes the caps.
+       */
+      else {
+	new_dist = hypot(p->x - arc->center1.x, p->y - arc->center1.y) - lw/2;
+	if (new_dist < dist) {
+	  dist = new_dist;
+	}
+	new_dist = hypot(p->x - arc->center2.x, p->y - arc->center2.y) - lw/2;
+	if (new_dist < dist) {
+	  dist = new_dist;
+	}
+      }
+    }
+    if (dist <= 0.0) {
+      return 0.0;
+    }
+    if (point_in_angle) {
+      new_dist = OvalToPointDist(&center, width, height, lw, p);
+      if (new_dist < dist) {
+	dist = new_dist;
+      }
+      if (dist < 0.0) {
+	dist = filled ? 0.0 : -dist;
+      }
+    }
+    return dist;
+  }
+
+  /*
+   * This is a chord closed oval.
+   */    
+  dist = LineToPointDist(&arc->center1, &arc->center2, p);
+  if (arc->line_width > 1) {
+    if (closed) {
+      dist -= arc->line_width/2;
+    }
+    /*
+     * The arc outline is CapRounded so if it is not
+     * full extent, includes the caps.
+     */
+    else {
+      new_dist = hypot(p->x - arc->center1.x, p->y - arc->center1.y) - lw/2;
+      if (new_dist < dist) {
+	dist = new_dist;
+      }
+      new_dist = hypot(p->x - arc->center2.x, p->y - arc->center2.y) - lw/2;
+      if (new_dist < dist) {
+	dist = new_dist;
+      }
+    }
+  }
+  if (dist <= 0.0) {
+    return 0.0;
+  }
+  
+  /*
+   * Need to check the point against the triangle formed
+   * by the difference between Chord mode and PieSlice mode.
+   * This triangle needs to be included if extend is more than
+   * 180 degrees and excluded otherwise. We try to see if
+   * the center of the arc and the point are both on the same
+   * side of the chord. If they are, the point is in the triangle
+   */
+  if (arc->center1.x == arc->center2.x) {
+    in_triangle = ((center.x <= arc->center1.x) && (p->x <= arc->center1.x)) ||
+      ((center.x > arc->center1.x) && (p->x > arc->center1.x));
+  }
+  else {
+    double	a, b;
+    
+    a = ((double) (arc->center2.y - arc->center1.y)) /
+      ((double) (arc->center2.x - arc->center1.x));
+    b = arc->center1.y - a*arc->center1.x;
+    in_triangle = (((a*center.x + b - center.y) >= 0.0) ==
+		   ((a*p->x + b - p->y) >= 0.0));
+  }
+  
+  acute_angle = ((arc->angle_extent > -180) && (arc->angle_extent < 180));
+  if (!point_in_angle && !acute_angle && filled && in_triangle) {
+    return 0.0;
+  }
+  
+  if (point_in_angle && (!acute_angle || !in_triangle)) {
+    new_dist = OvalToPointDist(&center, width, height, lw, p);
+    if (new_dist < dist) {
+      dist = new_dist;
+    }
+    if (dist < 0.0) {
+      dist = filled ? 0.0 : -dist;
+    }
+  }
+
+  return dist;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetClipVertices --
+ *	Get the clipping shape.
+ *
+ **********************************************************************************
+ */
+static RadarBool
+GetClipVertices(Item		item,
+		RadarPoint	**points,
+		int		*num_points)
+{
+  return False;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Coords --
+ *	Return or edit the item vertices.
+ *
+ **********************************************************************************
+ */
+static int
+Coords(Item		item,
+       int		index,
+       int		cmd,
+       RadarPoint	**pts,
+       int		*num_pts)
+{
+  ArcItem	arc = (ArcItem) item;
+
+  if ((cmd == COORDS_ADD) || (cmd == COORDS_ADD_LAST) || (cmd == COORDS_REMOVE)) {
+    Tcl_AppendResult(item->wi->interp,
+		     " arcs can't add or remove vertices", NULL);
+    return RADAR_ERROR;
+  }
+  else if (cmd == COORDS_REPLACE_ALL) {
+    if (*num_pts != 2) {
+      Tcl_AppendResult(item->wi->interp,
+		       " coords command need 2 points on arcs", NULL);
+      return RADAR_ERROR;
+    }
+    arc->coords[0] = (*pts)[0];
+    arc->coords[1] = (*pts)[1];
+    ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+  }
+  else if (cmd == COORDS_REPLACE) {
+    if (*num_pts < 1) {
+      Tcl_AppendResult(item->wi->interp,
+		       " coords command need at least 1 point", NULL);
+      return RADAR_ERROR;
+    }
+    if (index < 0) {
+      index += 2;
+    }
+    if ((index < 0) || (index > 1)) {
+    range_err:
+      Tcl_AppendResult(item->wi->interp,
+		       " incorrect coord index, should be between -2 and 1", NULL);
+      return RADAR_ERROR;
+    }
+    arc->coords[index] = (*pts)[0];
+    ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+  }
+  else if (cmd == COORDS_READ_ALL) {
+    *num_pts = 2;
+    *pts = arc->coords;
+  }
+  else if (cmd == COORDS_READ) {
+    if (index < 0) {
+      index += 2;
+    }
+    if ((index < 0) || (index > 1)) {
+      goto range_err;
+    }
+    *num_pts = 1;
+    *pts = &arc->coords[index];
+  }
+
+  return RADAR_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * PostScript --
+ *
+ **********************************************************************************
+ */
+static void
+PostScript(Item			item,
+	   PostScriptInfo	ps_info)
+{
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Exported functions struct --
+ *
+ **********************************************************************************
+ */
+static ItemClassStruct ARC_ITEM_CLASS = {
+  sizeof(ArcItemStruct),
+  False,
+  False,
+  False,
+  "arc",
+  arc_attrs,
+  Init,
+  Clone,
+  Destroy,
+  Configure,
+  Query,
+  NULL,
+  NULL,
+  GetClipVertices,
+  Coords,
+  ComputeCoordinates,
+  ToArea,
+  Draw,
+  IsSensitive,
+  Pick,
+  PostScript
+};
+
+RadarItemClassId RadarArc = (RadarItemClassId) &ARC_ITEM_CLASS;