Fin de la r�alisation de l'item. Ajout des fleches, prise

en compte de la rotation, r�alisation de Pick et ToArea.

1 files changed, 636 insertions, 142 deletions

diff --git a/generic/Arc.c b/generic/Arc.c
index 77e655c..a5203b5 100644
--- a/generic/Arc.c
+++ b/generic/Arc.c
@@ -27,6 +27,7 @@
  */
 
 
+#include <alloca.h>
 #include <malloc.h>
 
 #include "Item.h"
@@ -44,78 +45,16 @@ 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}
-};
+#define FILLED_BIT	1<<0	/* If the arc is filled with color/pattern */
+#define CLOSED_BIT	1<<1	/* If the arc outline is closed */
+#define PIE_SLICE_BIT	1<<2	/* If the arc is closed as a pie slice or a chord */
+
+#define FIRST_END_OK	1<<3
+#define LAST_END_OK	1<<4
+
+
+static double Pick(Item item, RadarPoint *p, Item start_item, int aperture,
+		   Item *a_item, int *a_part);
 
 
 /*
@@ -138,6 +77,8 @@ typedef struct _ArcItemStruct {
   RadarColor	line_color;
   int		line_width;
   LineStyle	line_style;
+  LineEnd	first_end;
+  LineEnd	last_end;
   char		*tile_name;
   unsigned char flags;
 
@@ -168,6 +109,10 @@ static RadarAttrConfig	arc_attrs[] = {
     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_LINE_END, "-firstend", NULL,
+    Tk_Offset(ArcItemStruct, first_end), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_LINE_END, "-lastend", NULL,
+    Tk_Offset(ArcItemStruct, last_end), 0, RADAR_COORDS_FLAG, False },
   { RADAR_CONFIG_COLOR, "-linecolor", NULL,
     Tk_Offset(ArcItemStruct, line_color), 0,
     RADAR_DRAW_FLAG|RADAR_BORDER_FLAG, False },
@@ -259,6 +204,7 @@ Init(Item	item,
   arc->fill_pattern = RadarUnspecifiedPattern;
   arc->line_style = LINE_SIMPLE;
   arc->line_width = 1;
+  arc->first_end = arc->last_end = NULL;
   arc->tile_name = "";
   arc->tile = RadarUnspecifiedImage;
   arc->render_shape = NULL;
@@ -332,6 +278,12 @@ Clone(Item	item)
     arc->tile = Tk_GetImage(wi->interp, wi->win, arc->tile_name,
 			    ArcTileChange, (ClientData) arc);
   }
+  if (arc->first_end) {
+    LineEndDuplicate(arc->first_end);
+  }
+  if (arc->last_end) {
+    LineEndDuplicate(arc->last_end);
+  }
   if (arc->line_pattern != RadarUnspecifiedPattern) {
     arc->line_pattern = Tk_GetBitmap(wi->interp, wi->win,
 				     Tk_NameOfBitmap(wi->dpy, arc->line_pattern));
@@ -342,7 +294,9 @@ Clone(Item	item)
   }
   arc->line_color = RadarGetColorByValue(wi->win, arc->line_color);
   arc->fill_color = RadarGetColorByValue(wi->win, arc->fill_color);
-  arc->render_shape = NULL;
+  if (arc->render_shape) {
+    arc->render_shape = RadarListDuplicate(arc->render_shape);
+  }
 }
 
 
@@ -365,6 +319,12 @@ Destroy(Item	item)
   if (strlen(arc->tile_name) != 0) {
     RadarFree(arc->tile_name);
   }
+  if (arc->first_end) {
+    LineEndDelete(arc->first_end);
+  }
+  if (arc->last_end) {
+    LineEndDelete(arc->last_end);
+  }
   if (arc->tile != RadarUnspecifiedImage) {
     Tk_FreeImage(arc->tile);
     arc->tile = RadarUnspecifiedImage;
@@ -383,6 +343,29 @@ Destroy(Item	item)
 /*
  **********************************************************************************
  *
+ * Setup flags to control the precedence between the
+ * graphical attributes.
+ *
+ **********************************************************************************
+ */
+static void
+SetRenderFlags(ArcItem	arc)
+{
+  ASSIGN(arc->flags, FIRST_END_OK,
+	 (arc->first_end != NULL) && ISCLEAR(arc->flags, CLOSED_BIT) &&
+	 ISCLEAR(arc->flags, FILLED_BIT) && arc->line_width
+	 /*&& ISCLEAR(arc->flags, RELIEF_OK)*/);
+
+  ASSIGN(arc->flags, LAST_END_OK,
+	 (arc->last_end != NULL) && ISCLEAR(arc->flags, CLOSED_BIT) &&
+	 ISCLEAR(arc->flags, FILLED_BIT) && arc->line_width
+	 /*&& ISCLEAR(arc->flags, RELIEF_OK)*/);
+}
+
+
+/*
+ **********************************************************************************
+ *
  * Configure --
  *
  **********************************************************************************
@@ -423,6 +406,8 @@ Configure(Item		item,
     arc->tile = tile;
   }
 
+  SetRenderFlags(arc);
+  
   return RADAR_OK;
 }
 
@@ -448,6 +433,66 @@ Query(Item		item,
 
 
 /*
+ * Tangent --
+ *	Compute a point describing the arc tangent at the first/last
+ *	end of the arc. The point is on the tangent segment next to
+ *	the arc (ie: it is suitable for drawing arrows).
+ */
+void
+Tangent(ArcItem		arc,
+	RadarBool	first,
+	RadarPoint	*p)
+{
+  double	a2, b2, w_2, h_2;
+  double	angle;
+  RadarPoint	p1, center;
+
+  if (first) {
+    angle = DegreesToRadian(arc->start_angle);
+  }
+  else {
+    angle = DegreesToRadian(arc->start_angle + arc->angle_extent);
+  }
+  p1.x = cos(angle);
+  p1.y = sin(angle);
+  w_2 = (arc->corner.x - arc->orig.x) / 2.0;
+  h_2 = (arc->corner.y - arc->orig.y) / 2.0;
+  center.x = (arc->orig.x + arc->corner.x) / 2.0;
+  center.y = (arc->orig.y + arc->corner.y) / 2.0;
+
+  /*
+   * Slope of the initial segment.
+   *
+   * a1 = (center->y - p1.y) / (center->x - p1.x);
+   * a2 = -1/a1;
+   */
+  a2 = - p1.x / p1.y;
+  b2 = p1.y - a2*p1.x;
+
+  if (p1.y == 0.0) {
+    p->x = p1.x;
+    if (!first) {
+      p->y = p1.y - 10.0;
+    }
+    else {
+      p->y = p1.y + 10.0;
+    }
+  }
+  else {
+    if ((!first && (p1.y < 0.0)) || (first && (p1.y > 0.0))) {
+      p->x = p1.x - 10.0;
+    }
+    else {
+      p->x = p1.x + 10.0;
+    }
+    p->y = a2*p->x + b2;
+  }
+  p->x = center.x + REAL_TO_INT(p->x*w_2);
+  p->y = center.y + REAL_TO_INT(p->y*h_2);
+}
+
+
+/*
  **********************************************************************************
  *
  * ComputeCoordinates --
@@ -461,8 +506,10 @@ ComputeCoordinates(Item		item,
   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;
+  RadarReal	tmp, w_2, h_2, center_x, center_y;
+  int		num_p, i;
   RadarPoint	*p_list, p;
+  RadarPoint	end_points[LINE_END_POINTS];
   RadarReal	width_2, height_2, ox, oy;
   
   ResetBBox(&item->item_bounding_box);
@@ -474,35 +521,64 @@ ComputeCoordinates(Item		item,
   }
 
   /*
-   * Special casing for rotation. This should eventually be the
-   * only code but it lacks the arc capability. 
+   * Special casing for rotation and/or relief.
+   * This could eventually be the only code but it has to
+   * good results and be fast enough. 
    */
   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);
+      arc->render_shape = RadarListNew(4, sizeof(RadarPoint));
     }
+    GetArcPath(DegreesToRadian(arc->start_angle),
+	       DegreesToRadian(arc->start_angle+arc->angle_extent),
+	       (ISCLEAR(arc->flags, CLOSED_BIT) ? 0 :
+		ISCLEAR(arc->flags, PIE_SLICE_BIT) ? 1 : 2), arc->render_shape);
     p_list = (RadarPoint *) RadarListArray(arc->render_shape);
+    num_p = RadarListSize(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;
+    for (i = 0; i < num_p; i++, p_list++) {
+      p.x = ox + p_list->x*width_2;
+      p.y = oy + p_list->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;
+    tmp = (arc->line_width + 1.0) / 2.0 + 1.0;
     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;
+
+    /*
+     * Add the arrows if any.
+     */
+    p_list = (RadarPoint *) RadarListArray(arc->render_shape);
+    if (ISSET(arc->flags, FIRST_END_OK)) {
+      GetLineEnd(p_list, p_list+1, arc->line_width, CapRound,
+		 arc->first_end, end_points);
+      AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+    }
+    if (ISSET(arc->flags, LAST_END_OK)) {
+      GetLineEnd(&p_list[num_p-1], &p_list[num_p-2], arc->line_width, CapRound,
+		 arc->last_end, end_points);
+      AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+    }
     return;
   }
 
+  /*
+   *******		********			**********
+   * This part is for X drawn arcs: not rotated, without relief.
+   *******		********			**********
+   */
+  if (arc->render_shape) {
+    RadarListFree(arc->render_shape);
+    arc->render_shape = NULL;
+  }
   RadarTransformPoint(wi->current_transfo, &arc->coords[0], &arc->orig);
   RadarTransformPoint(wi->current_transfo, &arc->coords[1], &arc->corner);
 
@@ -521,13 +597,12 @@ ComputeCoordinates(Item		item,
    * 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.
+   * Angles are running clockwise and y coordinates are inverted.
    */
-  angle = -(arc->start_angle * M_PI / 180.0);
+  angle = DegreesToRadian(arc->start_angle);
   sin1 = sin(angle);
   cos1 = cos(angle);
-  angle -= (arc->angle_extent * M_PI / 180.0);
+  angle += DegreesToRadian(arc->angle_extent);
   sin2 = sin(angle);
   cos2 = cos(angle);
   
@@ -568,38 +643,54 @@ ComputeCoordinates(Item		item,
     AddPointToBBox(&item->item_bounding_box, arc->corner.x, center_y);
   }
 
-  tmp = 90 - arc->start_angle;
+  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, center_x, arc->orig.y);
+    AddPointToBBox(&item->item_bounding_box, arc->orig.x, center_y);
   }
   
-  tmp = 180 - arc->start_angle;
+  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, arc->orig.x, center_y);
+    AddPointToBBox(&item->item_bounding_box, center_x, arc->corner.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);
+    AddPointToBBox(&item->item_bounding_box, center_x, arc->orig.y);
   }
-
+  
   /*
    * Now take care of the arc outline width plus one pixel of margin.
    */
-  tmp = (arc->line_width + 1) / 2 + 1;
+  tmp = (arc->line_width + 1.0) / 2.0 + 1.0;
   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;
+
+  /*
+   * Then add the arrows if any.
+   */
+  if (ISSET(arc->flags, FIRST_END_OK)) {
+    Tangent(arc, True, &p);
+    GetLineEnd(&arc->center1, &p, arc->line_width, CapRound,
+	       arc->first_end, end_points);
+    AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+  }
+  if (ISSET(arc->flags, LAST_END_OK)) {
+    Tangent(arc, False, &p);
+    GetLineEnd(&arc->center2, &p, arc->line_width, CapRound,
+	       arc->last_end, end_points);
+    AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+  }
 }
 
 
@@ -620,22 +711,272 @@ ToArea(Item		item,
        RadarBool	report)
 {
   ArcItem	arc = (ArcItem) item;
-  RadarPoint	center;
-  RadarBBox	tran_rect;
-  int		rx, ry;
-  int		lw = arc->line_width;
+  WidgetInfo	*wi = item->wi;
+  RadarPoint	*points;
+  RadarPoint	pts[20]; /* Should be at least LINE_END_POINTS large */
+  RadarPoint	center, tang;
+  RadarBBox	t_area;
+  int		num_points, result, result2;
+  RadarReal	lw = arc->line_width;
+  RadarReal	rx, ry, angle, tmp;
+  RadarBool	inside, new_inside;
+  
+  if (arc->render_shape &&
+      (ISSET(arc->flags, FILLED_BIT) || (arc->line_width))) {
+    GetBezierPath(arc->render_shape, wi->work_pts);
+    points = (RadarPoint *) RadarListArray(wi->work_pts);
+    num_points = RadarListSize(wi->work_pts);
+
+    if (ISSET(arc->flags, FILLED_BIT)) {
+      result = PolygonInBBox(points, num_points, area);
+      if (result == 0) {
+	return 0;
+      }
+    }
+    if (arc->line_width > 0) {
+      result2 = PolylineInBBox(points, num_points, arc->line_width,
+			       CapRound, JoinRound, area);
+      if (ISCLEAR(arc->flags, FILLED_BIT)) {
+	if (result2 == 0) {
+	  return 0;
+	}
+	result = result2;
+      }
+      else if (result2 != result) {
+	return 0;
+      }
+      if (ISSET(arc->flags, CLOSED_BIT) && ISSET(arc->flags, PIE_SLICE_BIT)) {
+	pts[0] = points[num_points-1];
+	pts[1] = points[0];
+	if (PolylineInBBox(pts, 2, arc->line_width,
+			   CapRound, JoinRound, area) != result) {
+	  return 0;
+	}
+      }
+      /*
+       * Check line ends.
+       */
+      if (ISSET(arc->flags, FIRST_END_OK)) {
+	GetLineEnd(&points[0], &points[1], arc->line_width, CapRound,
+		   arc->first_end, pts);
+	if (PolygonInBBox(pts, LINE_END_POINTS, area) != result) {
+	  return 0;
+	}
+      }
+      if (ISSET(arc->flags, LAST_END_OK)) {
+	GetLineEnd(&points[num_points-1], &points[num_points-2], arc->line_width,
+		   CapRound, arc->last_end, pts);
+	if (PolygonInBBox(pts, LINE_END_POINTS, area) != result) {
+	  return 0;
+	}
+      }
+    }
+    return result;
+  }
 
   /*
-   * Translate both the arc and the area so that they are
-   * centered on the origin. rx,ry are the radiuses in x and y.
+   *******		********			**********
+   * The rest of this code deal with non rotated or relief arcs. *
+   * It has been stolen from tkCanvArc.c			 *
+   *******		********			**********
    */
-  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;
+  /*
+   * Transform both the arc and the rectangle so that the arc's oval
+   * is centered on the origin.
+   */
+  center.x = (arc->orig.x + arc->corner.x)/2.0;
+  center.y = (arc->orig.y + arc->corner.y)/2.0;
+  t_area.orig.x = area->orig.x - center.x;
+  t_area.orig.y = area->orig.y - center.y;
+  t_area.corner.x = area->corner.x - center.x;
+  t_area.corner.y = area->corner.y - center.y;
+  rx = arc->corner.x - center.x + lw/2.0;
+  ry = arc->corner.y - center.y + lw/2.0;
+
+  /*
+   * Find the extreme points of the arc and see whether these are all
+   * inside the rectangle (in which case we're done), partly in and
+   * partly out (in which case we're done), or all outside (in which
+   * case we have more work to do).  The extreme points include the
+   * following, which are checked in order:
+   *
+   * 1. The outside points of the arc, corresponding to start and
+   *	  extent.
+   * 2. The center of the arc (but only in pie-slice mode).
+   * 3. The 12, 3, 6, and 9-o'clock positions (but only if the arc
+   *    includes those angles).
+   */
+  points = pts;
+  angle = DegreesToRadian(arc->start_angle);
+  points->x = rx*cos(angle);
+  points->y = ry*sin(angle);
+  angle += DegreesToRadian(arc->angle_extent);
+  points[1].x = rx*cos(angle);
+  points[1].y = ry*sin(angle);
+  num_points = 2;
+  points += 2;
+
+  if (ISSET(arc->flags, PIE_SLICE_BIT) && (arc->angle_extent < 180.0)) {
+    points->x = 0.0;
+    points->y = 0.0;
+    num_points++;
+    points++;
+  }
+
+  tmp = -arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360.0;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp-360) > arc->angle_extent)) {
+    points->x = rx;
+    points->y = 0.0;
+    num_points++;
+    points++;
+  }
+  tmp = 180.0 - arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360.0;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp-360) > arc->angle_extent)) {
+    points->x = 0.0;
+    points->y = ry;
+    num_points++;
+    points++;
+  }
+  tmp = 90.0 - arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360.0;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp-360) > arc->angle_extent)) {
+    points->x = -rx;
+    points->y = 0.0;
+    num_points++;
+    points++;
+  }
+  tmp = 270.0 - arc->start_angle;
+  if (tmp < 0) {
+    tmp += 360.0;
+  }
+  if ((tmp < arc->angle_extent) || ((tmp-360) > arc->angle_extent)) {
+    points->x = 0.0;
+    points->y = -ry;
+    num_points++;
+  }
+
+  /*
+   * Now that we've located the extreme points, loop through them all
+   * to see which are inside the rectangle.
+   */
+  inside = PointInBBox(&t_area, pts->x, pts->y);
+  for (points = pts+1; num_points > 1; points++, num_points--) {
+    new_inside = PointInBBox(&t_area, points->x, points->y);
+    if (new_inside != inside) {
+      return 0;
+    }
+  }
+  result = inside ? 1 : -1;
   
+  /*
+   * So far, oval appears to be outside rectangle, but can't yet tell
+   * for sure.  Next, test each of the four sides of the rectangle
+   * against the bounding region for the arc.  If any intersections
+   * are found, then return "overlapping".  First, test against the
+   * polygon(s) forming the sides of a chord or pie-slice.
+   */
+  if ((lw >= 1.0) && (ISSET(arc->flags, CLOSED_BIT))) {
+    if (ISSET(arc->flags, PIE_SLICE_BIT)) {
+      pts[0] = arc->center1;
+      pts[1] = center;
+      pts[2] = arc->center2;
+      num_points = 3;
+    }
+    else {
+      pts[0] = arc->center1;
+      pts[1] = arc->center2;
+      num_points = 2;
+    }
+    if (PolylineInBBox(pts, num_points, lw, CapRound, JoinRound, area) != result) {
+      return 0;
+    }
+  }
+  else if (ISSET(arc->flags, FILLED_BIT)) {
+    if (ISSET(arc->flags, PIE_SLICE_BIT)) {
+      if ((LineInBBox(&center, &arc->center1, area) != result) ||
+	  (LineInBBox(&center, &arc->center2, area) != result)) {
+	return 0;
+      }
+    }
+    else {
+      if (LineInBBox(&arc->center1, &arc->center2, area) != result) {
+	return 0;
+      }
+    }
+  }
+
+  /*
+   * Check line ends.
+   */
+  if (ISSET(arc->flags, FIRST_END_OK)) {
+    Tangent(arc, True, &tang);
+    GetLineEnd(&arc->center1, &tang, arc->line_width, CapRound,
+	       arc->first_end, pts);
+    if (PolygonInBBox(pts, LINE_END_POINTS, area) != result) {
+      return 0;
+    }
+  }
+  if (ISSET(arc->flags, LAST_END_OK)) {
+    Tangent(arc, False, &tang);
+    GetLineEnd(&arc->center2, &tang, arc->line_width, CapRound,
+	       arc->last_end, pts);
+    if (PolygonInBBox(pts, LINE_END_POINTS, area) != result) {
+      return 0;
+    }
+  }
+  if (result == 1) {
+    return result;
+  }
+  
+  /*
+   * Next check for overlap between each of the four sides and the
+   * outer perimiter of the arc.  If the arc isn't filled, then also
+   * check the inner perimeter of the arc.
+   */
+  if (HorizLineToArc(t_area.orig.x, t_area.corner.x, t_area.orig.y,
+		     rx, ry, arc->start_angle, arc->angle_extent) ||
+      HorizLineToArc(t_area.orig.x, t_area.corner.x, t_area.corner.y,
+		     rx, ry, arc->start_angle, arc->angle_extent) ||
+      VertLineToArc(t_area.orig.x, t_area.orig.y, t_area.corner.y,
+		       rx, ry, arc->start_angle, arc->angle_extent) ||
+      VertLineToArc(t_area.corner.x, t_area.orig.y, t_area.corner.y,
+		    rx, ry, arc->start_angle, arc->angle_extent)) {
+    return 0;
+  }
+  if ((lw > 1.0) && ISCLEAR(arc->flags, FILLED_BIT)) {
+    rx -= lw;
+    ry -= lw;
+    if (HorizLineToArc(t_area.orig.x, t_area.corner.x, t_area.orig.y,
+		       rx, ry, arc->start_angle, arc->angle_extent) ||
+	HorizLineToArc(t_area.orig.x, t_area.corner.x, t_area.corner.y,
+		       rx, ry, arc->start_angle, arc->angle_extent) ||
+	VertLineToArc(t_area.orig.x, t_area.orig.y, t_area.corner.y,
+		      rx, ry, arc->start_angle, arc->angle_extent) ||
+	VertLineToArc(t_area.corner.x, t_area.orig.y, t_area.corner.y,
+		      rx, ry, arc->start_angle, arc->angle_extent)) {
+      return 0;
+    }
+  }
+  
+  /*
+   * The arc still appears to be totally disjoint from the rectangle,
+   * but it's also possible that the rectangle is totally inside the arc.
+   * Do one last check, which is to check one point of the rectangle
+   * to see if it's inside the arc.  If it is, we've got overlap.  If
+   * it isn't, the arc's really outside the rectangle.
+   */
+  if (Pick(item, &area->orig, RADAR_NO_ITEM, 0, NULL, NULL) == 0.0) {
+    return 0;
+  }
+
   return -1;
 }
 
@@ -655,22 +996,23 @@ Draw(Item	item)
   XGCValues  	values;
   int		width, height;
   RadarPoint	*p;
-  XPoint	xp[PTS_IN_SHAPE+1];
+  XPoint	*xp;
   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);
+    GetBezierPath(arc->render_shape, wi->work_pts);
+    p = (RadarPoint *) RadarListArray(wi->work_pts);
+    num_points = RadarListSize(wi->work_pts);
+    xp = (XPoint *) alloca(num_points*sizeof(XPoint));
     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++;
+  }
+  else {
+    width = arc->corner.x - arc->orig.x;
+    height = arc->corner.y - arc->orig.y;
   }
   
   /* Fill if requested */
@@ -707,7 +1049,7 @@ Draw(Item	item)
     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);
+	       -arc->start_angle*64, -arc->angle_extent*64);
     }
   }
 
@@ -715,6 +1057,10 @@ Draw(Item	item)
    * Draw the arc.
    */
   if (arc->line_width) {
+    RadarPoint  end_points[LINE_END_POINTS];
+    XPoint      xap[LINE_END_POINTS];
+    RadarPoint	tang;
+      
     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;
@@ -735,31 +1081,80 @@ Draw(Item	item)
     if (arc->render_shape) {
       XDrawLines(wi->dpy, wi->draw_buffer, wi->gc,
 		 xp, num_points, CoordModeOrigin);
+      if (ISSET(arc->flags, CLOSED_BIT) && ISSET(arc->flags, PIE_SLICE_BIT)) {
+	XDrawLine(wi->dpy, wi->draw_buffer, wi->gc,
+		  xp[num_points-1].x, xp[num_points-1].y,
+		  xp[0].x, xp[0].y);
+      }
+      if (ISSET(arc->flags, FIRST_END_OK)) {
+	p = (RadarPoint *) RadarListArray(arc->render_shape);
+	GetLineEnd(p, p+1, arc->line_width, CapRound,
+		   arc->first_end, end_points);
+	for (i = 0; i < LINE_END_POINTS; i++) {
+	  xap[i].x = end_points[i].x;
+	  xap[i].y = end_points[i].y;
+	}
+	XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xap, LINE_END_POINTS,
+		     Nonconvex, CoordModeOrigin);
+      }
+      if (ISSET(arc->flags, LAST_END_OK)) {
+	p = (RadarPoint *) RadarListArray(arc->render_shape);
+	num_points = RadarListSize(arc->render_shape);
+	GetLineEnd(&p[num_points-1], &p[num_points-2], arc->line_width,
+		   CapRound, arc->last_end, end_points);
+	for (i = 0; i < LINE_END_POINTS; i++) {
+	  xap[i].x = end_points[i].x;
+	  xap[i].y = end_points[i].y;
+	}
+	XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xap, LINE_END_POINTS,
+		     Nonconvex, 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);
+	       -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);
+	}
       }
-      else {
-	XDrawLine(wi->dpy, wi->draw_buffer, wi->gc,
-		  arc->center1.x, arc->center1.y, arc->center2.x, arc->center2.y);
+      if (ISSET(arc->flags, FIRST_END_OK)) {
+	Tangent(arc, True, &tang);
+	GetLineEnd(&arc->center1, &tang, arc->line_width, CapRound,
+		   arc->first_end, end_points);
+	for (i = 0; i < LINE_END_POINTS; i++) {
+	  xap[i].x = end_points[i].x;
+	  xap[i].y = end_points[i].y;
+	}
+	XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xap, LINE_END_POINTS,
+		     Nonconvex, CoordModeOrigin);
+      }
+      if (ISSET(arc->flags, LAST_END_OK)) {
+	Tangent(arc, False, &tang);
+	GetLineEnd(&arc->center2, &tang, arc->line_width, CapRound,
+		   arc->last_end, end_points);
+	for (i = 0; i < LINE_END_POINTS; i++) {
+	  xap[i].x = end_points[i].x;
+	  xap[i].y = end_points[i].y;
+	}
+	XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xap, LINE_END_POINTS,
+		     Nonconvex, CoordModeOrigin);
       }
     }
   }
@@ -797,14 +1192,79 @@ Pick(Item	item,
      Item	*a_item,
      int	*a_part)
 {
+  WidgetInfo	*wi = item->wi;
   ArcItem	arc = (ArcItem) item;
-  double	dist, new_dist;
+  double	dist = 1e40, new_dist;
   RadarBool	point_in_angle, filled, closed;
   RadarBool	in_triangle, acute_angle;
-  RadarPoint	p1, center;
+  RadarPoint	p1, center, tang;
+  RadarPoint	*points;
+  RadarPoint	end_points[LINE_END_POINTS];
+  int		num_points;
   int		width, height;
   RadarDim	lw = arc->line_width;
+  
+  if (arc->render_shape &&
+      (ISSET(arc->flags, FILLED_BIT) || (arc->line_width))) {
+    GetBezierPath(arc->render_shape, wi->work_pts);
+    points = (RadarPoint *) RadarListArray(wi->work_pts);
+    num_points = RadarListSize(wi->work_pts);
+
+    if (ISSET(arc->flags, FILLED_BIT)) {
+      dist = PolygonToPointDist(points, num_points, p);
+      if (dist <= 0.0) {
+	return 0.0;
+      }
+    }
+    if (arc->line_width > 0) {
+      new_dist = PolylineToPointDist(points, num_points, arc->line_width,
+				     CapRound, JoinRound, p);
+      if (new_dist < dist) {
+	dist = new_dist;
+      }
+      if (ISSET(arc->flags, CLOSED_BIT) && ISSET(arc->flags, PIE_SLICE_BIT)) {
+	new_dist = LineToPointDist(&points[num_points-1], &points[0], p);
+	if (new_dist < dist) {
+	  dist = new_dist;
+	}
+      }
+      if (dist <= 0.0) {
+	return 0.0;
+      }
+    }
+    /*
+     * Check line ends.
+     */
+    if (ISSET(arc->flags, FIRST_END_OK)) {
+      GetLineEnd(&points[0], &points[1], arc->line_width, CapRound,
+		 arc->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(arc->flags, LAST_END_OK)) {
+      GetLineEnd(&points[num_points-1], &points[num_points-2], arc->line_width,
+		 CapRound, arc->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;
+  }
 
+  /*
+   *******		********			**********
+   * The rest of this code deal with non rotated or relief arcs. *
+   *******		********			**********
+   */
   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;
@@ -813,10 +1273,9 @@ Pick(Item	item,
   /*
    * 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;
+  p1.y = (p->y - center.y) / height;
+  p1.x = (p->x - center.x) / width;
   point_in_angle = PointInAngle(arc->start_angle, arc->angle_extent, &p1);
 
   /*
@@ -837,9 +1296,10 @@ Pick(Item	item,
       if (dist < 0.0) {
 	dist = -dist;
       }
-      return dist;
     }
-    dist = hypot((p->x - arc->center1.x), (p->y - arc->center1.y));
+    else {
+      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;
@@ -851,6 +1311,37 @@ Pick(Item	item,
 	dist = 0.0;
       }
     }
+    if (dist == 0.0) {
+      return 0.0;
+    }
+
+    /*
+     * Check line ends.
+     */
+    if (ISSET(arc->flags, FIRST_END_OK)) {
+      Tangent(arc, True, &tang);
+      GetLineEnd(&arc->center1, &tang, arc->line_width, CapRound,
+		 arc->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(arc->flags, LAST_END_OK)) {
+      Tangent(arc, False, &tang);
+      GetLineEnd(&arc->center2, &tang, arc->line_width,
+		 CapRound, arc->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;
   }
   
@@ -960,6 +1451,9 @@ Pick(Item	item,
     if (dist < 0.0) {
       dist = filled ? 0.0 : -dist;
     }
+    if (dist == 0.0) {
+      return 0.0;
+    }
   }
 
   return dist;