Passage en Zinc

1 files changed, 366 insertions, 366 deletions

diff --git a/generic/Track.c b/generic/Track.c
index bcfdcf5..a5e17dc 100644
--- a/generic/Track.c
+++ b/generic/Track.c
@@ -58,9 +58,9 @@ static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ "
  */
 
 typedef struct {
-  RadarPoint	world;	/* world coord of pos    */
-  RadarPoint	dev;	/* dev coord of pos      */
-  RadarBool	visible;
+  ZnPoint	world;	/* world coord of pos    */
+  ZnPoint	dev;	/* dev coord of pos      */
+  ZnBool	visible;
 } HistoryStruct, *History;
   
 typedef struct _TrackItemStruct {
@@ -69,232 +69,232 @@ typedef struct _TrackItemStruct {
   /* Public data */
   unsigned char		flags;
   Pixmap		symbol;			/* item symbol			*/
-  RadarColor		symbol_color;
+  ZnColor		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;
+  ZnAnchor		label_anchor;
   LeaderAnchors		leader_anchors;		/* Spec of the leader attachment */
-  RadarColor		leader_color;		/* leader color			*/
+  ZnColor		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		*/
+  ZnColor		marker_color;		/* error circle color		*/
   LineStyle		marker_style;		/* error circle style		*/
   Pixmap		marker_fill_pattern;	/* error circle fill pattern	*/
-  RadarColor		connection_color;	/* connection color		*/
+  ZnColor		connection_color;	/* connection color		*/
   LineStyle		connection_style;
   int			connection_width;
-  RadarColor		speed_vector_color;	/* s. v. color			*/
+  ZnColor		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	*/
+  ZnPoint		pos;			/* item world coordinates	*/
+  ZnPoint		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;
+  ZnPoint		dev;			/* device coords of current pos */
+  ZnPoint		speed_vector_dev;	/* s. v. end in device coord	*/
+  ZnDim			marker_size_dev;	/* dev size of error circle   	*/
+  ZnList		history;		/* pos list			*/
+  ZnList		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,
+static ZnAttrConfig	track_attrs[] = {
+  { ZN_CONFIG_BOOL, "-circlehistory", NULL,
+    Tk_Offset(TrackItemStruct, flags), CIRCLE_HISTORY_BIT, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-composerotation", NULL,
     Tk_Offset(TrackItemStruct, header.flags), COMPOSE_ROTATION_BIT,
-    RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_BOOL, "-composescale", NULL,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-composescale", NULL,
     Tk_Offset(TrackItemStruct, header.flags), COMPOSE_SCALE_BIT,
-    RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_ITEM, "-connecteditem", NULL,
+    ZN_COORDS_FLAG, False },
+  { ZN_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,
+    ZN_COORDS_FLAG|ZN_ITEM_FLAG, False },
+  { ZN_CONFIG_COLOR, "-connectioncolor", NULL,
+    Tk_Offset(TrackItemStruct, connection_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-connectionsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_CONNECTION),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-connectionstyle", NULL,
+    Tk_Offset(TrackItemStruct, connection_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_DIM, "-connectionwidth", NULL,
+    Tk_Offset(TrackItemStruct, connection_width), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-filledhistory", NULL,
+    Tk_Offset(TrackItemStruct, flags), FILLED_HISTORY_BIT, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-filledmarker", NULL,
+    Tk_Offset(TrackItemStruct, flags), MARKER_FILLED_BIT, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-frozenlabel", NULL,
+    Tk_Offset(TrackItemStruct, flags), FROZEN_LABEL_BIT, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_ANCHOR, "-labelanchor", NULL,
+    Tk_Offset(TrackItemStruct, label_anchor), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_ANGLE, "-labelangle", NULL,
     Tk_Offset(TrackItemStruct, label_angle), 0,
-    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
-  { RADAR_CONFIG_DIM, "-labeldistance", NULL,
+    ZN_COORDS_FLAG|ZN_POLAR_FLAG, False },
+  { ZN_CONFIG_DIM, "-labeldistance", NULL,
     Tk_Offset(TrackItemStruct, label_distance), 0,
-    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
-  { RADAR_CONFIG_DIM, "-labeldx", NULL,
+    ZN_COORDS_FLAG|ZN_POLAR_FLAG, False },
+  { ZN_CONFIG_DIM, "-labeldx", NULL,
     Tk_Offset(TrackItemStruct, label_dx), 0,
-    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
-  { RADAR_CONFIG_DIM, "-labeldy", NULL,
+    ZN_COORDS_FLAG|ZN_CARTESIAN_FLAG, False },
+  { ZN_CONFIG_DIM, "-labeldy", NULL,
     Tk_Offset(TrackItemStruct, label_dy), 0,
-    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
-  { RADAR_CONFIG_LABEL_FORMAT, "-labelformat", NULL,
+    ZN_COORDS_FLAG|ZN_CARTESIAN_FLAG, False },
+  { ZN_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,
+    ZN_COORDS_FLAG|ZN_CLFC_FLAG, False },
+  { ZN_CONFIG_LEADER_ANCHORS, "-leaderanchors", NULL,
+    Tk_Offset(TrackItemStruct, leader_anchors), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-leadercolor", NULL,
+    Tk_Offset(TrackItemStruct, leader_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_LINE_END, "-leaderfirstend", NULL,
+    Tk_Offset(TrackItemStruct, leader_first_end), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_LINE_END, "-leaderlastend", NULL,
+    Tk_Offset(TrackItemStruct, leader_last_end), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-leadersensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_LEADER),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-leaderstyle", NULL,
+    Tk_Offset(TrackItemStruct, leader_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_LINE_SHAPE, "-leadershape", NULL,
+    Tk_Offset(TrackItemStruct, leader_shape), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_DIM, "-leaderwidth", NULL,
+    Tk_Offset(TrackItemStruct, leader_width), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-markercolor", NULL,
+    Tk_Offset(TrackItemStruct, marker_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-markerfillpattern", NULL,
+    Tk_Offset(TrackItemStruct, marker_fill_pattern), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_DIM, "-markersize", NULL,
+    Tk_Offset(TrackItemStruct, marker_size), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-markerstyle", NULL,
+    Tk_Offset(TrackItemStruct, marker_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-mixedhistory", NULL,
+    Tk_Offset(TrackItemStruct, flags), DOT_MIXED_HISTORY_BIT, ZN_DRAW_FLAG, False },
+  { ZN_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,
+  { ZN_CONFIG_POINT, "-position", NULL, Tk_Offset(TrackItemStruct, pos), 0,
+    ZN_COORDS_FLAG|ZN_MOVED_FLAG, False},
+  { ZN_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,
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), SENSITIVE_BIT, ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_POINT, "-speedvector", NULL, Tk_Offset(TrackItemStruct, speed_vector), 0,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-speedvectorcolor", NULL,
+    Tk_Offset(TrackItemStruct, speed_vector_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-speedvectorsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_SPEED_VECTOR),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-symbol", NULL,
+    Tk_Offset(TrackItemStruct, symbol), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-symbolcolor", NULL,
+    Tk_Offset(TrackItemStruct, symbol_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-symbolsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_CURRENT_POSITION),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_TAGS, "-tags", NULL,
     Tk_Offset(TrackItemStruct, header.tags), 0, 0, False },
-  { RADAR_CONFIG_BOOL, "-visible", NULL,
+  { ZN_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 },
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG|ZN_VIS_FLAG, False },
+  { ZN_CONFIG_UINT, "-visiblehistorysize", NULL,
+    Tk_Offset(TrackItemStruct, visible_history_size), 0, ZN_DRAW_FLAG, False },
   
-  { RADAR_CONFIG_END, NULL, NULL, 0, 0, 0 }
+  { ZN_CONFIG_END, NULL, NULL, 0, 0, 0 }
 };
 
-static RadarAttrConfig	wp_attrs[] = {
-  { RADAR_CONFIG_BOOL, "-composerotation", NULL,
+static ZnAttrConfig	wp_attrs[] = {
+  { ZN_CONFIG_BOOL, "-composerotation", NULL,
     Tk_Offset(TrackItemStruct, header.flags), COMPOSE_ROTATION_BIT,
-    RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_BOOL, "-composescale", NULL,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-composescale", NULL,
     Tk_Offset(TrackItemStruct, header.flags), COMPOSE_SCALE_BIT,
-    RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_ITEM, "-connecteditem", NULL,
+    ZN_COORDS_FLAG, False },
+  { ZN_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,
+    ZN_COORDS_FLAG|ZN_ITEM_FLAG, False },
+  { ZN_CONFIG_COLOR, "-connectioncolor", NULL,
+    Tk_Offset(TrackItemStruct, connection_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-connectionsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_CONNECTION),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-connectionstyle", NULL,
+    Tk_Offset(TrackItemStruct, connection_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_DIM, "-connectionwidth", NULL,
+    Tk_Offset(TrackItemStruct, connection_width), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-filledmarker", NULL,
+    Tk_Offset(TrackItemStruct, flags), MARKER_FILLED_BIT, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_ANCHOR, "-labelanchor", NULL,
+    Tk_Offset(TrackItemStruct, label_anchor), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_ANGLE, "-labelangle", NULL,
     Tk_Offset(TrackItemStruct, label_angle), 0,
-    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
-  { RADAR_CONFIG_DIM, "-labeldistance", NULL,
+    ZN_COORDS_FLAG|ZN_POLAR_FLAG, False },
+  { ZN_CONFIG_DIM, "-labeldistance", NULL,
     Tk_Offset(TrackItemStruct, label_distance), 0,
-    RADAR_COORDS_FLAG|RADAR_POLAR_FLAG, False },
-  { RADAR_CONFIG_DIM, "-labeldx", NULL,
+    ZN_COORDS_FLAG|ZN_POLAR_FLAG, False },
+  { ZN_CONFIG_DIM, "-labeldx", NULL,
     Tk_Offset(TrackItemStruct, label_dx), 0,
-    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
-  { RADAR_CONFIG_DIM, "-labeldy", NULL,
+    ZN_COORDS_FLAG|ZN_CARTESIAN_FLAG, False },
+  { ZN_CONFIG_DIM, "-labeldy", NULL,
     Tk_Offset(TrackItemStruct, label_dy), 0,
-    RADAR_COORDS_FLAG|RADAR_CARTESIAN_FLAG, False },
-  { RADAR_CONFIG_LABEL_FORMAT, "-labelformat", NULL,
+    ZN_COORDS_FLAG|ZN_CARTESIAN_FLAG, False },
+  { ZN_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,
+    ZN_COORDS_FLAG|ZN_CLFC_FLAG, False },
+  { ZN_CONFIG_LEADER_ANCHORS, "-leaderanchors", NULL,
+    Tk_Offset(TrackItemStruct, leader_anchors), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-leadercolor", NULL,
+    Tk_Offset(TrackItemStruct, leader_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_LINE_END, "-leaderfirstend", NULL,
+    Tk_Offset(TrackItemStruct, leader_first_end), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_LINE_END, "-leaderlastend", NULL,
+    Tk_Offset(TrackItemStruct, leader_last_end), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-leadersensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_LEADER),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_LINE_SHAPE, "-leadershape", NULL,
+    Tk_Offset(TrackItemStruct, leader_shape), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-leaderstyle", NULL,
+    Tk_Offset(TrackItemStruct, leader_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_DIM, "-leaderwidth", NULL,
+    Tk_Offset(TrackItemStruct, leader_width), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-markercolor", NULL,
+    Tk_Offset(TrackItemStruct, marker_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-markerfillpattern", NULL,
+    Tk_Offset(TrackItemStruct, marker_fill_pattern), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_DIM, "-markersize", NULL,
+    Tk_Offset(TrackItemStruct, marker_size), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_LINE_STYLE, "-markerstyle", NULL,
+    Tk_Offset(TrackItemStruct, marker_style), 0, ZN_DRAW_FLAG, False },
+  { ZN_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,
+  { ZN_CONFIG_POINT, "-position", NULL, Tk_Offset(TrackItemStruct, pos), 0,
+    ZN_COORDS_FLAG, False},
+  { ZN_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,
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.flags), SENSITIVE_BIT, ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-symbol", NULL,
+    Tk_Offset(TrackItemStruct, symbol), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_COLOR, "-symbolcolor", NULL,
+    Tk_Offset(TrackItemStruct, symbol_color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-symbolsensitive", NULL,
+    Tk_Offset(TrackItemStruct, header.part_sensitive), PART_NUMBER_TO_BIT(ZN_CURRENT_POSITION),
+    ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_TAGS, "-tags", NULL,
     Tk_Offset(TrackItemStruct, header.tags), 0, 0, False },
-  { RADAR_CONFIG_BOOL, "-visible", NULL,
+  { ZN_CONFIG_BOOL, "-visible", NULL,
     Tk_Offset(TrackItemStruct, header.flags), VISIBLE_BIT,
-    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG|RADAR_VIS_FLAG, False },
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG|ZN_VIS_FLAG, False },
   
-  { RADAR_CONFIG_END, NULL, NULL, 0, 0, 0 }
+  { ZN_CONFIG_END, NULL, NULL, 0, 0, 0 }
 };
 
 
@@ -309,9 +309,9 @@ static RadarAttrConfig	wp_attrs[] = {
  *
  **********************************************************************************
  */
-static RadarReal
-ProjectionToAngle(RadarDim	dx,
-		  RadarDim	dy)
+static ZnReal
+ProjectionToAngle(ZnDim	dx,
+		  ZnDim	dy)
 {
   if (dx == 0) {
     if (dy < 0) {
@@ -334,7 +334,7 @@ ProjectionToAngle(RadarDim	dx,
 }
 
 static void
-PointPolarToCartesian(RadarReal	heading,
+PointPolarToCartesian(ZnReal	heading,
 		      int	rho,
 		      int	theta,
 		      int	*delta_x,
@@ -373,35 +373,35 @@ Init(Item	item,
   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);
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(ZN_CURRENT_POSITION));
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(ZN_LEADER));
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(ZN_CONNECTION));
+  SET(item->part_sensitive, PART_NUMBER_TO_BIT(ZN_SPEED_VECTOR));
+  track->symbol_color = ZnGetColorByValue(wi->win, wi->fore_color);
   track->symbol = Tk_GetBitmap(wi->interp, wi->win, Tk_GetUid("AtcSymbol15"));
-  track->label_anchor = RadarAnchorCenter;
+  track->label_anchor = ZnAnchorCenter;
   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_color = ZnGetColorByValue(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_color = ZnGetColorByValue(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_color = ZnGetColorByValue(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);
+  track->marker_fill_pattern = ZnUnspecifiedPattern;
+  track->speed_vector_color = ZnGetColorByValue(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) {
+  if (item->class == ZnTrack) {
     item->priority = DEFAULT_TRACK_PRIORITY;
     track->visible_history_size = DEFAULT_VISIBLE_HISTORY_SIZE;
     track->marker_size = DEFAULT_MARKER_SIZE;
@@ -421,14 +421,14 @@ Init(Item	item,
    * 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)) {
+      (Tcl_GetInt(wi->interp, (args[0])[0], &field_set->num_fields) != ZN_ERROR)) {
     *args += 1;
     *argc -= 1;
     ITEM_P.InitFields(field_set);
   }
   else {
     Tcl_AppendResult(wi->interp, " number of fields expected", NULL);
-    return RADAR_ERROR;
+    return ZN_ERROR;
   }
   
   track->pos.x = 0;
@@ -446,7 +446,7 @@ Init(Item	item,
   track->marker_size_dev = 0;
   track->leader_points = NULL;
 
-  return RADAR_OK;
+  return ZN_OK;
 }
 
 
@@ -464,7 +464,7 @@ Clone(Item	item)
   WidgetInfo	*wi = item->wi;
 
   if (track->history) {
-    track->history = RadarListDuplicate(track->history);
+    track->history = ZnListDuplicate(track->history);
   }
   track->dev.x = 0;
   track->dev.y = 0;
@@ -472,7 +472,7 @@ Clone(Item	item)
   track->speed_vector_dev.y = 0;
   track->marker_size_dev = 0;
   if (track->leader_points) {
-    track->leader_points = RadarListDuplicate(track->leader_points);
+    track->leader_points = ZnListDuplicate(track->leader_points);
   }
   if (track->leader_first_end) {
     LineEndDuplicate(track->leader_first_end);
@@ -486,16 +486,16 @@ Clone(Item	item)
   /*
    * 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_color = ZnGetColorByValue(wi->win, track->symbol_color);
+  track->leader_color = ZnGetColorByValue(wi->win, track->leader_color);
+  track->connection_color = ZnGetColorByValue(wi->win, track->connection_color);
+  track->marker_color = ZnGetColorByValue(wi->win, track->marker_color);
+  track->speed_vector_color = ZnGetColorByValue(wi->win, track->speed_vector_color);
+  if (track->symbol != ZnUnspecifiedPattern) {
     track->symbol = Tk_GetBitmap(wi->interp, wi->win,
 				 Tk_NameOfBitmap(wi->dpy, track->symbol));
   }
-  if (track->marker_fill_pattern != RadarUnspecifiedPattern) {
+  if (track->marker_fill_pattern != ZnUnspecifiedPattern) {
     track->marker_fill_pattern = Tk_GetBitmap(wi->interp, wi->win,
 					      Tk_NameOfBitmap(wi->dpy, track->marker_fill_pattern));
   }
@@ -516,7 +516,7 @@ Destroy(Item	item)
   WidgetInfo	*wi = item->wi;
   
   if (track->leader_points) {
-    RadarListFree(track->leader_points);
+    ZnListFree(track->leader_points);
   }
   if (track->leader_first_end) {
     LineEndDelete(track->leader_first_end);
@@ -526,21 +526,21 @@ Destroy(Item	item)
   }
 
   if (track->history) {
-    RadarListFree(track->history);
+    ZnListFree(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) {
+  ZnFreeColor(track->symbol_color);
+  ZnFreeColor(track->leader_color);
+  ZnFreeColor(track->connection_color);
+  ZnFreeColor(track->marker_color);
+  ZnFreeColor(track->speed_vector_color);
+  if (track->symbol != ZnUnspecifiedPattern) {
     Tk_FreeBitmap(wi->dpy, track->symbol);
   }
-  if (track->marker_fill_pattern != RadarUnspecifiedPattern) {
+  if (track->marker_fill_pattern != ZnUnspecifiedPattern) {
     Tk_FreeBitmap(wi->dpy, track->marker_fill_pattern);
   }
 
@@ -557,7 +557,7 @@ Destroy(Item	item)
  */
 static void
 AddToHistory(TrackItem	track,
-	     RadarPoint	old_pos)
+	     ZnPoint	old_pos)
 {
   WidgetInfo	*wi = ((Item) track)->wi;
   
@@ -569,15 +569,15 @@ AddToHistory(TrackItem	track,
       hist.world = old_pos;
       hist.dev = track->dev;
       hist.visible = True;
-      RadarListAdd(track->history, &hist, RadarListHead);
-      RadarListTruncate(track->history, wi->track_managed_history_size);
+      ZnListAdd(track->history, &hist, ZnListHead);
+      ZnListTruncate(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,
+    track->history = ZnListNew(wi->track_managed_history_size+1,
 				  sizeof(HistoryStruct));
   }
 }
@@ -585,19 +585,19 @@ AddToHistory(TrackItem	track,
 static int
 Configure(Item		item,
 	  int		argc,
-	  RadarAttrList	argv,
+	  ZnAttrList	argv,
 	  int		*flags)
 {
   TrackItem	track = (TrackItem) item;
   WidgetInfo	*wi = item->wi;
   Item		old_connected;
-  RadarPoint	old_pos;
+  ZnPoint	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;
+  if (ITEM_P.ConfigureAttributes((char *) item, -1, argc, argv, flags) == ZN_ERROR) {
+    return ZN_ERROR;
   }
   
   /*
@@ -608,21 +608,21 @@ Configure(Item		item,
   /*
    * Adapt to the new label locating system.
    */
-  if (ISSET(*flags, RADAR_POLAR_FLAG)) {
+  if (ISSET(*flags, ZN_POLAR_FLAG)) {
     SET(track->flags, POLAR_BIT);
   }
-  else if (ISSET(*flags, RADAR_CARTESIAN_FLAG)) {
+  else if (ISSET(*flags, ZN_CARTESIAN_FLAG)) {
     CLEAR(track->flags, POLAR_BIT);
   }
   
-  if (ISSET(*flags, RADAR_ITEM_FLAG)) {
+  if (ISSET(*flags, ZN_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)) &&
+    if ((item->connected_item == ZN_NO_ITEM) ||
+	(((item->connected_item->class == ZnTrack) ||
+	  (item->connected_item->class == ZnWayPoint)) &&
 	 (item->parent == item->connected_item->parent))) {
       ITEM.UpdateItemDependency(item, old_connected);
     }
@@ -632,22 +632,22 @@ Configure(Item		item,
   }
   
 #ifdef OM
-  if (ISSET(*flags, RADAR_VIS_FLAG)) {
+  if (ISSET(*flags, ZN_VIS_FLAG)) {
     /* Record the change to trigger the overlap manager latter */
-    if ((item->class == RadarTrack) && ISSET(item->flags, VISIBLE_BIT)) {
+    if ((item->class == ZnTrack) && 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) {
+  if (ISSET(*flags, ZN_MOVED_FLAG)) {
+    if (item->class == ZnTrack) {
       AddToHistory(track, old_pos);
     }
   }
 
-  return RADAR_OK;
+  return ZN_OK;
 }
   
   
@@ -661,13 +661,13 @@ Configure(Item		item,
 static int
 Query(Item		item,
       int		argc,
-      RadarAttrList	argv)
+      ZnAttrList	argv)
 {
-  if (ITEM_P.QueryAttribute((char *) item, -1, argv[0]) == RADAR_ERROR) {
-    return RADAR_ERROR;
+  if (ITEM_P.QueryAttribute((char *) item, -1, argv[0]) == ZN_ERROR) {
+    return ZN_ERROR;
   }
 
-  return RADAR_OK;
+  return ZN_OK;
 }
 
 
@@ -681,18 +681,18 @@ Query(Item		item,
 
 static void
 ComputeCoordinates(Item		item,
-		   RadarBool	force)
+		   ZnBool	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;
+  ZnPoint	old_label_pos, old_pos, p, xp;
+  ZnDim		old_label_width, old_label_height;
+  ZnReal	rotation;
+  ZnBBox	bbox;
+  ZnPoint	*points;
   int		num_acc_pos, i;
   int		num_points, alignment;
   int		w2=0, h2=0, w=0, h=0;
@@ -705,15 +705,15 @@ ComputeCoordinates(Item		item,
   /*
    * Suppress history if history management was turned off.
    */
-  if ((item->class == RadarTrack) && !wi->track_manage_history) {
-    RadarListEmpty(track->history);
+  if ((item->class == ZnTrack) && !wi->track_manage_history) {
+    ZnListEmpty(track->history);
   }
 
   old_pos = track->dev;
 
-  RadarTransformPoint(wi->current_transfo, &track->pos, &track->dev);
+  ZnTransformPoint(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) {
+  if (track->symbol != ZnUnspecifiedPattern) {
     Tk_SizeOfBitmap(wi->dpy, track->symbol, &w, &h);
     /*printf("taille symbole %d %d\n", w, h);*/
     w2 = (w+1)/2;
@@ -731,12 +731,12 @@ ComputeCoordinates(Item		item,
      care :-). In fact it is even worse as we use the overall
      information from the symbol font.
      */
-  if ((item->class == RadarTrack) && track->history) {
+  if ((item->class == ZnTrack) && track->history) {
     ResetBBox(&bbox);
-    num_acc_pos = RadarListSize(track->history);
-    hist = RadarListArray(track->history);
+    num_acc_pos = ZnListSize(track->history);
+    hist = ZnListArray(track->history);
     for (i = 0; i < num_acc_pos; i++) {
-      RadarTransformPoint(wi->current_transfo, &hist[i].world, &hist[i].dev);
+      ZnTransformPoint(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;
@@ -750,10 +750,10 @@ ComputeCoordinates(Item		item,
   /*
    * Compute the speed vector end.
    */
-  if (item->class == RadarTrack) {
+  if (item->class == ZnTrack) {
     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);  
+    ZnTransformPoint(wi->current_transfo, &p, &track->speed_vector_dev);  
     AddPointToBBox(&item->item_bounding_box, track->speed_vector_dev.x,
 		   track->speed_vector_dev.y);
   }
@@ -762,7 +762,7 @@ ComputeCoordinates(Item		item,
    * Take care of the connection between items.
    */
   c_item = item->connected_item;
-  if ((c_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
+  if ((c_item != ZN_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);
@@ -775,23 +775,23 @@ ComputeCoordinates(Item		item,
    */
   p.x = track->pos.x + track->marker_size;
   p.y = track->pos.y;
-  RadarTransformPoint(wi->current_transfo, &p, &xp);
+  ZnTransformPoint(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);
+		   track->dev.x - (ZnPos) track->marker_size_dev,
+		   track->dev.y - (ZnPos) 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);
+		   track->dev.x + (ZnPos) track->marker_size_dev,
+		   track->dev.y + (ZnPos) track->marker_size_dev);
   } 
   
   /* Compute the new label bounding box. */
   if (field_set->label_format) {
-    RadarDim	bb_width, bb_height, dist;
-    RadarPoint	leader_end;
+    ZnDim	bb_width, bb_height, dist;
+    ZnPoint	leader_end;
 
     ITEM_P.GetLabelBBox(field_set, &bb_width, &bb_height);
     /*
@@ -803,9 +803,9 @@ ComputeCoordinates(Item		item,
 	 * 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)) {
+	if ((track->label_anchor == ZnAnchorN) ||
+	    (track->label_anchor == ZnAnchorCenter) ||
+	    (track->label_anchor == ZnAnchorS)) {
 	  dist = sqrt(bb_width*bb_width/4+bb_height*bb_height/4);
 	}
 	else {
@@ -815,7 +815,7 @@ ComputeCoordinates(Item		item,
 	/*
 	 * Compute heading after applying the transform.
 	 */
-	RadarTransfoDecompose(wi->current_transfo, NULL, NULL, &rotation, NULL);
+	ZnTransfoDecompose(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);*/
@@ -832,15 +832,15 @@ ComputeCoordinates(Item		item,
     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);
+		   field_set->label_pos.x + (ZnPos) bb_width,
+		   field_set->label_pos.y + (ZnPos) 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];
+      ZnPoint	end_points[LINE_END_POINTS];
       
       /*
        * Compute the actual leader end in the label.
@@ -886,13 +886,13 @@ ComputeCoordinates(Item		item,
 
       /* Setup leader shape points */
       if (!track->leader_points) {
-	track->leader_points = RadarListNew(LINE_SHAPE_POINTS, sizeof(RadarPoint));
+	track->leader_points = ZnListNew(LINE_SHAPE_POINTS, sizeof(ZnPoint));
       }
       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);
+      points = (ZnPoint *) ZnListArray(track->leader_points);
+      num_points = ZnListSize(track->leader_points);
 
       /* Setup leader ends */
       if (track->leader_first_end != NULL) {
@@ -920,7 +920,7 @@ ComputeCoordinates(Item		item,
 
 #ifdef OM
     /* Record the move to trigger the overlap manager latter */
-    if (item->class == RadarTrack) {
+    if (item->class == ZnTrack) {
       ((GroupItem) item->parent)->call_om = True;
     }
 #endif
@@ -938,24 +938,24 @@ ComputeCoordinates(Item		item,
  **********************************************************************************
  */
 static int
-ToArea(Item		item,
-       RadarBBox	*area,
-       Tk_Uid		tag_uid,
-       int		enclosed,
-       RadarBool	report)
+ToArea(Item	item,
+       ZnBBox	*area,
+       Tk_Uid	tag_uid,
+       int	enclosed,
+       ZnBool	report)
 {
   WidgetInfo	*wi = item->wi;
   TrackItem	track = (TrackItem) item;
   int		inside;
   int		width, height;
-  RadarDim	lwidth, lheight;
-  RadarBBox	bbox;
+  ZnDim		lwidth, lheight;
+  ZnBBox	bbox;
 
   /*
    * Try the current position.
    */
   ResetBBox(&bbox);
-  if (track->symbol != RadarUnspecifiedPattern) {
+  if (track->symbol != ZnUnspecifiedPattern) {
     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;
@@ -982,12 +982,12 @@ ToArea(Item		item,
    * Try the leader.
    */
   if (track->field_set.label_format && (track->leader_width > 0)) {
-    RadarPoint end_points[LINE_END_POINTS];
-    RadarPoint *points;
+    ZnPoint end_points[LINE_END_POINTS];
+    ZnPoint *points;
     int	       num_points;
 
-    points = (RadarPoint *) RadarListArray(track->leader_points);
-    num_points = RadarListSize(track->leader_points);
+    points = (ZnPoint *) ZnListArray(track->leader_points);
+    num_points = ZnListSize(track->leader_points);
     width = track->leader_width > 1 ? track->leader_width : 0;
     if (PolylineInBBox(points, num_points, width,
 		       CapRound, JoinRound, area) != inside) {
@@ -1015,7 +1015,7 @@ ToArea(Item		item,
   /*
    * Try the speed vector.
    */
-  if (item->class == RadarTrack) {
+  if (item->class == ZnTrack) {
     if (LineInBBox(&track->dev, &track->speed_vector_dev, area) != inside) {
       printf("track speed vector\n");
       return 0;
@@ -1025,8 +1025,8 @@ ToArea(Item		item,
   /*
    * Try the connection.
    */
-  if ((item->connected_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
-    RadarPoint	pts[2];
+  if ((item->connected_item != ZN_NO_ITEM) && (track->connection_width > 0)) {
+    ZnPoint	pts[2];
     
     pts[0] = track->dev;
     pts[1] = ((TrackItem) item->connected_item)->dev;
@@ -1065,10 +1065,10 @@ Draw(Item	item)
   /* Draw the marker */
   if (track->marker_size_dev != 0) {
     SetLineStyle(wi->dpy, wi->gc, track->marker_style);
-    values.foreground = RadarPixel(track->marker_color);
+    values.foreground = ZnPixel(track->marker_color);
     values.line_width = 0;
     if (ISSET(track->flags, MARKER_FILLED_BIT)) {
-      if (track->marker_fill_pattern == RadarUnspecifiedPattern) {
+      if (track->marker_fill_pattern == ZnUnspecifiedPattern) {
 	/* Fill solid */
 	values.fill_style = FillSolid;
 	XChangeGC(wi->dpy, wi->gc, GCFillStyle | GCLineWidth | GCForeground, &values);
@@ -1081,16 +1081,16 @@ Draw(Item	item)
 		  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->dev.x - (ZnPos) track->marker_size_dev,
+	       track->dev.y - (ZnPos) 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->dev.x - (ZnPos) track->marker_size_dev,
+	       track->dev.y - (ZnPos) track->marker_size_dev,
 	       track->marker_size_dev * 2, track->marker_size_dev * 2,
 	       0, 360 * 64);
     }
@@ -1100,8 +1100,8 @@ Draw(Item	item)
    * Draw the connection.
    */
   c_item = item->connected_item;
-  if ((c_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
-    RadarPoint	pts[2];
+  if ((c_item != ZN_NO_ITEM) && (track->connection_width > 0)) {
+    ZnPoint	pts[2];
     
     pts[0] = track->dev;
     pts[1] = ((TrackItem) item->connected_item)->dev;
@@ -1113,8 +1113,8 @@ Draw(Item	item)
   /*
    * Draw the speed vector.
    */
-  if (item->class == RadarTrack) {
-    values.foreground = RadarPixel(track->speed_vector_color);
+  if (item->class == ZnTrack) {
+    values.foreground = ZnPixel(track->speed_vector_color);
     values.line_width = 0;
     values.line_style = LineSolid;
     values.fill_style = FillSolid;
@@ -1128,13 +1128,13 @@ Draw(Item	item)
    * Draw the leader.
    */
   if (track->field_set.label_format && track->leader_width > 0) {
-    RadarPoint end_points[LINE_END_POINTS];
+    ZnPoint end_points[LINE_END_POINTS];
     XPoint     xpoints[LINE_END_POINTS];
-    RadarPoint *points;
+    ZnPoint *points;
     int	       num_points;
 
-    points = (RadarPoint *) RadarListArray(track->leader_points);
-    num_points = RadarListSize(track->leader_points);
+    points = (ZnPoint *) ZnListArray(track->leader_points);
+    num_points = ZnListSize(track->leader_points);
     DrawLineShape(wi->dpy, wi->draw_buffer, wi->gc,
 		  points, num_points,
 		  track->leader_style, track->leader_color,
@@ -1162,24 +1162,24 @@ Draw(Item	item)
   }
   
   tmp_str[0] = track->symbol;
-  values.foreground = RadarPixel(track->symbol_color);
+  values.foreground = ZnPixel(track->symbol_color);
   values.fill_style = FillSolid;
   XChangeGC(wi->dpy, wi->gc, GCForeground|GCFillStyle, &values);  
-  if (track->symbol != RadarUnspecifiedPattern) {
+  if (track->symbol != ZnUnspecifiedPattern) {
     Tk_SizeOfBitmap(wi->dpy, track->symbol, &width, &height);
   }
   
   /*
    * Draw the history, current pos excepted.
    */
-  if ((item->class == RadarTrack) && track->history) {
+  if ((item->class == ZnTrack) && 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);
+    num_acc_pos = ZnListSize(track->history);
+    hist = ZnListArray(track->history);
     side_size = MAX(width, height);
     for (i = 0, nb_hist = 0;
 	 i < MIN(track->visible_history_size, num_acc_pos); i++) {
@@ -1223,7 +1223,7 @@ Draw(Item	item)
   /*
    * Draw the current position using a pattern for Tk.
    */
-  if (track->symbol != RadarUnspecifiedPattern) {
+  if (track->symbol != ZnUnspecifiedPattern) {
     int x = track->dev.x - (width+1)/2;
     int y = track->dev.y - (height+1)/2;
     values.fill_style = FillStippled;
@@ -1249,16 +1249,16 @@ Draw(Item	item)
  *
  **********************************************************************************
  */
-static RadarBool
+static ZnBool
 IsSensitive(Item	item,
 	    int		item_part)
 {
   if (ISCLEAR(item->flags, SENSITIVE_BIT) ||
-      !item->parent->class->IsSensitive(item->parent, RADAR_NO_PART)) {
+      !item->parent->class->IsSensitive(item->parent, ZN_NO_PART)) {
     return False;
   }
   
-  if (item_part < RADAR_NO_PART) {
+  if (item_part < ZN_NO_PART) {
     return ISSET(item->part_sensitive, PART_NUMBER_TO_BIT(item_part));
   }
   else if (item_part >= 0) {
@@ -1277,7 +1277,7 @@ IsSensitive(Item	item,
  */
 static double
 Pick(Item	item,
-     RadarPoint	*p,
+     ZnPoint	*p,
      Item	start_item,
      int	aperture,
      Item	*a_item,
@@ -1286,9 +1286,9 @@ Pick(Item	item,
   WidgetInfo	*wi= item->wi;
   TrackItem	track = (TrackItem) item;
   Item		c_item;
-  RadarBBox	bbox;
+  ZnBBox	bbox;
   double	dist=0, new_dist;
-  RadarPoint	*points;
+  ZnPoint	*points;
   int		num_points, i;
   int		width=0, height=0;
   double	width_2;
@@ -1306,7 +1306,7 @@ Pick(Item	item,
    * Try the current position symbol.
    */
   ResetBBox(&bbox);
-  if (track->symbol != RadarUnspecifiedPattern) {
+  if (track->symbol != ZnUnspecifiedPattern) {
     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;
@@ -1316,7 +1316,7 @@ Pick(Item	item,
 
   new_dist = RectangleToPointDist(&bbox, p);
   if (new_dist < dist) {
-    best_part = RADAR_CURRENT_POSITION;
+    best_part = ZN_CURRENT_POSITION;
     dist = new_dist;
   }
   if (dist <= 0.0) {
@@ -1327,16 +1327,16 @@ Pick(Item	item,
    * Try the leader.
    */
   if (track->field_set.label_format && (track->leader_width > 0)) {
-    RadarPoint end_points[LINE_END_POINTS];
+    ZnPoint 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;
+    points = (ZnPoint *) ZnListArray(track->leader_points);
+    num_points = ZnListSize(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;
+	best_part = ZN_LEADER;
 	dist = new_dist;
       }
       if (dist <= 0.0) {
@@ -1348,7 +1348,7 @@ Pick(Item	item,
 		 CapRound, track->leader_first_end, end_points);
       new_dist = PolygonToPointDist(end_points, LINE_END_POINTS, p);
       if (new_dist < dist) {
-	best_part = RADAR_LEADER;
+	best_part = ZN_LEADER;
 	dist = new_dist;	
       }
       if (dist <= 0.0) {
@@ -1360,7 +1360,7 @@ Pick(Item	item,
 		 CapRound, track->leader_last_end, end_points);
       new_dist = PolygonToPointDist(end_points, LINE_END_POINTS, p);
       if (new_dist < dist) {
-	best_part = RADAR_LEADER;
+	best_part = ZN_LEADER;
 	dist = new_dist;	
       }
       if (dist <= 0.0) {
@@ -1372,10 +1372,10 @@ Pick(Item	item,
   /*
    * Try the speed vector.
    */
-  if (item->class == RadarTrack) {
+  if (item->class == ZnTrack) {
     new_dist = LineToPointDist(&track->dev, &track->speed_vector_dev, p);
     if (new_dist < dist) {
-      best_part = RADAR_SPEED_VECTOR;
+      best_part = ZN_SPEED_VECTOR;
       dist = new_dist;
     }
     if (dist <= 0.0) {
@@ -1387,8 +1387,8 @@ Pick(Item	item,
    * Try the connection.
    */
   c_item = item->connected_item;
-  if ((c_item != RADAR_NO_ITEM) && (track->connection_width > 0)) {
-    RadarPoint	pts[2];
+  if ((c_item != ZN_NO_ITEM) && (track->connection_width > 0)) {
+    ZnPoint	pts[2];
 		   
     pts[0] = track->dev;
     pts[1] = ((TrackItem) item->connected_item)->dev;
@@ -1396,7 +1396,7 @@ Pick(Item	item,
 				   CapRound, JoinRound, p);
     if (new_dist < dist) {
       dist = new_dist;
-      best_part = RADAR_CONNECTION;
+      best_part = ZN_CONNECTION;
     }
     if (dist <= 0.0) {
     report0:
@@ -1458,28 +1458,28 @@ SendTrackToOm(void	*ptr,
   WidgetInfo	*wi = (WidgetInfo *) ptr;
   Item		current_item = (Item) item;
   TrackItem	track;
-  RadarBBox	radar_bbox, bbox;
-  RadarBool	to_be_sent;
+  ZnBBox	zn_bbox, bbox;
+  ZnBool	to_be_sent;
 
-  radar_bbox.orig.x = radar_bbox.orig.y = 0;
-  radar_bbox.corner.x = wi->width;
-  radar_bbox.corner.y = wi->height;
+  zn_bbox.orig.x = zn_bbox.orig.y = 0;
+  zn_bbox.corner.x = wi->width;
+  zn_bbox.corner.y = wi->height;
 
-  if (current_item == RADAR_NO_ITEM) {
+  if (current_item == ZN_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;
+  while (current_item != ZN_NO_ITEM) {
+    to_be_sent = current_item->class == ZnTrack;
 
     /* 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);
+    IntersectBBox(&zn_bbox, &current_item->item_bounding_box, &bbox);
     to_be_sent &= !IsEmptyBBox(&bbox);
     
     if (to_be_sent) {
@@ -1499,7 +1499,7 @@ SendTrackToOm(void	*ptr,
       *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;
+	ZnDim	bb_width, bb_height;
 
 	ITEM_P.GetLabelBBox(&track->field_set, &bb_width, &bb_height);
 	*label_width = bb_width;
@@ -1539,7 +1539,7 @@ SetLabelAngleFromOm(void	*ptr,	/* No longer in use. */
 
   if ((theta >= 0) && (track->label_angle != theta)) {
     track->label_angle = theta;
-    ITEM.Invalidate((Item) item, RADAR_COORDS_FLAG);
+    ITEM.Invalidate((Item) item, ZN_COORDS_FLAG);
   }
 }
 
@@ -1556,19 +1556,19 @@ void
 QueryLabelPosition(void	*ptr,	/* No longer in use. */
 		   void	*item,
 		   int	theta,
-		   int*	x,
-		   int*	y,
-		   int*	w,
-		   int*	h)
+		   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;
+    ZnDim	bb_width, bb_height;
     int		delta_x, delta_y;
-    RadarReal	heading;
+    ZnReal	heading;
     
     /*
      * !! BUG !! This doesn't work if the current transform has some rotation.
@@ -1580,8 +1580,8 @@ QueryLabelPosition(void	*ptr,	/* No longer in use. */
      * !! 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);
+    *x = track->dev.x + (ZnPos) (delta_x - bb_width/2);
+    *y = track->dev.y - (ZnPos) (delta_y + bb_height/2);
     *y = wi->height - *y;
     *w = bb_width;
     *h = bb_height;
@@ -1602,7 +1602,7 @@ QueryLabelPosition(void	*ptr,	/* No longer in use. */
 void
 SetHistoryVisibility(Item	item,
 		     int	index,
-		     RadarBool	visible)
+		     ZnBool	visible)
 {
 }
 
@@ -1620,12 +1620,12 @@ TruncHistory(Item	item)
   TrackItem	track = (TrackItem) item;
 
   if (track->history) {
-    int size = RadarListSize (track->history);
-    History hist_tbl = RadarListArray (track->history);
+    int size = ZnListSize (track->history);
+    History hist_tbl = ZnListArray (track->history);
     while (size--) {
       hist_tbl[size].visible = False;
     }
-    ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+    ITEM.Invalidate(item, ZN_COORDS_FLAG);
   }
 }
 
@@ -1653,11 +1653,11 @@ GetFieldSet(Item	item)
  */
 static void
 GetAnchor(Item		item,
-	  RadarAnchor	anchor,
-	  RadarPoint	*p)
+	  ZnAnchor	anchor,
+	  ZnPoint	*p)
 {
   FieldSet	field_set = &((TrackItem) item)->field_set;
-  RadarDim	width, height;
+  ZnDim		width, height;
   
   if (field_set->label_format) {
     ITEM_P.GetLabelBBox(field_set, &width, &height);
@@ -1678,37 +1678,37 @@ GetAnchor(Item		item,
  **********************************************************************************
  */
 static int
-Coords(Item		item,
-       int		index,
-       int		cmd,
-       RadarPoint	**pts,
-       int		*num_pts)
+Coords(Item	item,
+       int	index,
+       int	cmd,
+       ZnPoint	**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;
+    return ZN_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;
+      return ZN_ERROR;
     }
-    if (item->class == RadarTrack) {
+    if (item->class == ZnTrack) {
       AddToHistory(track, track->pos);
     }
     track->pos = (*pts)[0];
-    ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+    ITEM.Invalidate(item, ZN_COORDS_FLAG);
   }
   else if ((cmd == COORDS_READ) || (cmd == COORDS_READ_ALL)) {
     *num_pts = 1;
     *pts = &track->pos;
   }
-  return RADAR_OK;
+  return ZN_OK;
 }
 
 
@@ -1767,5 +1767,5 @@ static ItemClassStruct WAY_POINT_ITEM_CLASS = {
   PostScript
 };
 
-RadarItemClassId RadarTrack = (RadarItemClassId) &TRACK_ITEM_CLASS;
-RadarItemClassId RadarWayPoint = (RadarItemClassId) &WAY_POINT_ITEM_CLASS;
+ZnItemClassId ZnTrack = (ZnItemClassId) &TRACK_ITEM_CLASS;
+ZnItemClassId ZnWayPoint = (ZnItemClassId) &WAY_POINT_ITEM_CLASS;