Adaptation des ent�tes.

Adaptation pour utilisation du module couleur interne.
Ajout des attributs de fleches "-leaderfirstend" et "-leaderlastend"
Si le nombre de champs n'�tait pas pr�cis�, ce n'�tait pas
d�tect�. Corrig�.
Correction de bugs de clonage.
Am�nagement de la m�thode Coords.
Suppression de la structure TRACK_P.

1 files changed, 1771 insertions, 0 deletions

diff --git a/generic/Track.c b/generic/Track.c
new file mode 100644
index 0000000..bcfdcf5
--- /dev/null
+++ b/generic/Track.c
@@ -0,0 +1,1771 @@
+/*
+ * Track.c -- Implementation of Track and WayPoint items.
+ *
+ * Authors		: Patrick Lecoanet.
+ * Creation date	:
+ *
+ * $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 "Track.h"
+#include "Draw.h"
+#include "Geo.h"
+#include "Item.h"
+#include "Types.h"
+#include "WidgetInfo.h"
+
+
+static const char rcsid[] = "$Id$";
+static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $";
+
+
+#define SPEED_VECTOR_PICKING_THRESHOLD	5	/* In pixels	*/
+
+#define MARKER_FILLED_BIT		1 << 0
+#define FILLED_HISTORY_BIT		1 << 1
+#define DOT_MIXED_HISTORY_BIT		1 << 2
+#define CIRCLE_HISTORY_BIT		1 << 3
+#define POLAR_BIT			1 << 5
+#define FROZEN_LABEL_BIT		1 << 6
+
+
+/*
+ **********************************************************************************
+ *
+ * Specific Track item record
+ *
+ **********************************************************************************
+ */
+
+typedef struct {
+  RadarPoint	world;	/* world coord of pos    */
+  RadarPoint	dev;	/* dev coord of pos      */
+  RadarBool	visible;
+} HistoryStruct, *History;
+  
+typedef struct _TrackItemStruct {
+  ItemStruct	header;
+  
+  /* Public data */
+  unsigned char		flags;
+  Pixmap		symbol;			/* item symbol			*/
+  RadarColor		symbol_color;
+  int			label_angle;		/* Label angle from track. */
+  int			label_distance;		/* Label distance from track. */
+  int			label_dx;		/* Label dx/dy from track.	*/
+  int			label_dy;
+  RadarAnchor		label_anchor;
+  LeaderAnchors		leader_anchors;		/* Spec of the leader attachment */
+  RadarColor		leader_color;		/* leader color			*/
+  LineStyle		leader_style;
+  LineShape		leader_shape;
+  LineEnd		leader_first_end;
+  LineEnd		leader_last_end;
+  int			leader_width;
+  int			marker_size;		/* world size of error circle	*/
+  RadarColor		marker_color;		/* error circle color		*/
+  LineStyle		marker_style;		/* error circle style		*/
+  Pixmap		marker_fill_pattern;	/* error circle fill pattern	*/
+  RadarColor		connection_color;	/* connection color		*/
+  LineStyle		connection_style;
+  int			connection_width;
+  RadarColor		speed_vector_color;	/* s. v. color			*/
+  int			visible_history_size;	/* Number of visible positions	*/
+  RadarPoint		pos;			/* item world coordinates	*/
+  RadarPoint		speed_vector;		/* s. v. slope in world coord	*/
+
+  /* Private data */
+  FieldSetStruct	field_set;
+  RadarPoint		dev;			/* device coords of current pos */
+  RadarPoint		speed_vector_dev;	/* s. v. end in device coord	*/
+  RadarDim		marker_size_dev;	/* dev size of error circle   	*/
+  RadarList		history;		/* pos list			*/
+  RadarList		leader_points;
+} TrackItemStruct, *TrackItem;
+
+
+static RadarAttrConfig	track_attrs[] = {
+  { RADAR_CONFIG_BOOL, "-circlehistory", NULL,
+    Tk_Offset(TrackItemStruct, flags), CIRCLE_HISTORY_BIT, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-composerotation", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), COMPOSE_ROTATION_BIT,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-composescale", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), COMPOSE_SCALE_BIT,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_ITEM, "-connecteditem", NULL,
+    Tk_Offset(TrackItemStruct, header.connected_item), 0,
+    RADAR_COORDS_FLAG|RADAR_ITEM_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-connectioncolor", NULL,
+    Tk_Offset(TrackItemStruct, connection_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-connectionsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_CONNECTION),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-connectionstyle", NULL,
+    Tk_Offset(TrackItemStruct, connection_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_DIM, "-connectionwidth", NULL,
+    Tk_Offset(TrackItemStruct, connection_width), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-filledhistory", NULL,
+    Tk_Offset(TrackItemStruct, flags), FILLED_HISTORY_BIT, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-filledmarker", NULL,
+    Tk_Offset(TrackItemStruct, flags), MARKER_FILLED_BIT, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-frozenlabel", NULL,
+    Tk_Offset(TrackItemStruct, flags), FROZEN_LABEL_BIT, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_ANCHOR, "-labelanchor", NULL,
+    Tk_Offset(TrackItemStruct, label_anchor), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_ANGLE, "-labelangle", NULL,
+    Tk_Offset(TrackItemStruct, label_angle), 0,
+    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
+  { RADAR_CONFIG_DIM, "-labeldistance", NULL,
+    Tk_Offset(TrackItemStruct, label_distance), 0,
+    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
+  { RADAR_CONFIG_DIM, "-labeldx", NULL,
+    Tk_Offset(TrackItemStruct, label_dx), 0,
+    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
+  { RADAR_CONFIG_DIM, "-labeldy", NULL,
+    Tk_Offset(TrackItemStruct, label_dy), 0,
+    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
+  { RADAR_CONFIG_LABEL_FORMAT, "-labelformat", NULL,
+    Tk_Offset(TrackItemStruct, field_set.label_format), 0,
+    RADAR_COORDS_FLAG|RADAR_CLFC_FLAG, False },
+  { RADAR_CONFIG_LEADER_ANCHORS, "-leaderanchors", NULL,
+    Tk_Offset(TrackItemStruct, leader_anchors), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-leadercolor", NULL,
+    Tk_Offset(TrackItemStruct, leader_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_LINE_END, "-leaderfirstend", NULL,
+    Tk_Offset(TrackItemStruct, leader_first_end), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_LINE_END, "-leaderlastend", NULL,
+    Tk_Offset(TrackItemStruct, leader_last_end), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-leadersensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_LEADER),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-leaderstyle", NULL,
+    Tk_Offset(TrackItemStruct, leader_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_LINE_SHAPE, "-leadershape", NULL,
+    Tk_Offset(TrackItemStruct, leader_shape), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_DIM, "-leaderwidth", NULL,
+    Tk_Offset(TrackItemStruct, leader_width), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-markercolor", NULL,
+    Tk_Offset(TrackItemStruct, marker_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_PATTERN, "-markerfillpattern", NULL,
+    Tk_Offset(TrackItemStruct, marker_fill_pattern), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_DIM, "-markersize", NULL,
+    Tk_Offset(TrackItemStruct, marker_size), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-markerstyle", NULL,
+    Tk_Offset(TrackItemStruct, marker_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-mixedhistory", NULL,
+    Tk_Offset(TrackItemStruct, flags), DOT_MIXED_HISTORY_BIT, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_UINT, "-numfields", NULL,
+    Tk_Offset(TrackItemStruct, field_set.num_fields), 0, 0, True },
+  { RADAR_CONFIG_POINT, "-position", NULL, Tk_Offset(TrackItemStruct, pos), 0,
+    RADAR_COORDS_FLAG|RADAR_MOVED_FLAG, False},
+  { RADAR_CONFIG_PRI, "-priority", NULL,
+    Tk_Offset(TrackItemStruct, header.priority), 0,
+    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), SENSITIVE_BIT, RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_POINT, "-speedvector", NULL, Tk_Offset(TrackItemStruct, speed_vector), 0,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-speedvectorcolor", NULL,
+    Tk_Offset(TrackItemStruct, speed_vector_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-speedvectorsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_SPEED_VECTOR),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_PATTERN, "-symbol", NULL,
+    Tk_Offset(TrackItemStruct, symbol), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-symbolcolor", NULL,
+    Tk_Offset(TrackItemStruct, symbol_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-symbolsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_CURRENT_POSITION),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_TAGS, "-tags", NULL,
+    Tk_Offset(TrackItemStruct, header.tags), 0, 0, False },
+  { RADAR_CONFIG_BOOL, "-visible", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), VISIBLE_BIT,
+    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG|RADAR_VIS_FLAG, False },
+  { RADAR_CONFIG_UINT, "-visiblehistorysize", NULL,
+    Tk_Offset(TrackItemStruct, visible_history_size), 0, RADAR_DRAW_FLAG, False },
+  
+  { RADAR_CONFIG_END, NULL, NULL, 0, 0, 0 }
+};
+
+static RadarAttrConfig	wp_attrs[] = {
+  { RADAR_CONFIG_BOOL, "-composerotation", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), COMPOSE_ROTATION_BIT,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-composescale", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), COMPOSE_SCALE_BIT,
+    RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_ITEM, "-connecteditem", NULL,
+    Tk_Offset(TrackItemStruct, header.connected_item), 0,
+    RADAR_COORDS_FLAG|RADAR_ITEM_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-connectioncolor", NULL,
+    Tk_Offset(TrackItemStruct, connection_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-connectionsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_CONNECTION),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-connectionstyle", NULL,
+    Tk_Offset(TrackItemStruct, connection_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_DIM, "-connectionwidth", NULL,
+    Tk_Offset(TrackItemStruct, connection_width), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-filledmarker", NULL,
+    Tk_Offset(TrackItemStruct, flags), MARKER_FILLED_BIT, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_ANCHOR, "-labelanchor", NULL,
+    Tk_Offset(TrackItemStruct, label_anchor), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_ANGLE, "-labelangle", NULL,
+    Tk_Offset(TrackItemStruct, label_angle), 0,
+    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
+  { RADAR_CONFIG_DIM, "-labeldistance", NULL,
+    Tk_Offset(TrackItemStruct, label_distance), 0,
+    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
+  { RADAR_CONFIG_DIM, "-labeldx", NULL,
+    Tk_Offset(TrackItemStruct, label_dx), 0,
+    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
+  { RADAR_CONFIG_DIM, "-labeldy", NULL,
+    Tk_Offset(TrackItemStruct, label_dy), 0,
+    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
+  { RADAR_CONFIG_LABEL_FORMAT, "-labelformat", NULL,
+    Tk_Offset(TrackItemStruct, field_set.label_format), 0,
+    RADAR_COORDS_FLAG|RADAR_CLFC_FLAG, False },
+  { RADAR_CONFIG_LEADER_ANCHORS, "-leaderanchors", NULL,
+    Tk_Offset(TrackItemStruct, leader_anchors), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-leadercolor", NULL,
+    Tk_Offset(TrackItemStruct, leader_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_LINE_END, "-leaderfirstend", NULL,
+    Tk_Offset(TrackItemStruct, leader_first_end), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_LINE_END, "-leaderlastend", NULL,
+    Tk_Offset(TrackItemStruct, leader_last_end), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-leadersensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_LEADER),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_LINE_SHAPE, "-leadershape", NULL,
+    Tk_Offset(TrackItemStruct, leader_shape), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-leaderstyle", NULL,
+    Tk_Offset(TrackItemStruct, leader_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_DIM, "-leaderwidth", NULL,
+    Tk_Offset(TrackItemStruct, leader_width), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-markercolor", NULL,
+    Tk_Offset(TrackItemStruct, marker_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_PATTERN, "-markerfillpattern", NULL,
+    Tk_Offset(TrackItemStruct, marker_fill_pattern), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_DIM, "-markersize", NULL,
+    Tk_Offset(TrackItemStruct, marker_size), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_LINE_STYLE, "-markerstyle", NULL,
+    Tk_Offset(TrackItemStruct, marker_style), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_UINT, "-numfields", NULL,
+    Tk_Offset(TrackItemStruct, field_set.num_fields), 0, 0, True },
+  { RADAR_CONFIG_POINT, "-position", NULL, Tk_Offset(TrackItemStruct, pos), 0,
+    RADAR_COORDS_FLAG, False},
+  { RADAR_CONFIG_PRI, "-priority", NULL,
+    Tk_Offset(TrackItemStruct, header.priority), 0,
+    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), SENSITIVE_BIT, RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_PATTERN, "-symbol", NULL,
+    Tk_Offset(TrackItemStruct, symbol), 0, RADAR_COORDS_FLAG, False },
+  { RADAR_CONFIG_COLOR, "-symbolcolor", NULL,
+    Tk_Offset(TrackItemStruct, symbol_color), 0, RADAR_DRAW_FLAG, False },
+  { RADAR_CONFIG_BOOL, "-symbolsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(RADAR_CURRENT_POSITION),
+    RADAR_REPICK_FLAG, False },
+  { RADAR_CONFIG_TAGS, "-tags", NULL,
+    Tk_Offset(TrackItemStruct, header.tags), 0, 0, False },
+  { RADAR_CONFIG_BOOL, "-visible", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), VISIBLE_BIT,
+    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG|RADAR_VIS_FLAG, False },
+  
+  { RADAR_CONFIG_END, NULL, NULL, 0, 0, 0 }
+};
+
+
+/*
+ **********************************************************************************
+ *
+ * PointPolarToCartesian --
+ *	Convert a point in polar coordinates in
+ *	a reference system described by heading
+ *	dx_ref, dy_ref to a point in cartesian
+ *	coordinates.
+ *
+ **********************************************************************************
+ */
+static RadarReal
+ProjectionToAngle(RadarDim	dx,
+		  RadarDim	dy)
+{
+  if (dx == 0) {
+    if (dy < 0) {
+      return -M_PI_2;
+    }
+    else if (dy > 0) {
+      return M_PI_2;
+    }
+    else {
+      return 0.0;
+    }
+  }
+  else if (dx < 0) {
+    return atan((double) dy / (double) dx) - M_PI;
+  }
+  else {
+    return atan((double) dy / (double) dx);
+  }
+  return 0.0;
+}
+
+static void
+PointPolarToCartesian(RadarReal	heading,
+		      int	rho,
+		      int	theta,
+		      int	*delta_x,
+		      int	*delta_y)
+{
+  double	to_angle;
+
+  /* Compute angle in trigonometric system */
+  to_angle = DegreesToRadian(theta) + heading - M_PI_2;
+  /*  to_angle = heading - DegreesToRadian(theta);*/
+  /* Compute cartesian coordinates */
+  *delta_x = (int) (rho * cos(to_angle));
+  *delta_y = (int) (rho * sin(to_angle));
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Init --
+ *
+ **********************************************************************************
+ */
+static int
+Init(Item	item,
+     int	*argc,
+     Arg	**args)
+{
+  TrackItem	track = (TrackItem) item;
+  FieldSet	field_set = &track->field_set;
+  WidgetInfo	*wi = item->wi;
+  
+  /*printf("size of a track = %d\n", sizeof(TrackItemStruct));*/
+   
+  SET(item->flags, VISIBLE_BIT);
+  SET(item->flags, SENSITIVE_BIT);
+  SET(item->flags, COMPOSE_ROTATION_BIT);
+  SET(item->flags, COMPOSE_SCALE_BIT);
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(RADAR_CURRENT_POSITION));
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(RADAR_LEADER));
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(RADAR_CONNECTION));
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(RADAR_SPEED_VECTOR));
+  track->symbol_color = RadarGetColorByValue(wi->win, wi->fore_color);
+  track->symbol = Tk_GetBitmap(wi->interp, wi->win, Tk_GetUid("AtcSymbol15"));
+  track->label_anchor = RadarAnchorCenter;
+  track->label_angle = DEFAULT_LABEL_ANGLE;
+  track->label_distance = DEFAULT_LABEL_DISTANCE;
+  SET(track->flags, POLAR_BIT);
+  CLEAR(track->flags, FROZEN_LABEL_BIT);
+  track->leader_anchors = NULL;
+  track->leader_color = RadarGetColorByValue(wi->win, wi->fore_color);
+  track->leader_style = LINE_SIMPLE;
+  track->leader_shape = LINE_STRAIGHT;
+  track->leader_width = DEFAULT_LINE_WIDTH;
+  track->connection_color = RadarGetColorByValue(wi->win, wi->fore_color);
+  track->connection_style = LINE_SIMPLE;
+  track->connection_width = DEFAULT_LINE_WIDTH;
+  track->marker_color = RadarGetColorByValue(wi->win, wi->fore_color);
+  track->marker_style = LINE_SIMPLE;
+  track->marker_fill_pattern = RadarUnspecifiedPattern;
+  track->speed_vector_color = RadarGetColorByValue(wi->win, wi->fore_color);
+  CLEAR(track->flags, MARKER_FILLED_BIT);
+  SET(track->flags, FILLED_HISTORY_BIT);
+  CLEAR(track->flags, DOT_MIXED_HISTORY_BIT);
+  CLEAR(track->flags, CIRCLE_HISTORY_BIT);
+
+  if (item->class == RadarTrack) {
+    item->priority = DEFAULT_TRACK_PRIORITY;
+    track->visible_history_size = DEFAULT_VISIBLE_HISTORY_SIZE;
+    track->marker_size = DEFAULT_MARKER_SIZE;
+    track->speed_vector.x = 0;
+    track->speed_vector.y = 0;
+  }
+  else {
+    item->priority = DEFAULT_WAY_POINT_PRIORITY;
+    track->visible_history_size = 0;
+    track->marker_size = 0;
+    track->speed_vector.x = 0.0;
+    track->speed_vector.y = 10.0;
+  }
+  field_set->wi = wi;
+  field_set->label_format = NULL;
+  /*
+   * Then try to see if some fields are needed.
+   */
+  if ((*argc > 0) && (LangString((*args)[0])[0] != '-') &&
+      (Tcl_GetInt(wi->interp, (args[0])[0], &field_set->num_fields) != RADAR_ERROR)) {
+    *args += 1;
+    *argc -= 1;
+    ITEM_P.InitFields(field_set);
+  }
+  else {
+    Tcl_AppendResult(wi->interp, " number of fields expected", NULL);
+    return RADAR_ERROR;
+  }
+  
+  track->pos.x = 0;
+  track->pos.y = 0;
+  track->field_set.label_pos.x = 0;
+  track->field_set.label_pos.y = 0;
+  track->leader_first_end = NULL;
+  track->leader_last_end = NULL;
+
+  track->history = NULL;
+  track->dev.x = 0;
+  track->dev.y = 0;
+  track->speed_vector_dev.x = 0;
+  track->speed_vector_dev.y = 0;
+  track->marker_size_dev = 0;
+  track->leader_points = NULL;
+
+  return RADAR_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Clone --
+ *
+ **********************************************************************************
+ */
+static void
+Clone(Item	item)
+{
+  TrackItem	track = (TrackItem) item;
+  WidgetInfo	*wi = item->wi;
+
+  if (track->history) {
+    track->history = RadarListDuplicate(track->history);
+  }
+  track->dev.x = 0;
+  track->dev.y = 0;
+  track->speed_vector_dev.x = 0;
+  track->speed_vector_dev.y = 0;
+  track->marker_size_dev = 0;
+  if (track->leader_points) {
+    track->leader_points = RadarListDuplicate(track->leader_points);
+  }
+  if (track->leader_first_end) {
+    LineEndDuplicate(track->leader_first_end);
+  }
+  if (track->leader_last_end) {
+    LineEndDuplicate(track->leader_last_end);
+  }
+  
+  ITEM_P.CloneFields(&track->field_set);
+
+  /*
+   * We get all shared resources, colors bitmaps.
+   */
+  track->symbol_color = RadarGetColorByValue(wi->win, track->symbol_color);
+  track->leader_color = RadarGetColorByValue(wi->win, track->leader_color);
+  track->connection_color = RadarGetColorByValue(wi->win, track->connection_color);
+  track->marker_color = RadarGetColorByValue(wi->win, track->marker_color);
+  track->speed_vector_color = RadarGetColorByValue(wi->win, track->speed_vector_color);
+  if (track->symbol != RadarUnspecifiedPattern) {
+    track->symbol = Tk_GetBitmap(wi->interp, wi->win,
+				 Tk_NameOfBitmap(wi->dpy, track->symbol));
+  }
+  if (track->marker_fill_pattern != RadarUnspecifiedPattern) {
+    track->marker_fill_pattern = Tk_GetBitmap(wi->interp, wi->win,
+					      Tk_NameOfBitmap(wi->dpy, track->marker_fill_pattern));
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Destroy --
+ *
+ **********************************************************************************
+ */
+static void
+Destroy(Item	item)
+{
+  TrackItem	track   = (TrackItem) item;
+  WidgetInfo	*wi = item->wi;
+  
+  if (track->leader_points) {
+    RadarListFree(track->leader_points);
+  }
+  if (track->leader_first_end) {
+    LineEndDelete(track->leader_first_end);
+  }
+  if (track->leader_last_end) {
+    LineEndDelete(track->leader_last_end);
+  }
+
+  if (track->history) {
+    RadarListFree(track->history);
+  }
+  
+  /*
+   * Release shared resources.
+   */
+  RadarFreeColor(track->symbol_color);
+  RadarFreeColor(track->leader_color);
+  RadarFreeColor(track->connection_color);
+  RadarFreeColor(track->marker_color);
+  RadarFreeColor(track->speed_vector_color);
+  if (track->symbol != RadarUnspecifiedPattern) {
+    Tk_FreeBitmap(wi->dpy, track->symbol);
+  }
+  if (track->marker_fill_pattern != RadarUnspecifiedPattern) {
+    Tk_FreeBitmap(wi->dpy, track->marker_fill_pattern);
+  }
+
+  ITEM_P.FreeFields(&track->field_set);
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Configure --
+ *
+ **********************************************************************************
+ */
+static void
+AddToHistory(TrackItem	track,
+	     RadarPoint	old_pos)
+{
+  WidgetInfo	*wi = ((Item) track)->wi;
+  
+  /*printf("Track moved, manage history: %d\n", wi->track_manage_history);*/
+  if (track->history) {
+    if (wi->track_manage_history) {
+      HistoryStruct	hist;
+      
+      hist.world = old_pos;
+      hist.dev = track->dev;
+      hist.visible = True;
+      RadarListAdd(track->history, &hist, RadarListHead);
+      RadarListTruncate(track->history, wi->track_managed_history_size);
+    }
+  }
+  else {
+    /* We do not shift the first time we move as the preceding position
+     * is not valid. */
+    /*printf("creating history\n");*/
+    track->history = RadarListNew(wi->track_managed_history_size+1,
+				  sizeof(HistoryStruct));
+  }
+}
+
+static int
+Configure(Item		item,
+	  int		argc,
+	  RadarAttrList	argv,
+	  int		*flags)
+{
+  TrackItem	track = (TrackItem) item;
+  WidgetInfo	*wi = item->wi;
+  Item		old_connected;
+  RadarPoint	old_pos;
+
+  old_pos = track->pos;
+  old_connected = item->connected_item;
+  
+  if (ITEM_P.ConfigureAttributes((char *) item, -1, argc, argv, flags) == RADAR_ERROR) {
+    return RADAR_ERROR;
+  }
+  
+  /*
+   * Trunc the visible history to the managed size.
+   */
+  track->visible_history_size = MIN(track->visible_history_size,
+				    wi->track_managed_history_size);
+  /*
+   * Adapt to the new label locating system.
+   */
+  if (ISSET(*flags, RADAR_POLAR_FLAG)) {
+    SET(track->flags, POLAR_BIT);
+  }
+  else if (ISSET(*flags, RADAR_CARTESIAN_FLAG)) {
+    CLEAR(track->flags, POLAR_BIT);
+  }
+  
+  if (ISSET(*flags, RADAR_ITEM_FLAG)) {
+    /*
+     * If the new connected item is not appropriate back up
+     * to the old one.
+     */
+    if ((item->connected_item == RADAR_NO_ITEM) ||
+	(((item->connected_item->class == RadarTrack) ||
+	  (item->connected_item->class == RadarWayPoint)) &&
+	 (item->parent == item->connected_item->parent))) {
+      ITEM.UpdateItemDependency(item, old_connected);
+    }
+    else {
+      item->connected_item = old_connected;
+    }
+  }
+  
+#ifdef OM
+  if (ISSET(*flags, RADAR_VIS_FLAG)) {
+    /* Record the change to trigger the overlap manager latter */
+    if ((item->class == RadarTrack) && ISSET(item->flags, VISIBLE_BIT)) {
+      ((GroupItem) item->parent)->call_om = True;
+    }
+  }
+#endif
+  
+  /* If the current position has changed, shift the past pos. */
+  if (ISSET(*flags, RADAR_MOVED_FLAG)) {
+    if (item->class == RadarTrack) {
+      AddToHistory(track, old_pos);
+    }
+  }
+
+  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;
+  TrackItem	track = (TrackItem) item;
+  FieldSet	field_set = &track->field_set;
+  Item		c_item;
+  History	hist;
+  RadarPoint	old_label_pos, old_pos, p, xp;
+  RadarDim	old_label_width, old_label_height;
+  RadarReal	rotation;
+  RadarBBox	bbox;
+  RadarPoint	*points;
+  int		num_acc_pos, i;
+  int		num_points, alignment;
+  int		w2=0, h2=0, w=0, h=0;
+  
+  ResetBBox(&item->item_bounding_box);
+  old_label_pos = field_set->label_pos;
+  old_label_width = field_set->label_width;
+  old_label_height = field_set->label_height;
+
+  /*
+   * Suppress history if history management was turned off.
+   */
+  if ((item->class == RadarTrack) && !wi->track_manage_history) {
+    RadarListEmpty(track->history);
+  }
+
+  old_pos = track->dev;
+
+  RadarTransformPoint(wi->current_transfo, &track->pos, &track->dev);
+  /*printf("track pos %g %g --> %g %g\n", track->pos.x, track->pos.y, track->dev.x, track->dev.y);*/
+  if (track->symbol != RadarUnspecifiedPattern) {
+    Tk_SizeOfBitmap(wi->dpy, track->symbol, &w, &h);
+    /*printf("taille symbole %d %d\n", w, h);*/
+    w2 = (w+1)/2;
+    h2 = (h+1)/2;
+    bbox.orig.x = track->dev.x - w2;
+    bbox.orig.y = track->dev.y - h2;
+    bbox.corner.x = bbox.orig.x + w;
+    bbox.corner.y = bbox.orig.y + h;
+    
+    AddBBoxToBBox(&item->item_bounding_box, &bbox);
+  }
+  
+  /* Here we approximate the past position sizes to the size
+     of the current position. They are actually smaller but who
+     care :-). In fact it is even worse as we use the overall
+     information from the symbol font.
+     */
+  if ((item->class == RadarTrack) && track->history) {
+    ResetBBox(&bbox);
+    num_acc_pos = RadarListSize(track->history);
+    hist = RadarListArray(track->history);
+    for (i = 0; i < num_acc_pos; i++) {
+      RadarTransformPoint(wi->current_transfo, &hist[i].world, &hist[i].dev);
+      if ((i < track->visible_history_size) && (hist[i].visible)) {
+	bbox.orig.x = hist[i].dev.x - w2;
+	bbox.orig.y = hist[i].dev.y - h2;
+	bbox.corner.x = bbox.orig.x + w;
+	bbox.corner.y = bbox.orig.y + h;
+	AddBBoxToBBox(&item->item_bounding_box, &bbox);
+      }
+    }
+  }
+
+  /*
+   * Compute the speed vector end.
+   */
+  if (item->class == RadarTrack) {
+    p.x = track->pos.x + track->speed_vector.x * wi->speed_vector_length;
+    p.y = track->pos.y + track->speed_vector.y * wi->speed_vector_length;
+    RadarTransformPoint(wi->current_transfo, &p, &track->speed_vector_dev);  
+    AddPointToBBox(&item->item_bounding_box, track->speed_vector_dev.x,
+		   track->speed_vector_dev.y);
+  }
+  
+  /*
+   * Take care of the connection between items.
+   */
+  c_item = item->connected_item;
+  if ((c_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
+    ResetBBox(&bbox);
+    w2 = track->connection_width/2;
+    AddPointToBBox(&item->item_bounding_box, track->dev.x-w2, track->dev.y-w2);
+    AddPointToBBox(&item->item_bounding_box, ((TrackItem)c_item)->dev.x+w2,
+		   ((TrackItem)c_item)->dev.y+w2);
+  }
+
+  /*
+   * Compute the size of the circular marker.
+   */
+  p.x = track->pos.x + track->marker_size;
+  p.y = track->pos.y;
+  RadarTransformPoint(wi->current_transfo, &p, &xp);
+  xp.x = xp.x - track->dev.x;
+  xp.y = xp.y - track->dev.y;
+  track->marker_size_dev = sqrt(xp.x*xp.x + xp.y*xp.y);
+  if (track->marker_size_dev > PRECISION_LIMIT) {
+    AddPointToBBox(&item->item_bounding_box,
+		   track->dev.x - (RadarPos) track->marker_size_dev,
+		   track->dev.y - (RadarPos) track->marker_size_dev);
+    AddPointToBBox(&item->item_bounding_box,
+		   track->dev.x + (RadarPos) track->marker_size_dev,
+		   track->dev.y + (RadarPos) track->marker_size_dev);
+  } 
+  
+  /* Compute the new label bounding box. */
+  if (field_set->label_format) {
+    RadarDim	bb_width, bb_height, dist;
+    RadarPoint	leader_end;
+
+    ITEM_P.GetLabelBBox(field_set, &bb_width, &bb_height);
+    /*
+     * Compute the label position.
+     */
+    if (ISCLEAR(track->flags, FROZEN_LABEL_BIT)) {
+      if (ISSET(track->flags, POLAR_BIT)) {
+	/*
+	 * Adjust the min dist spec given in label_distance by
+	 * the size of the label.
+	 */
+	if ((track->label_anchor == RadarAnchorN) ||
+	    (track->label_anchor == RadarAnchorCenter) ||
+	    (track->label_anchor == RadarAnchorS)) {
+	  dist = sqrt(bb_width*bb_width/4+bb_height*bb_height/4);
+	}
+	else {
+	  dist = sqrt(bb_width*bb_width+bb_height*bb_height);
+	}
+	dist += track->label_distance;
+	/*
+	 * Compute heading after applying the transform.
+	 */
+	RadarTransfoDecompose(wi->current_transfo, NULL, NULL, &rotation, NULL);
+	/*printf("rotation=%g, heading=%g, angle=%d\n", rotation,
+	  ProjectionToAngle(track->speed_vector.x, track->speed_vector.y),
+	  track->label_angle);*/
+	rotation = ProjectionToAngle(track->speed_vector.x, track->speed_vector.y)-rotation;
+	PointPolarToCartesian(rotation, dist, track->label_angle,
+			      &track->label_dx, &track->label_dy);
+      }
+      field_set->label_pos.x = track->dev.x + track->label_dx;
+      field_set->label_pos.y = track->dev.y - track->label_dy;
+      Anchor2Origin(&field_set->label_pos, bb_width, bb_height,
+		    track->label_anchor, &field_set->label_pos);
+    }
+    
+    AddPointToBBox(&item->item_bounding_box, field_set->label_pos.x,
+		   field_set->label_pos.y);
+    AddPointToBBox(&item->item_bounding_box,
+		   field_set->label_pos.x + (RadarPos) bb_width,
+		   field_set->label_pos.y + (RadarPos) bb_height);
+
+    /*
+     * Process the leader.
+     */
+    if (track->leader_width > 0) {
+      int	left_x, left_y, right_x, right_y;
+      RadarPoint end_points[LINE_END_POINTS];
+      
+      /*
+       * Compute the actual leader end in the label.
+       */
+      if (track->leader_anchors) {
+	left_x = track->leader_anchors->left_x;
+	right_x = track->leader_anchors->right_x;
+	left_y = track->leader_anchors->left_y;
+	right_y = track->leader_anchors->right_y;
+      }
+      else {
+	left_x = right_x = left_y = right_y = 50;
+      }
+      if (track->label_angle >= 270 || track->label_angle < 90) {
+	if (track->leader_anchors && (left_y < 0)) {
+	  ITEM_P.GetFieldBBox(field_set, left_x, &bbox);
+	  leader_end.x = bbox.orig.x;
+	  leader_end.y = bbox.corner.y;
+	}
+	else {
+	  leader_end.x = field_set->label_pos.x + left_x*bb_width/100;
+	  leader_end.y = field_set->label_pos.y + left_y*bb_height/100;
+	}
+	alignment = AA_LEFT;
+      }
+      else {
+	if (track->leader_anchors && (right_y < 0)) {
+	  ITEM_P.GetFieldBBox(field_set, right_x, &bbox);
+	  leader_end.x = bbox.corner.x;
+	  leader_end.y = bbox.corner.y;
+	}
+	else {
+	  leader_end.x = field_set->label_pos.x + right_x*bb_width/100;
+	  leader_end.y = field_set->label_pos.y + right_y*bb_height/100;
+	}
+	alignment = AA_RIGHT;
+      }
+      
+      ITEM.SetFieldsAutoAlign(item, alignment);
+
+      /* Clip the leader on the label's fields */
+      ITEM_P.LeaderToLabel(field_set, &track->dev, &leader_end);
+
+      /* Setup leader shape points */
+      if (!track->leader_points) {
+	track->leader_points = RadarListNew(LINE_SHAPE_POINTS, sizeof(RadarPoint));
+      }
+      GetLineShape(&track->dev, &leader_end, track->leader_width,
+			track->leader_shape, &bbox, track->leader_points);
+      AddBBoxToBBox(&item->item_bounding_box, &bbox);
+      points = (RadarPoint *) RadarListArray(track->leader_points);
+      num_points = RadarListSize(track->leader_points);
+
+      /* Setup leader ends */
+      if (track->leader_first_end != NULL) {
+	GetLineEnd(&points[0], &points[1], track->leader_width,
+		   CapRound, track->leader_first_end, end_points);
+	AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+      }
+      if (track->leader_last_end != NULL) {
+	GetLineEnd(&points[num_points-1], &points[num_points-2], track->leader_width,
+		   CapRound, track->leader_last_end, end_points);
+	AddPointsToBBox(&item->item_bounding_box, end_points, LINE_END_POINTS);
+      }
+    }
+  }
+
+  /* Update connected items. */
+  if ((old_label_pos.x != field_set->label_pos.x) ||
+      (old_label_pos.y != field_set->label_pos.y) ||
+      (old_label_width != field_set->label_width) ||
+      (old_label_height != field_set->label_height) ||
+      (old_pos.x != track->dev.x) ||
+      (old_pos.y != track->dev.y)) {
+    /* Update connected items */
+    SET(item->flags, UPDATE_DEPENDENT_BIT);
+
+#ifdef OM
+    /* Record the move to trigger the overlap manager latter */
+    if (item->class == RadarTrack) {
+      ((GroupItem) item->parent)->call_om = True;
+    }
+#endif
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * 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)
+{
+  WidgetInfo	*wi = item->wi;
+  TrackItem	track = (TrackItem) item;
+  int		inside;
+  int		width, height;
+  RadarDim	lwidth, lheight;
+  RadarBBox	bbox;
+
+  /*
+   * Try the current position.
+   */
+  ResetBBox(&bbox);
+  if (track->symbol != RadarUnspecifiedPattern) {
+    Tk_SizeOfBitmap(wi->dpy, track->symbol, &width, &height);
+    bbox.orig.x = track->dev.x-(width+1)/2;
+    bbox.orig.y = track->dev.y-(height+1)/2;
+    bbox.corner.x = bbox.orig.x + width;
+    bbox.corner.y = bbox.orig.y + height;
+  }
+  inside = BBoxInBBox(&bbox, area);
+  if (inside == 0) {
+    printf("track pos\n");    
+    return 0;
+  }
+  
+  /*
+   * Try the fields.
+   */
+  ITEM_P.GetLabelBBox(&track->field_set, &lwidth, &lheight);
+  if ((lwidth > 0.0) && (lheight > 0.0)) {
+    if (ITEM_P.FieldsToArea(&track->field_set, area) != inside) {
+      return 0;
+    }
+  }
+  
+  /*
+   * Try the leader.
+   */
+  if (track->field_set.label_format && (track->leader_width > 0)) {
+    RadarPoint end_points[LINE_END_POINTS];
+    RadarPoint *points;
+    int	       num_points;
+
+    points = (RadarPoint *) RadarListArray(track->leader_points);
+    num_points = RadarListSize(track->leader_points);
+    width = track->leader_width > 1 ? track->leader_width : 0;
+    if (PolylineInBBox(points, num_points, width,
+		       CapRound, JoinRound, area) != inside) {
+      printf("track leader\n");
+      return 0;
+    }
+    if (track->leader_first_end != NULL) {
+      GetLineEnd(&points[0], &points[1], track->leader_width,
+		 CapRound, track->leader_first_end, end_points);
+      if (PolygonInBBox(end_points, LINE_END_POINTS, area) != inside) {
+	printf("track leader\n");
+	return 0;
+      }
+    }
+    if (track->leader_last_end != NULL) {
+      GetLineEnd(&points[num_points-1], &points[num_points-2], track->leader_width,
+		 CapRound, track->leader_last_end, end_points);
+      if (PolygonInBBox(end_points, LINE_END_POINTS, area) != inside) {
+	printf("track leader\n");
+	return 0;
+      }
+    }
+  }
+
+  /*
+   * Try the speed vector.
+   */
+  if (item->class == RadarTrack) {
+    if (LineInBBox(&track->dev, &track->speed_vector_dev, area) != inside) {
+      printf("track speed vector\n");
+      return 0;
+    }
+  }
+
+  /*
+   * Try the connection.
+   */
+  if ((item->connected_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
+    RadarPoint	pts[2];
+    
+    pts[0] = track->dev;
+    pts[1] = ((TrackItem) item->connected_item)->dev;
+    width = track->connection_width > 1 ? track->connection_width : 0;
+    if (PolylineInBBox(pts, 2, width, CapRound, JoinRound, area) != inside) {
+      printf("track connection\n");
+      return 0;
+    }
+  }
+
+  return inside;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Draw --
+ *
+ **********************************************************************************
+ */
+
+static void
+Draw(Item	item)
+{
+  WidgetInfo	*wi = item->wi;
+  TrackItem	track = (TrackItem) item;
+  Item	        c_item;
+  char		tmp_str[] = ".";
+  XGCValues	values;
+  History	hist;
+  int		h_side_size, side_size, width=0, height=0;
+  int		i, nb_hist, num_acc_pos;
+
+
+  /* Draw the marker */
+  if (track->marker_size_dev != 0) {
+    SetLineStyle(wi->dpy, wi->gc, track->marker_style);
+    values.foreground = RadarPixel(track->marker_color);
+    values.line_width = 0;
+    if (ISSET(track->flags, MARKER_FILLED_BIT)) {
+      if (track->marker_fill_pattern == RadarUnspecifiedPattern) {
+	/* Fill solid */
+	values.fill_style = FillSolid;
+	XChangeGC(wi->dpy, wi->gc, GCFillStyle | GCLineWidth | GCForeground, &values);
+      }
+      else {
+	/* Fill stippled */
+	values.fill_style = FillStippled;
+	values.stipple = track->marker_fill_pattern;
+	XChangeGC(wi->dpy, wi->gc,
+		  GCFillStyle | GCStipple | GCLineWidth | GCForeground, &values);
+      }
+      XFillArc(wi->dpy, wi->draw_buffer, wi->gc,
+	       track->dev.x - (RadarPos) track->marker_size_dev,
+	       track->dev.y - (RadarPos) track->marker_size_dev,
+	       track->marker_size_dev * 2, track->marker_size_dev * 2,
+	       0, 360 * 64);
+    }
+    else {
+      XChangeGC(wi->dpy, wi->gc, GCLineWidth | GCForeground, &values);
+      XDrawArc(wi->dpy, wi->draw_buffer, wi->gc,
+	       track->dev.x - (RadarPos) track->marker_size_dev,
+	       track->dev.y - (RadarPos) track->marker_size_dev,
+	       track->marker_size_dev * 2, track->marker_size_dev * 2,
+	       0, 360 * 64);
+    }
+  }
+  
+  /*
+   * Draw the connection.
+   */
+  c_item = item->connected_item;
+  if ((c_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
+    RadarPoint	pts[2];
+    
+    pts[0] = track->dev;
+    pts[1] = ((TrackItem) item->connected_item)->dev;
+    DrawLineShape(wi->dpy, wi->draw_buffer, wi->gc, pts, 2,
+		  track->connection_style, track->connection_color,
+		  track->connection_width, LINE_STRAIGHT);
+  }
+
+  /*
+   * Draw the speed vector.
+   */
+  if (item->class == RadarTrack) {
+    values.foreground = RadarPixel(track->speed_vector_color);
+    values.line_width = 0;
+    values.line_style = LineSolid;
+    values.fill_style = FillSolid;
+    XChangeGC(wi->dpy, wi->gc,
+	      GCForeground | GCLineWidth | GCLineStyle | GCFillStyle, &values);
+    XDrawLine(wi->dpy, wi->draw_buffer, wi->gc, track->dev.x, track->dev.y,
+	      track->speed_vector_dev.x, track->speed_vector_dev.y);
+  }
+  
+  /*
+   * Draw the leader.
+   */
+  if (track->field_set.label_format && track->leader_width > 0) {
+    RadarPoint end_points[LINE_END_POINTS];
+    XPoint     xpoints[LINE_END_POINTS];
+    RadarPoint *points;
+    int	       num_points;
+
+    points = (RadarPoint *) RadarListArray(track->leader_points);
+    num_points = RadarListSize(track->leader_points);
+    DrawLineShape(wi->dpy, wi->draw_buffer, wi->gc,
+		  points, num_points,
+		  track->leader_style, track->leader_color,
+		  track->leader_width, track->leader_shape);
+    if (track->leader_first_end != NULL) {
+      GetLineEnd(&points[0], &points[1], track->leader_width,
+		 CapRound, track->leader_first_end, end_points);
+      for (i = 0; i < LINE_END_POINTS; i++) {
+	xpoints[i].x = end_points[i].x;
+	xpoints[i].y = end_points[i].y;
+      }
+      XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xpoints, LINE_END_POINTS,
+		   Nonconvex, CoordModeOrigin);
+    }
+    if (track->leader_last_end != NULL) {
+      GetLineEnd(&points[num_points-1], &points[num_points-2], track->leader_width,
+		 CapRound, track->leader_last_end, end_points);
+      for (i = 0; i < LINE_END_POINTS; i++) {
+	xpoints[i].x = end_points[i].x;
+	xpoints[i].y = end_points[i].y;
+      }
+      XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xpoints, LINE_END_POINTS,
+		   Nonconvex, CoordModeOrigin);
+    }
+  }
+  
+  tmp_str[0] = track->symbol;
+  values.foreground = RadarPixel(track->symbol_color);
+  values.fill_style = FillSolid;
+  XChangeGC(wi->dpy, wi->gc, GCForeground|GCFillStyle, &values);  
+  if (track->symbol != RadarUnspecifiedPattern) {
+    Tk_SizeOfBitmap(wi->dpy, track->symbol, &width, &height);
+  }
+  
+  /*
+   * Draw the history, current pos excepted.
+   */
+  if ((item->class == RadarTrack) && track->history) {
+    if (ISCLEAR(track->flags, FILLED_HISTORY_BIT)) {
+      values.line_width = 0;
+      values.line_style = LineSolid;
+      XChangeGC(wi->dpy, wi->gc, GCLineWidth | GCLineStyle, &values);
+    }
+    num_acc_pos = RadarListSize(track->history);
+    hist = RadarListArray(track->history);
+    side_size = MAX(width, height);
+    for (i = 0, nb_hist = 0;
+	 i < MIN(track->visible_history_size, num_acc_pos); i++) {
+      side_size--;
+      side_size = MAX(1, side_size);
+      h_side_size = (side_size+1)/2;
+      if (hist[i].visible) {
+	if (ISSET(track->flags, DOT_MIXED_HISTORY_BIT) && !(nb_hist++ % 2)) {
+	  XDrawPoint(wi->dpy, wi->draw_buffer, wi->gc, hist[i].dev.x, hist[i].dev.y);
+	}
+	else {
+	  if (ISSET(track->flags, CIRCLE_HISTORY_BIT)) {
+	    if (ISSET(track->flags, FILLED_HISTORY_BIT)) {
+	      XFillArc(wi->dpy, wi->draw_buffer, wi->gc,  
+		       hist[i].dev.x - h_side_size, hist[i].dev.y - h_side_size,
+		       side_size, side_size, 0, 360*64);
+	    }
+	    else {
+	      XDrawArc(wi->dpy, wi->draw_buffer, wi->gc,  
+		       hist[i].dev.x - h_side_size, hist[i].dev.y - h_side_size,
+		       side_size - 1, side_size - 1, 0, 360*64);
+	    }
+	  }
+	  else {
+	    if (ISSET(track->flags, FILLED_HISTORY_BIT)) {
+	      XFillRectangle(wi->dpy, wi->draw_buffer, wi->gc,  
+			     hist[i].dev.x - h_side_size, hist[i].dev.y - h_side_size,
+			     side_size, side_size);
+	    }
+	    else {
+	      XDrawRectangle(wi->dpy, wi->draw_buffer, wi->gc,  
+			     hist[i].dev.x - h_side_size, hist[i].dev.y - h_side_size,
+			     side_size - 1, side_size - 1);
+	    }
+	  }
+	}
+      }
+    }
+  }
+
+  /*
+   * Draw the current position using a pattern for Tk.
+   */
+  if (track->symbol != RadarUnspecifiedPattern) {
+    int x = track->dev.x - (width+1)/2;
+    int y = track->dev.y - (height+1)/2;
+    values.fill_style = FillStippled;
+    values.stipple = track->symbol;
+    values.ts_x_origin = x;
+    values.ts_y_origin = y;
+    XChangeGC(wi->dpy, wi->gc,
+	      GCFillStyle|GCStipple|GCTileStipXOrigin|GCTileStipYOrigin, &values);
+    XFillRectangle(wi->dpy, wi->draw_buffer, wi->gc, x, y, width, height);
+  }
+
+  /*
+   * Draw the label.
+   */
+  ITEM_P.DrawFields(&track->field_set);
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * IsSensitive --
+ *
+ **********************************************************************************
+ */
+static RadarBool
+IsSensitive(Item	item,
+	    int		item_part)
+{
+  if (ISCLEAR(item->flags, SENSITIVE_BIT) ||
+      !item->parent->class->IsSensitive(item->parent, RADAR_NO_PART)) {
+    return False;
+  }
+  
+  if (item_part < RADAR_NO_PART) {
+    return ISSET(item->part_sensitive, PART_NUMBER_TO_BIT(item_part));
+  }
+  else if (item_part >= 0) {
+    return ITEM_P.IsFieldSensitive(&((TrackItem) item)->field_set, item_part);
+  }
+  return True;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Pick --
+ *
+ **********************************************************************************
+ */
+static double
+Pick(Item	item,
+     RadarPoint	*p,
+     Item	start_item,
+     int	aperture,
+     Item	*a_item,
+     int	*part)
+{
+  WidgetInfo	*wi= item->wi;
+  TrackItem	track = (TrackItem) item;
+  Item		c_item;
+  RadarBBox	bbox;
+  double	dist=0, new_dist;
+  RadarPoint	*points;
+  int		num_points, i;
+  int		width=0, height=0;
+  double	width_2;
+  int		best_part;
+  
+  /*
+   * Try one of the fields.
+   */
+  dist = ITEM_P.FieldsPick(&track->field_set, p, &best_part);
+  if (dist <= 0.0) {
+    goto report0;
+  }
+
+  /*
+   * Try the current position symbol.
+   */
+  ResetBBox(&bbox);
+  if (track->symbol != RadarUnspecifiedPattern) {
+    Tk_SizeOfBitmap(wi->dpy, track->symbol, &width, &height);
+    bbox.orig.x = track->dev.x-(width+1)/2;
+    bbox.orig.y = track->dev.y-(height+1)/2;
+    bbox.corner.x = bbox.orig.x + width;
+    bbox.corner.y = bbox.orig.y + height;
+  }
+
+  new_dist = RectangleToPointDist(&bbox, p);
+  if (new_dist < dist) {
+    best_part = RADAR_CURRENT_POSITION;
+    dist = new_dist;
+  }
+  if (dist <= 0.0) {
+    goto report0;
+  }
+  
+  /*
+   * Try the leader.
+   */
+  if (track->field_set.label_format && (track->leader_width > 0)) {
+    RadarPoint end_points[LINE_END_POINTS];
+
+    width_2 = (track->leader_width>1) ? ((double) track->leader_width)/2.0 : 0;
+    points = (RadarPoint *) RadarListArray(track->leader_points);
+    num_points = RadarListSize(track->leader_points)-1;
+    for (i = 0; i < num_points; i++) {
+      new_dist = LineToPointDist(&points[i], &points[i+1], p);
+      new_dist -= width_2;
+      if (new_dist < dist) {
+	best_part = RADAR_LEADER;
+	dist = new_dist;
+      }
+      if (dist <= 0.0) {
+	goto report0;
+      }
+    }
+    if (track->leader_first_end != NULL) {
+      GetLineEnd(&points[0], &points[1], track->leader_width,
+		 CapRound, track->leader_first_end, end_points);
+      new_dist = PolygonToPointDist(end_points, LINE_END_POINTS, p);
+      if (new_dist < dist) {
+	best_part = RADAR_LEADER;
+	dist = new_dist;	
+      }
+      if (dist <= 0.0) {
+	goto report0;
+      }
+    }
+    if (track->leader_last_end != NULL) {
+      GetLineEnd(&points[num_points-1], &points[num_points-2], track->leader_width,
+		 CapRound, track->leader_last_end, end_points);
+      new_dist = PolygonToPointDist(end_points, LINE_END_POINTS, p);
+      if (new_dist < dist) {
+	best_part = RADAR_LEADER;
+	dist = new_dist;	
+      }
+      if (dist <= 0.0) {
+	goto report0;
+      }
+    }
+  }
+
+  /*
+   * Try the speed vector.
+   */
+  if (item->class == RadarTrack) {
+    new_dist = LineToPointDist(&track->dev, &track->speed_vector_dev, p);
+    if (new_dist < dist) {
+      best_part = RADAR_SPEED_VECTOR;
+      dist = new_dist;
+    }
+    if (dist <= 0.0) {
+      goto report0;
+    }
+  }
+
+  /*
+   * Try the connection.
+   */
+  c_item = item->connected_item;
+  if ((c_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
+    RadarPoint	pts[2];
+		   
+    pts[0] = track->dev;
+    pts[1] = ((TrackItem) item->connected_item)->dev;
+    new_dist = PolylineToPointDist(pts, 2, track->connection_width,
+				   CapRound, JoinRound, p);
+    if (new_dist < dist) {
+      dist = new_dist;
+      best_part = RADAR_CONNECTION;
+    }
+    if (dist <= 0.0) {
+    report0:
+      dist = 0.0;
+    }
+  }
+
+  /* printf("track %d reporting part %d, distance %lf\n",
+	 item->id, best_part, dist); */
+  *part = best_part;
+  return dist;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * PostScript --
+ *
+ **********************************************************************************
+ */
+static void
+PostScript(Item			item,
+	   PostScriptInfo	ps_info)
+{
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * SendTrackToOm --
+ *
+ **********************************************************************************
+ */
+/*
+ * TODO:
+ *
+ *   The tracks should be identified by their ids not their
+ *   structure pointer. This would enable an easy interface
+ *   between the overlap manager and the applications when
+ *   dealing with tracks.
+ */
+void *
+SendTrackToOm(void	*ptr,
+	      void	*item,
+	      int	*x,
+	      int	*y,
+	      int	*sv_dx,
+	      int	*sv_dy,
+	      int	*label_x,
+	      int	*label_y,
+	      int	*label_width,
+	      int	*label_height,
+	      int	*rho,
+	      int	*theta,
+	      int	*visibility)
+{
+  WidgetInfo	*wi = (WidgetInfo *) ptr;
+  Item		current_item = (Item) item;
+  TrackItem	track;
+  RadarBBox	radar_bbox, bbox;
+  RadarBool	to_be_sent;
+
+  radar_bbox.orig.x = radar_bbox.orig.y = 0;
+  radar_bbox.corner.x = wi->width;
+  radar_bbox.corner.y = wi->height;
+
+  if (current_item == RADAR_NO_ITEM) {
+    current_item = ((GroupItem) wi->top_group)->head;
+  }
+  else {
+    current_item = current_item->next;
+  }
+
+  while (current_item != RADAR_NO_ITEM) {
+    to_be_sent = current_item->class == RadarTrack;
+
+    /* We send invisibles items because the current algorithm
+       take care of the age of the tracks.
+       to_be_sent &= ISSET(current_item->flags, VISIBLE_BIT);*/
+
+    IntersectBBox(&radar_bbox, &current_item->item_bounding_box, &bbox);
+    to_be_sent &= !IsEmptyBBox(&bbox);
+    
+    if (to_be_sent) {
+      track = (TrackItem) current_item;
+      
+      *x = track->dev.x;
+      *y = wi->height - track->dev.y;
+
+      /*
+       * We must send world values for speed vector deltas as device
+       * equivalents can be null. But then if the image is rotated this
+       * is nonsense.
+       */
+      *sv_dx = track->speed_vector.x;
+      *sv_dy = track->speed_vector.y;
+      
+      *label_x = track->field_set.label_pos.x;
+      *label_y = wi->height - track->field_set.label_pos.y;
+      if (track->field_set.label_format) {
+	RadarDim	bb_width, bb_height;
+
+	ITEM_P.GetLabelBBox(&track->field_set, &bb_width, &bb_height);
+	*label_width = bb_width;
+	*label_height = bb_height;
+      }
+      else {
+	*label_width = 0;
+	*label_height = 0;
+      }
+      *rho = sqrt(track->label_dx*track->label_dx + track->label_dy*track->label_dy);
+      *theta = track->label_angle;
+      break;
+    }
+    
+    current_item = current_item->next;
+  }
+  
+  return (void *) current_item;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * SetLabelAngleFromOm --
+ *
+ **********************************************************************************
+ */
+void
+SetLabelAngleFromOm(void	*ptr,	/* No longer in use. */
+		    void	*item,
+		    int		theta)
+{
+  TrackItem	track = (TrackItem) item;
+
+  theta %= 360;
+
+  if ((theta >= 0) && (track->label_angle != theta)) {
+    track->label_angle = theta;
+    ITEM.Invalidate((Item) item, RADAR_COORDS_FLAG);
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * QueryLabelPosition -- OverlapMan query the widget about what would be the
+ *			 label position if label_angle is theta
+ *
+ **********************************************************************************
+ */
+void
+QueryLabelPosition(void	*ptr,	/* No longer in use. */
+		   void	*item,
+		   int	theta,
+		   int*	x,
+		   int*	y,
+		   int*	w,
+		   int*	h)
+{
+  Item		it = (Item) item;
+  WidgetInfo	*wi = it->wi;
+  TrackItem	track = (TrackItem) it;
+  
+  if (track->field_set.label_format) {
+    RadarDim	bb_width, bb_height;
+    int		delta_x, delta_y;
+    RadarReal	heading;
+    
+    /*
+     * !! BUG !! This doesn't work if the current transform has some rotation.
+     */
+    heading = ProjectionToAngle(track->speed_vector.x, track->speed_vector.y);
+    PointPolarToCartesian(heading, track->label_distance, theta, &delta_x, &delta_y);
+    ITEM_P.GetLabelBBox(&track->field_set, &bb_width, &bb_height);
+    /*
+     * !! BUG !! This assume a label placing relative to the center anchor.
+     * We must fix this by taking into account the label anchor.
+     */
+    *x = track->dev.x + (RadarPos) (delta_x - bb_width/2);
+    *y = track->dev.y - (RadarPos) (delta_y + bb_height/2);
+    *y = wi->height - *y;
+    *w = bb_width;
+    *h = bb_height;
+  }
+  else {
+    *x = *y = *w = *h = 0;
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * SetHistoryVisibility -- PLC - not yet implemented
+ *
+ **********************************************************************************
+ */
+void
+SetHistoryVisibility(Item	item,
+		     int	index,
+		     RadarBool	visible)
+{
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * TruncHistory -- PLC - not yet interfaced
+ *
+ **********************************************************************************
+ */
+void
+TruncHistory(Item	item)
+{
+  TrackItem	track = (TrackItem) item;
+
+  if (track->history) {
+    int size = RadarListSize (track->history);
+    History hist_tbl = RadarListArray (track->history);
+    while (size--) {
+      hist_tbl[size].visible = False;
+    }
+    ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetFieldSet --
+ *
+ **********************************************************************************
+ */
+static FieldSet
+GetFieldSet(Item	item)
+{
+  return &((TrackItem) item)->field_set;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * GetAnchor --
+ *
+ **********************************************************************************
+ */
+static void
+GetAnchor(Item		item,
+	  RadarAnchor	anchor,
+	  RadarPoint	*p)
+{
+  FieldSet	field_set = &((TrackItem) item)->field_set;
+  RadarDim	width, height;
+  
+  if (field_set->label_format) {
+    ITEM_P.GetLabelBBox(field_set, &width, &height);
+    Origin2Anchor(&field_set->label_pos, width, height, anchor, p);
+  }
+  else {
+    p->x = p->y = 0.0;
+  }
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Coords --
+ *	Return or edit the item position.
+ *
+ **********************************************************************************
+ */
+static int
+Coords(Item		item,
+       int		index,
+       int		cmd,
+       RadarPoint	**pts,
+       int		*num_pts)
+{
+  TrackItem	track = (TrackItem) item;
+  
+  if ((cmd == COORDS_ADD) || (cmd == COORDS_ADD_LAST) || (cmd == COORDS_REMOVE)) {
+    Tcl_AppendResult(item->wi->interp, " ",
+		     item->class->name, "s can't add or remove vertices", NULL);
+    return RADAR_ERROR;
+  }
+  else if ((cmd == COORDS_REPLACE) || (cmd == COORDS_REPLACE_ALL)) {
+    if (*num_pts == 0) {
+      Tcl_AppendResult(item->wi->interp,
+		       " coords command need 1 point on ",
+		       item->class->name, "s", NULL);
+      return RADAR_ERROR;
+    }
+    if (item->class == RadarTrack) {
+      AddToHistory(track, track->pos);
+    }
+    track->pos = (*pts)[0];
+    ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+  }
+  else if ((cmd == COORDS_READ) || (cmd == COORDS_READ_ALL)) {
+    *num_pts = 1;
+    *pts = &track->pos;
+  }
+  return RADAR_OK;
+}
+
+
+/*
+ **********************************************************************************
+ *
+ * Exported functions struct --
+ *
+ **********************************************************************************
+ */
+static ItemClassStruct TRACK_ITEM_CLASS = {
+  sizeof(TrackItemStruct),
+  True,
+  True,
+  True,
+  "track",
+  track_attrs,
+  Init,
+  Clone,
+  Destroy,
+  Configure,
+  Query,
+  GetFieldSet,
+  GetAnchor,
+  NULL,
+  Coords,
+  ComputeCoordinates,
+  ToArea,
+  Draw,
+  IsSensitive,
+  Pick,
+  PostScript
+};
+
+static ItemClassStruct WAY_POINT_ITEM_CLASS = {
+  sizeof(TrackItemStruct),
+  True,
+  True,
+  True,
+  "waypoint",
+  wp_attrs,
+  Init,
+  Clone,
+  Destroy,
+  Configure,
+  Query,
+  GetFieldSet,
+  GetAnchor,
+  NULL,
+  Coords,
+  ComputeCoordinates,
+  ToArea,
+  Draw,
+  IsSensitive,
+  Pick,
+  PostScript
+};
+
+RadarItemClassId RadarTrack = (RadarItemClassId) &TRACK_ITEM_CLASS;
+RadarItemClassId RadarWayPoint = (RadarItemClassId) &WAY_POINT_ITEM_CLASS;