Passage en Zinc

1 files changed, 247 insertions, 247 deletions

diff --git a/generic/Map.c b/generic/Map.c
index 45644d4..a9a6ed7 100644
--- a/generic/Map.c
+++ b/generic/Map.c
@@ -33,7 +33,7 @@
 #include "Geo.h"
 #include "Draw.h"
 #include "WidgetInfo.h"
-#include "tkRadar.h"
+#include "tkZinc.h"
 #ifdef PERFOS
 #include "perfos.h"
 #endif
@@ -59,66 +59,66 @@ typedef struct _MapItemStruct {
   ItemStruct	header;
  
   /* Public data */
-  RadarBool		filled;
-  Pixmap		fill_pattern;
-  RadarColor		color;
-  RadarFont		text_font;	/* null value -> use radar_map_text_font */
-  char			*map_info_name;
-  RadarList		symbol_patterns;
+  ZnBool	filled;
+  Pixmap	fill_pattern;
+  ZnColor	color;
+  ZnFont	text_font;	/* null value -> use zn_map_text_font */
+  char		*map_info_name;
+  ZnList	symbol_patterns;
   
   /* Private data */
-  MapInfoId		map_info;
-  RadarList		vectors;
-  RadarList		dashed_vectors;
-  RadarList		dotted_vectors;
-  RadarList		mixed_vectors;
-  RadarList		arcs;
-  RadarList		dashed_arcs;
-  RadarList		dotted_arcs;
-  RadarList		mixed_arcs;
-  RadarList		marks;
-  RadarList		symbols;
-  RadarList		texts;
+  MapInfoId	map_info;
+  ZnList	vectors;
+  ZnList	dashed_vectors;
+  ZnList	dotted_vectors;
+  ZnList	mixed_vectors;
+  ZnList	arcs;
+  ZnList	dashed_arcs;
+  ZnList	dotted_arcs;
+  ZnList	mixed_arcs;
+  ZnList	marks;
+  ZnList	symbols;
+  ZnList	texts;
 #ifdef PERFOS
-  Chrono		chrono_trans;
-  Chrono		chrono_draw;
+  Chrono	chrono_trans;
+  Chrono	chrono_draw;
 #endif
 } MapItemStruct, *MapItem;
 
 
-static RadarAttrConfig	map_attrs[] = {
-  { RADAR_CONFIG_COLOR, "-color", NULL,
-    Tk_Offset(MapItemStruct, color), 0, RADAR_DRAW_FLAG, False },
-  { RADAR_CONFIG_BOOL, "-composerotation", NULL,
+static ZnAttrConfig	map_attrs[] = {
+  { ZN_CONFIG_COLOR, "-color", NULL,
+    Tk_Offset(MapItemStruct, color), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_BOOL, "-composerotation", NULL,
     Tk_Offset(MapItemStruct, 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(MapItemStruct, header.flags), COMPOSE_SCALE_BIT,
-    RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_BOOL, "-filled", NULL,
-    Tk_Offset(MapItemStruct, filled), 1, RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_PATTERN, "-fillpattern", NULL,
-    Tk_Offset(MapItemStruct, fill_pattern), 0, RADAR_DRAW_FLAG, False },
-  { RADAR_CONFIG_FONT, "-font", NULL,
-    Tk_Offset(MapItemStruct, text_font), 0, RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_MAP_INFO, "-mapinfo", NULL,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_BOOL, "-filled", NULL,
+    Tk_Offset(MapItemStruct, filled), 1, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_PATTERN, "-fillpattern", NULL,
+    Tk_Offset(MapItemStruct, fill_pattern), 0, ZN_DRAW_FLAG, False },
+  { ZN_CONFIG_FONT, "-font", NULL,
+    Tk_Offset(MapItemStruct, text_font), 0, ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_MAP_INFO, "-mapinfo", NULL,
     Tk_Offset(MapItemStruct, map_info_name), 0,
-    RADAR_COORDS_FLAG|RADAR_MAP_INFO_FLAG, False },
-  { RADAR_CONFIG_PRI, "-priority", NULL,
+    ZN_COORDS_FLAG|ZN_MAP_INFO_FLAG, False },
+  { ZN_CONFIG_PRI, "-priority", NULL,
     Tk_Offset(MapItemStruct, header.priority), 0,
-    RADAR_DRAW_FLAG|RADAR_REPICK_FLAG, False },
-  { RADAR_CONFIG_BOOL, "-sensitive", NULL,
-    Tk_Offset(MapItemStruct, header.flags), SENSITIVE_BIT, RADAR_REPICK_FLAG, False },
-  { RADAR_CONFIG_PATTERNS, "-symbols", NULL,
+    ZN_DRAW_FLAG|ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_BOOL, "-sensitive", NULL,
+    Tk_Offset(MapItemStruct, header.flags), SENSITIVE_BIT, ZN_REPICK_FLAG, False },
+  { ZN_CONFIG_PATTERNS, "-symbols", NULL,
     Tk_Offset(MapItemStruct, symbol_patterns), 0,
-    RADAR_COORDS_FLAG, False },
-  { RADAR_CONFIG_TAGS, "-tags", NULL,
+    ZN_COORDS_FLAG, False },
+  { ZN_CONFIG_TAGS, "-tags", NULL,
     Tk_Offset(MapItemStruct, header.tags), 0, 0, False },
-  { RADAR_CONFIG_BOOL, "-visible", NULL,
+  { ZN_CONFIG_BOOL, "-visible", NULL,
     Tk_Offset(MapItemStruct, 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 }
 };
 
 
@@ -129,7 +129,7 @@ UpdateMapInfo(ClientData	client_data,
   Item	item = (Item) client_data;
 
   /*printf("updating a map 'cause of a change in mapinfo\n");*/
-  ITEM.Invalidate(item, RADAR_COORDS_FLAG);
+  ITEM.Invalidate(item, ZN_COORDS_FLAG);
 }
 
 
@@ -137,51 +137,51 @@ static void
 FreeLists(MapItem	map)
 {
   if (map->vectors) {
-    RadarListFree(map->vectors);
+    ZnListFree(map->vectors);
   }
   map->vectors = NULL;
   if (map->dashed_vectors) {
-    RadarListFree(map->dashed_vectors);
+    ZnListFree(map->dashed_vectors);
   }
   map->dashed_vectors = NULL;
   if (map->dotted_vectors) {
-    RadarListFree(map->dotted_vectors);
+    ZnListFree(map->dotted_vectors);
   }
   map->dotted_vectors = NULL;
   if (map->mixed_vectors) {
-    RadarListFree(map->mixed_vectors);
+    ZnListFree(map->mixed_vectors);
   }
   map->mixed_vectors = NULL;
   
   if (map->arcs) {
-    RadarListFree(map->arcs);
+    ZnListFree(map->arcs);
   }
   map->arcs = NULL;
   if (map->dashed_arcs) {
-    RadarListFree(map->dashed_arcs);
+    ZnListFree(map->dashed_arcs);
   }
   map->dashed_arcs = NULL;
   if (map->dotted_arcs) {
-    RadarListFree(map->dotted_arcs);
+    ZnListFree(map->dotted_arcs);
   }
   map->dotted_arcs = NULL;
   if (map->mixed_arcs) {
-    RadarListFree(map->mixed_arcs);
+    ZnListFree(map->mixed_arcs);
   }
   map->mixed_arcs = NULL;
   
   if (map->marks) {
-    RadarListFree(map->marks);
+    ZnListFree(map->marks);
   }
   map->marks = NULL;
   
   if (map->symbols) {
-    RadarListFree(map->symbols);
+    ZnListFree(map->symbols);
   }
   map->symbols = NULL;
   
   if (map->texts) {
-    RadarListFree(map->texts);
+    ZnListFree(map->texts);
   }
   map->texts = NULL;
 }
@@ -209,9 +209,9 @@ Init(Item	item,
   item->part_sensitive = 0;
   item->priority = DEFAULT_MAP_PRIORITY;
   map->filled = False;
-  map->fill_pattern = RadarUnspecifiedPattern; 
+  map->fill_pattern = ZnUnspecifiedPattern; 
   map->symbol_patterns = NULL;
-  map->color = RadarGetColorByValue(wi->win, wi->fore_color);
+  map->color = ZnGetColorByValue(wi->win, wi->fore_color);
   map->text_font = Tk_GetFont(wi->interp, wi->win, Tk_NameOfFont(wi->map_text_font));
   map->map_info_name = "";
   map->map_info = NULL;
@@ -234,7 +234,7 @@ Init(Item	item,
   RazChronos();
 #endif
 
-  return RADAR_OK;
+  return ZN_OK;
 }
 
 
@@ -253,55 +253,55 @@ Clone(Item	item)
   WidgetInfo	*wi = item->wi;
   
   if (map->vectors) {
-    map->vectors = RadarListDuplicate(map->vectors);
+    map->vectors = ZnListDuplicate(map->vectors);
   }
   if (map->dashed_vectors) {
-    map->dashed_vectors = RadarListDuplicate(map->dashed_vectors);
+    map->dashed_vectors = ZnListDuplicate(map->dashed_vectors);
   }
   if (map->dotted_vectors) {
-    map->dotted_vectors = RadarListDuplicate(map->dotted_vectors);
+    map->dotted_vectors = ZnListDuplicate(map->dotted_vectors);
   }
   if (map->mixed_vectors) {
-    map->mixed_vectors = RadarListDuplicate(map->mixed_vectors);
+    map->mixed_vectors = ZnListDuplicate(map->mixed_vectors);
   }
   
   if (map->arcs) {
-    map->arcs = RadarListDuplicate(map->arcs);
+    map->arcs = ZnListDuplicate(map->arcs);
   }
   if (map->dashed_arcs) {
-    map->dashed_arcs = RadarListDuplicate(map->dashed_arcs);
+    map->dashed_arcs = ZnListDuplicate(map->dashed_arcs);
   }
   if (map->dotted_arcs) {
-    map->dotted_arcs = RadarListDuplicate(map->dotted_arcs);
+    map->dotted_arcs = ZnListDuplicate(map->dotted_arcs);
   }
   if (map->mixed_arcs) {
-    map->mixed_arcs = RadarListDuplicate(map->mixed_arcs);
+    map->mixed_arcs = ZnListDuplicate(map->mixed_arcs);
   }
   
   if (map->marks) {
-    map->marks = RadarListDuplicate(map->marks);
+    map->marks = ZnListDuplicate(map->marks);
   }
   
   if (map->symbols) {
-    map->symbols = RadarListDuplicate(map->symbols);
+    map->symbols = ZnListDuplicate(map->symbols);
   }
   
   if (map->texts) {
-    map->texts = RadarListDuplicate(map->texts);
+    map->texts = ZnListDuplicate(map->texts);
   }
 
   if (strlen(map->map_info_name) != 0) {
     char *text;
-    text = RadarMalloc((strlen(map->map_info_name) + 1) * sizeof(char));
+    text = ZnMalloc((strlen(map->map_info_name) + 1) * sizeof(char));
     strcpy(text, map->map_info_name);
     map->map_info_name = text;
-    map->map_info = Radar_GetMapInfo(wi->interp, map->map_info_name,
-				     UpdateMapInfo, (ClientData) map);
+    map->map_info = ZnGetMapInfo(wi->interp, map->map_info_name,
+				 UpdateMapInfo, (ClientData) map);
   }
   
-  map->color = RadarGetColorByValue(wi->win, map->color);
+  map->color = ZnGetColorByValue(wi->win, map->color);
   map->text_font = Tk_GetFont(wi->interp, wi->win, Tk_NameOfFont(map->text_font));
-  if (map->fill_pattern != RadarUnspecifiedPattern) {
+  if (map->fill_pattern != ZnUnspecifiedPattern) {
     map->fill_pattern = Tk_GetBitmap(wi->interp, wi->win,
 				     Tk_NameOfBitmap(wi->dpy, map->fill_pattern));
   }
@@ -309,10 +309,10 @@ Clone(Item	item)
     Pixmap *pats, *new_pats;
     int	   i, num_pats;
     
-    pats = (Pixmap *) RadarListArray(map->symbol_patterns);
-    num_pats = RadarListSize(map->symbol_patterns);
-    map->symbol_patterns = RadarListNew(num_pats, sizeof(Pixmap));
-    new_pats = (Pixmap *) RadarListArray(map->symbol_patterns);
+    pats = (Pixmap *) ZnListArray(map->symbol_patterns);
+    num_pats = ZnListSize(map->symbol_patterns);
+    map->symbol_patterns = ZnListNew(num_pats, sizeof(Pixmap));
+    new_pats = (Pixmap *) ZnListArray(map->symbol_patterns);
     for (i = 0; i < num_pats; i++) {
       new_pats[i] = Tk_GetBitmap(wi->interp, wi->win,
 				 Tk_NameOfBitmap(wi->dpy, pats[i]));
@@ -335,27 +335,27 @@ Destroy(Item	item)
   MapItem	map = (MapItem) item;
 
   FreeLists(map);
-  RadarFreeColor(map->color);
+  ZnFreeColor(map->color);
   Tk_FreeFont(map->text_font);
-  if (map->fill_pattern != RadarUnspecifiedPattern) {
+  if (map->fill_pattern != ZnUnspecifiedPattern) {
     Tk_FreeBitmap(item->wi->dpy, map->fill_pattern);
   }
   if (map->symbol_patterns) {
     Pixmap *pats;
     int	   i, num_pats;
 
-    pats = (Pixmap *) RadarListArray(map->symbol_patterns);
-    num_pats = RadarListSize(map->symbol_patterns);
+    pats = (Pixmap *) ZnListArray(map->symbol_patterns);
+    num_pats = ZnListSize(map->symbol_patterns);
     for (i = 0; i < num_pats; i++) {
       Tk_FreeBitmap(item->wi->dpy, pats[i]);
     }
-    RadarListFree(map->symbol_patterns);
+    ZnListFree(map->symbol_patterns);
   }
   if (strlen(map->map_info_name) != 0) {
-    RadarFree(map->map_info_name);
+    ZnFree(map->map_info_name);
   }
   if (map->map_info != NULL) {
-    Radar_FreeMapInfo(map->map_info, UpdateMapInfo, (ClientData) map);
+    ZnFreeMapInfo(map->map_info, UpdateMapInfo, (ClientData) map);
   }
 }
 
@@ -370,23 +370,23 @@ Destroy(Item	item)
 static int
 Configure(Item		item,
 	  int		argc,
-	  RadarAttrList	argv,
+	  ZnAttrList	argv,
 	  int		*flags)
 {
   WidgetInfo	*wi = item->wi;
   MapItem	map = (MapItem) 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;
   }
 
-  if (ISSET(*flags, RADAR_MAP_INFO_FLAG)) {
+  if (ISSET(*flags, ZN_MAP_INFO_FLAG)) {
     MapInfoId	map_info;
-    RadarBool	error = False;
+    ZnBool	error = False;
     
     if (strlen(map->map_info_name) != 0) {
-      map_info = Radar_GetMapInfo(wi->interp, map->map_info_name,
-				  UpdateMapInfo, (ClientData) map);
+      map_info = ZnGetMapInfo(wi->interp, map->map_info_name,
+			      UpdateMapInfo, (ClientData) map);
       if (!map_info) {
 	error = True;
       }
@@ -396,16 +396,16 @@ Configure(Item		item,
     }
     if (!error) {
       if (map->map_info != NULL) {
-	Radar_FreeMapInfo(map->map_info, UpdateMapInfo, (ClientData) map);
+	ZnFreeMapInfo(map->map_info, UpdateMapInfo, (ClientData) map);
       }
       map->map_info = map_info;
     }
     else {
-      return RADAR_ERROR;
+      return ZN_ERROR;
     }
   }
 
-  return RADAR_OK;
+  return ZN_OK;
 }
 
 
@@ -419,13 +419,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;
 }
 
 
@@ -439,7 +439,7 @@ Query(Item		item,
 
 static void
 ComputeCoordinates(Item		item,
-		   RadarBool	force)
+		   ZnBool	force)
 {
   WidgetInfo		*wi = item->wi;
   MapItem		map = (MapItem) item;
@@ -459,20 +459,20 @@ ComputeCoordinates(Item		item,
   unsigned int		num_dotted_arcs;
   unsigned int		num_mixed_arcs;
   unsigned int		num_marks;
-  RadarPoint		*vectors, *dashed_vectors, *dotted_vectors;
-  RadarPoint		*mixed_vectors, *marks;
+  ZnPoint		*vectors, *dashed_vectors, *dotted_vectors;
+  ZnPoint		*mixed_vectors, *marks;
   XArc			*arcs, *dashed_arcs, *dotted_arcs, *mixed_arcs;
-  RadarPoint		*symbols, *texts;
-  RadarPoint		from, to, center;
-  RadarPoint		tmp_from, tmp_to;
+  ZnPoint		*symbols, *texts;
+  ZnPoint		from, to, center;
+  ZnPoint		tmp_from, tmp_to;
   XArc			arc;
-  RadarBBox		bbox, bbox_inter, radar_bbox;
+  ZnBBox		bbox, bbox_inter, zn_bbox;
   int			x_from_w, y_from_w, x_to_w, y_to_w;
   int			radius, start_angle, extend;
   unsigned int		radius_w;
   MapInfoPoint		new_marks;
   unsigned int		n_new_marks;
-  RadarFont		text_font;
+  ZnFont		text_font;
   int			sym_w2=0, sym_h2=0;
   
   ResetBBox(&item->item_bounding_box);
@@ -481,9 +481,9 @@ ComputeCoordinates(Item		item,
     return;
   }
 
-  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;
 
   map_info = map->map_info;
 
@@ -586,66 +586,66 @@ ComputeCoordinates(Item		item,
    * clipping and the filled attribute.
    */
   if (!map->vectors) {
-    map->vectors = RadarListNew(num_points, sizeof(RadarPoint));
+    map->vectors = ZnListNew(num_points, sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->vectors, num_points);
+  ZnListAssertSize(map->vectors, num_points);
   if (!map->dashed_vectors) {
-    map->dashed_vectors = RadarListNew(num_dashed_points, sizeof(RadarPoint));
+    map->dashed_vectors = ZnListNew(num_dashed_points, sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->dashed_vectors, num_dashed_points);
+  ZnListAssertSize(map->dashed_vectors, num_dashed_points);
   if (!map->dotted_vectors) {
-    map->dotted_vectors = RadarListNew(num_dotted_points, sizeof(RadarPoint));
+    map->dotted_vectors = ZnListNew(num_dotted_points, sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->dotted_vectors, num_dotted_points);
+  ZnListAssertSize(map->dotted_vectors, num_dotted_points);
   if (!map->mixed_vectors) {
-    map->mixed_vectors = RadarListNew(num_mixed_points, sizeof(RadarPoint));
+    map->mixed_vectors = ZnListNew(num_mixed_points, sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->mixed_vectors, num_mixed_points);
+  ZnListAssertSize(map->mixed_vectors, num_mixed_points);
   if (!map->arcs) {
-    map->arcs = RadarListNew(num_arcs, sizeof(XArc));
+    map->arcs = ZnListNew(num_arcs, sizeof(XArc));
   }
-  RadarListAssertSize(map->arcs, num_arcs);
+  ZnListAssertSize(map->arcs, num_arcs);
   if (!map->dashed_arcs) {
-    map->dashed_arcs = RadarListNew(num_dashed_arcs, sizeof(XArc));
+    map->dashed_arcs = ZnListNew(num_dashed_arcs, sizeof(XArc));
   }
-  RadarListAssertSize(map->dashed_arcs, num_dashed_arcs);
+  ZnListAssertSize(map->dashed_arcs, num_dashed_arcs);
   if (!map->dotted_arcs) {
-    map->dotted_arcs = RadarListNew(num_dotted_arcs, sizeof(XArc));
+    map->dotted_arcs = ZnListNew(num_dotted_arcs, sizeof(XArc));
   }
-  RadarListAssertSize(map->dotted_arcs, num_dotted_arcs);
+  ZnListAssertSize(map->dotted_arcs, num_dotted_arcs);
   if (!map->mixed_arcs) {
-    map->mixed_arcs = RadarListNew(num_mixed_arcs, sizeof(XArc));
+    map->mixed_arcs = ZnListNew(num_mixed_arcs, sizeof(XArc));
   }
-  RadarListAssertSize(map->mixed_arcs, num_mixed_arcs);
+  ZnListAssertSize(map->mixed_arcs, num_mixed_arcs);
   if (!map->marks) {
-    map->marks = RadarListNew(num_marks, sizeof(RadarPoint));
+    map->marks = ZnListNew(num_marks, sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->marks, num_marks);
+  ZnListAssertSize(map->marks, num_marks);
   if (!map->symbols) {
-    map->symbols = RadarListNew(MapInfoNumSymbols(map_info), sizeof(RadarPoint));
+    map->symbols = ZnListNew(MapInfoNumSymbols(map_info), sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->symbols, MapInfoNumSymbols(map_info));
+  ZnListAssertSize(map->symbols, MapInfoNumSymbols(map_info));
   if (!map->texts) {
-    map->texts = RadarListNew(MapInfoNumTexts(map_info), sizeof(RadarPoint));
+    map->texts = ZnListNew(MapInfoNumTexts(map_info), sizeof(ZnPoint));
   }
-  RadarListAssertSize(map->texts, MapInfoNumTexts(map_info));
+  ZnListAssertSize(map->texts, MapInfoNumTexts(map_info));
 
   /*
    * Ask the pointers to the actual arrays.
    */
-  vectors	 = (RadarPoint *) RadarListArray(map->vectors);
-  dashed_vectors = (RadarPoint *) RadarListArray(map->dashed_vectors);
-  dotted_vectors = (RadarPoint *) RadarListArray(map->dotted_vectors);
-  mixed_vectors	 = (RadarPoint *) RadarListArray(map->mixed_vectors);
-  arcs		 = (XArc *) RadarListArray(map->arcs);
-  dashed_arcs	 = (XArc *) RadarListArray(map->dashed_arcs);
-  dotted_arcs	 = (XArc *) RadarListArray(map->dotted_arcs);
-  mixed_arcs	 = (XArc *) RadarListArray(map->mixed_arcs);
-  marks		 = (RadarPoint *) RadarListArray(map->marks);
-  symbols	 = (RadarPoint *) RadarListArray(map->symbols);
-  texts		 = (RadarPoint *) RadarListArray(map->texts);
-
-  if (num_marks && (wi->map_distance_symbol != RadarUnspecifiedPattern)) {
+  vectors	 = (ZnPoint *) ZnListArray(map->vectors);
+  dashed_vectors = (ZnPoint *) ZnListArray(map->dashed_vectors);
+  dotted_vectors = (ZnPoint *) ZnListArray(map->dotted_vectors);
+  mixed_vectors	 = (ZnPoint *) ZnListArray(map->mixed_vectors);
+  arcs		 = (XArc *) ZnListArray(map->arcs);
+  dashed_arcs	 = (XArc *) ZnListArray(map->dashed_arcs);
+  dotted_arcs	 = (XArc *) ZnListArray(map->dotted_arcs);
+  mixed_arcs	 = (XArc *) ZnListArray(map->mixed_arcs);
+  marks		 = (ZnPoint *) ZnListArray(map->marks);
+  symbols	 = (ZnPoint *) ZnListArray(map->symbols);
+  texts		 = (ZnPoint *) ZnListArray(map->texts);
+
+  if (num_marks && (wi->map_distance_symbol != ZnUnspecifiedPattern)) {
     Tk_SizeOfBitmap(wi->dpy, wi->map_distance_symbol, &sym_w2, &sym_h2);
     sym_w2 = (sym_w2+1)/2;
     sym_h2 = (sym_h2+1)/2;
@@ -676,8 +676,8 @@ ComputeCoordinates(Item		item,
     tmp_from.y = y_from_w;
     tmp_to.x = x_to_w;
     tmp_to.y = y_to_w;
-    RadarTransformPoint(wi->current_transfo, &tmp_from, &from);
-    RadarTransformPoint(wi->current_transfo, &tmp_to, &to);
+    ZnTransformPoint(wi->current_transfo, &tmp_from, &from);
+    ZnTransformPoint(wi->current_transfo, &tmp_to, &to);
 
     /*
      * Skip zero length and outside segments.
@@ -687,7 +687,7 @@ ComputeCoordinates(Item		item,
     }
     
     if (!map->filled) {
-      if (LineInBBox(&from, &to, &radar_bbox) < 0) {
+      if (LineInBBox(&from, &to, &zn_bbox) < 0) {
 	continue;
       }
     }
@@ -729,17 +729,17 @@ ComputeCoordinates(Item		item,
 	num_points++;
 	vectors[num_points] = to;
 	num_points++;
-	if (wi->map_distance_symbol != RadarUnspecifiedPattern) {
+	if (wi->map_distance_symbol != ZnUnspecifiedPattern) {
 	  MapInfoGetMarks(map_info, i, &new_marks, &n_new_marks);
 	  for (j = 0; j < n_new_marks; j++) {
 	    /*
 	     * The transform can be put outside the loop when
-	     * MapInfo point type is modified to RadarPoint.
-	     * Will use then RadarTransformPoints.
+	     * MapInfo point type is modified to ZnPoint.
+	     * Will use then ZnTransformPoints.
 	     */
 	    tmp_from.x = new_marks[j].x;
 	    tmp_from.y = new_marks[j].y;
-	    RadarTransformPoint(wi->current_transfo, &tmp_from, &marks[num_marks]);
+	    ZnTransformPoint(wi->current_transfo, &tmp_from, &marks[num_marks]);
 	    AddPointToBBox(&item->item_bounding_box,
 			   marks[num_marks].x-sym_w2, marks[num_marks].y-sym_h2);
 	    AddPointToBBox(&item->item_bounding_box,
@@ -754,17 +754,17 @@ ComputeCoordinates(Item		item,
   
   cnt = MapInfoNumArcs(map_info);
   for (i = 0; i < cnt; i++) {
-    RadarPoint xp;
+    ZnPoint xp;
     
     MapInfoGetArc(map_info, i, NULL, &line_style, &line_width, 
 		  &x_from_w, &y_from_w, &radius_w, &start_angle, &extend);
 
     tmp_from.x = x_from_w;
     tmp_from.y = y_from_w;
-    RadarTransformPoint(wi->current_transfo, &tmp_from, &center);
+    ZnTransformPoint(wi->current_transfo, &tmp_from, &center);
     tmp_from.x += radius_w;
     tmp_from.y = 0;
-    RadarTransformPoint(wi->current_transfo, &tmp_from, &xp);
+    ZnTransformPoint(wi->current_transfo, &tmp_from, &xp);
     radius = xp.x - center.x;
 
     bbox.orig.x = center.x - radius;
@@ -779,7 +779,7 @@ ComputeCoordinates(Item		item,
       continue;
     }
     
-    IntersectBBox(&radar_bbox, &bbox, &bbox_inter);
+    IntersectBBox(&zn_bbox, &bbox, &bbox_inter);
     if (IsEmptyBBox(&bbox_inter)) {
       continue;
     }
@@ -845,10 +845,10 @@ ComputeCoordinates(Item		item,
   /*
    * Truncate arc lists to the real size.
    */
-  RadarListAssertSize(map->arcs, num_arcs);
-  RadarListAssertSize(map->dashed_arcs, num_dashed_arcs);
-  RadarListAssertSize(map->dotted_arcs, num_dotted_arcs);
-  RadarListAssertSize(map->mixed_arcs, num_mixed_arcs);
+  ZnListAssertSize(map->arcs, num_arcs);
+  ZnListAssertSize(map->dashed_arcs, num_dashed_arcs);
+  ZnListAssertSize(map->dotted_arcs, num_dotted_arcs);
+  ZnListAssertSize(map->mixed_arcs, num_mixed_arcs);
   
 #ifdef PERFOS
   StopUCChrono(map->chrono_trans);
@@ -859,17 +859,17 @@ ComputeCoordinates(Item		item,
   /* If map is filled, only the vectors description is valid. */
   if (!map->filled) {
     if (map->symbol_patterns) {
-      Pixmap sym, *syms = (Pixmap *) RadarListArray(map->symbol_patterns);
-      int    num_syms = RadarListSize(map->symbol_patterns);    
+      Pixmap sym, *syms = (Pixmap *) ZnListArray(map->symbol_patterns);
+      int    num_syms = ZnListSize(map->symbol_patterns);    
 
       cnt = MapInfoNumSymbols(map_info);
       for (i = 0; i < cnt; i++) {
 	MapInfoGetSymbol(map_info, i, NULL, &x_from_w, &y_from_w, &symbol);
 	tmp_from.x = x_from_w;
 	tmp_from.y = y_from_w;
-	RadarTransformPoint(wi->current_transfo, &tmp_from, &symbols[i]);
+	ZnTransformPoint(wi->current_transfo, &tmp_from, &symbols[i]);
 	sym = syms[symbol%num_syms];
-	if (sym != RadarUnspecifiedPattern) {
+	if (sym != ZnUnspecifiedPattern) {
 	  Tk_SizeOfBitmap(wi->dpy, sym, &sym_w2, &sym_h2);
 	  sym_w2 = (sym_w2+1)/2;
 	  sym_h2 = (sym_h2+1)/2;
@@ -879,7 +879,7 @@ ComputeCoordinates(Item		item,
 			 symbols[i].x+sym_w2, symbols[i].y+sym_h2);	  
 	}
       }
-      RadarListAssertSize(map->symbols, cnt);
+      ZnListAssertSize(map->symbols, cnt);
     }
 
     cnt = MapInfoNumTexts(map_info);
@@ -889,7 +889,7 @@ ComputeCoordinates(Item		item,
 		     &text_style, &line_style, &x_from_w, &y_from_w, &text);
       tmp_from.x = x_from_w;
       tmp_from.y = y_from_w;
-      RadarTransformPoint(wi->current_transfo, &tmp_from, &texts[i]);
+      ZnTransformPoint(wi->current_transfo, &tmp_from, &texts[i]);
       AddStringToBBox(&item->item_bounding_box, text, text_font,
 		      texts[i].x, texts[i].y);
       
@@ -930,30 +930,30 @@ ComputeCoordinates(Item		item,
 	}
       }
     }
-    RadarListAssertSize(map->texts, cnt);
+    ZnListAssertSize(map->texts, cnt);
   }
     
   /*
    * Truncate line lists to the real size.
    */
-  RadarListAssertSize(map->vectors, num_points);
-  RadarListAssertSize(map->dashed_vectors, num_dashed_points);
-  RadarListAssertSize(map->dotted_vectors, num_dotted_points);
-  RadarListAssertSize(map->mixed_vectors, num_mixed_points);
-  RadarListAssertSize(map->marks, num_marks);
+  ZnListAssertSize(map->vectors, num_points);
+  ZnListAssertSize(map->dashed_vectors, num_dashed_points);
+  ZnListAssertSize(map->dotted_vectors, num_dotted_points);
+  ZnListAssertSize(map->mixed_vectors, num_mixed_points);
+  ZnListAssertSize(map->marks, num_marks);
   
   AddPointsToBBox(&item->item_bounding_box,
-		  (RadarPoint *) RadarListArray(map->vectors),
-		  RadarListSize(map->vectors));
+		  (ZnPoint *) ZnListArray(map->vectors),
+		  ZnListSize(map->vectors));
   AddPointsToBBox(&item->item_bounding_box,
-		  (RadarPoint *) RadarListArray(map->dashed_vectors),
-		  RadarListSize(map->dashed_vectors));
+		  (ZnPoint *) ZnListArray(map->dashed_vectors),
+		  ZnListSize(map->dashed_vectors));
   AddPointsToBBox(&item->item_bounding_box,
-		  (RadarPoint *) RadarListArray(map->dotted_vectors),
-		  RadarListSize(map->dotted_vectors));
+		  (ZnPoint *) ZnListArray(map->dotted_vectors),
+		  ZnListSize(map->dotted_vectors));
   AddPointsToBBox(&item->item_bounding_box,
-		  (RadarPoint *) RadarListArray(map->mixed_vectors),
-		  RadarListSize(map->mixed_vectors));
+		  (ZnPoint *) ZnListArray(map->mixed_vectors),
+		  ZnListSize(map->mixed_vectors));
 }
 
 
@@ -968,11 +968,11 @@ 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)
 {
   return -1;
 }
@@ -992,7 +992,7 @@ Draw(Item	item)
   WidgetInfo	*wi = item->wi;
   MapItem	map = (MapItem) item;
   MapInfoId	map_info;
-  RadarPoint	*points;
+  ZnPoint	*points;
   XPoint	*xpoints;
   char		*text;
   char		tmp_str[] = ".";
@@ -1006,11 +1006,11 @@ Draw(Item	item)
 
   map_info = map->map_info;
 
-  values.foreground = RadarPixel(map->color);
+  values.foreground = ZnPixel(map->color);
 
   if (map->filled) {
-    if (RadarListSize(map->vectors) || RadarListSize(map->arcs)) {
-      if (map->fill_pattern == RadarUnspecifiedPattern) { /* Fill solid */
+    if (ZnListSize(map->vectors) || ZnListSize(map->arcs)) {
+      if (map->fill_pattern == ZnUnspecifiedPattern) { /* Fill solid */
 	values.fill_style = FillSolid;
 	XChangeGC(wi->dpy, wi->gc, GCFillStyle | GCForeground, &values);
       }
@@ -1021,10 +1021,10 @@ Draw(Item	item)
 		  GCFillStyle | GCStipple | GCForeground, &values);
       }
       
-      cnt = RadarListSize(map->vectors);
+      cnt = ZnListSize(map->vectors);
       if (cnt) {
 	xpoints = (XPoint *) alloca(cnt * sizeof(XPoint));
-	points = (RadarPoint *) RadarListArray(map->vectors);
+	points = (ZnPoint *) ZnListArray(map->vectors);
 	for (i = 0; i < cnt; i++) {
 	  xpoints[i].x = points[i].x;
 	  xpoints[i].y = points[i].y;
@@ -1033,9 +1033,9 @@ Draw(Item	item)
 		     Nonconvex, CoordModeOrigin);
       }
       
-      if (RadarListSize(map->arcs)) {
+      if (ZnListSize(map->arcs)) {
 	XFillArcs(wi->dpy, wi->draw_buffer, wi->gc,
-		  (XArc *) RadarListArray(map->arcs), RadarListSize(map->arcs));
+		  (XArc *) ZnListArray(map->arcs), ZnListSize(map->arcs));
       }
     }
   }
@@ -1044,7 +1044,7 @@ Draw(Item	item)
 #ifdef PERFOS
     StartUCChrono(map->chrono_draw);
 #endif
-    if (RadarListSize(map->vectors)) {
+    if (ZnListSize(map->vectors)) {
       SetLineStyle(wi->dpy, wi->gc, LINE_SIMPLE);
       values.fill_style = FillSolid;
       values.line_width = 0;
@@ -1054,10 +1054,10 @@ Draw(Item	item)
       /* !! WARNING !! XDrawSegments can't handle an unlimited number of segments
 	 in releases R4 and older */
       /*      XDrawSegments(wi->dpy, wi->draw_buffer, wi->gc,
-		    (XSegment *) RadarListArray(map->vectors),
-		    RadarListSize(map->vectors)/2);*/
-      cnt = RadarListSize(map->vectors);
-      points = (RadarPoint *) RadarListArray(map->vectors);
+		    (XSegment *) ZnListArray(map->vectors),
+		    ZnListSize(map->vectors)/2);*/
+      cnt = ZnListSize(map->vectors);
+      points = (ZnPoint *) ZnListArray(map->vectors);
       for (i = 0; i < cnt; i += 2) {
 	if (LineInBBox(&points[i], &points[i+1], &wi->damaged_area) >= 0) {
           MapInfoGetLine(map_info, i/2, NULL, NULL, &line_width, NULL,
@@ -1073,7 +1073,7 @@ Draw(Item	item)
       }
     }
 
-    if (RadarListSize(map->dashed_vectors)) {
+    if (ZnListSize(map->dashed_vectors)) {
       SetLineStyle(wi->dpy, wi->gc, LINE_DASHED);
       values.fill_style = FillSolid;
       values.line_width = 0;
@@ -1082,9 +1082,9 @@ Draw(Item	item)
       /* !! WARNING !! XDrawSegments can't handle an unlimited number of segments
 	 in releases R4 and older */
 /*      XDrawSegments(wi->dpy, wi->draw_buffer, wi->gc,
-		    (XSegment *) RadarListArray(map->dashed_vectors), RadarListSize(map->dashed_vectors)/2);*/
-      cnt = RadarListSize(map->dashed_vectors);
-      points = (RadarPoint *) RadarListArray(map->dashed_vectors);
+		    (XSegment *) ZnListArray(map->dashed_vectors), ZnListSize(map->dashed_vectors)/2);*/
+      cnt = ZnListSize(map->dashed_vectors);
+      points = (ZnPoint *) ZnListArray(map->dashed_vectors);
       for (i = 0; i < cnt; i += 2) {
 	if (LineInBBox(&points[i], &points[i+1], &wi->damaged_area) >= 0) {
           MapInfoGetLine(map_info, i/2, NULL, NULL, &line_width, NULL, NULL, NULL, NULL);
@@ -1099,7 +1099,7 @@ Draw(Item	item)
       }
     }
     
-    if (RadarListSize(map->dotted_vectors)) {
+    if (ZnListSize(map->dotted_vectors)) {
       SetLineStyle(wi->dpy, wi->gc, LINE_DOTTED);
       values.fill_style = FillSolid;
       values.line_width = 0;
@@ -1109,9 +1109,9 @@ Draw(Item	item)
       /* !! WARNING !! XDrawSegments can't handle an unlimited number of segments
 	 in releases R4 and older */
 /*      XDrawSegments(wi->dpy, wi->draw_buffer, wi->gc,
-		    (XSegment *) RadarListArray(map->dotted_vectors), RadarListSize(map->dotted_vectors)/2);*/
-      cnt = RadarListSize(map->dotted_vectors);
-      points = (RadarPoint *) RadarListArray(map->dotted_vectors);
+		    (XSegment *) ZnListArray(map->dotted_vectors), ZnListSize(map->dotted_vectors)/2);*/
+      cnt = ZnListSize(map->dotted_vectors);
+      points = (ZnPoint *) ZnListArray(map->dotted_vectors);
       for (i = 0; i < cnt; i += 2) {
 	if (LineInBBox(&points[i], &points[i+1], &wi->damaged_area) >= 0) {
           MapInfoGetLine(map_info, i/2, NULL, NULL, &line_width, NULL, NULL, NULL, NULL);
@@ -1126,7 +1126,7 @@ Draw(Item	item)
       }
     }
     
-    if (RadarListSize(map->mixed_vectors)) {
+    if (ZnListSize(map->mixed_vectors)) {
       SetLineStyle(wi->dpy, wi->gc, LINE_MIXED);
       values.fill_style = FillSolid;
       values.line_width = 0;
@@ -1135,9 +1135,9 @@ Draw(Item	item)
       /* !! WARNING !! XDrawSegments can't handle an unlimited number of segments
 	 in releases R4 and older */
       /*XDrawSegments(wi->dpy, wi->draw_buffer, wi->gc,
-		    (XSegment *) RadarListArray(map->mixed_vectors), RadarListSize(map->mixed_vectors)/2);*/
-      cnt = RadarListSize(map->mixed_vectors);
-      points = (RadarPoint *) RadarListArray(map->mixed_vectors);
+		    (XSegment *) ZnListArray(map->mixed_vectors), ZnListSize(map->mixed_vectors)/2);*/
+      cnt = ZnListSize(map->mixed_vectors);
+      points = (ZnPoint *) ZnListArray(map->mixed_vectors);
       for (i = 0; i < cnt; i += 2) {
 	if (LineInBBox(&points[i], &points[i+1], &wi->damaged_area) >= 0) {
           MapInfoGetLine(map_info, i/2, NULL, NULL, &line_width, NULL, NULL, NULL, NULL);
@@ -1152,7 +1152,7 @@ Draw(Item	item)
       }
     }
     
-    if (RadarListSize(map->arcs)) {
+    if (ZnListSize(map->arcs)) {
     
       SetLineStyle(wi->dpy, wi->gc, LINE_SIMPLE);
       values.fill_style = FillSolid;
@@ -1163,10 +1163,10 @@ Draw(Item	item)
 	 in releases R4 and older */
       
       XDrawArcs(wi->dpy, wi->draw_buffer, wi->gc,
-		(XArc *) RadarListArray(map->arcs), RadarListSize(map->arcs));
+		(XArc *) ZnListArray(map->arcs), ZnListSize(map->arcs));
     }
     
-    if (RadarListSize(map->dashed_arcs)) {
+    if (ZnListSize(map->dashed_arcs)) {
       
       SetLineStyle(wi->dpy, wi->gc, LINE_DASHED);
       values.fill_style = FillSolid;
@@ -1177,11 +1177,11 @@ Draw(Item	item)
 	 in releases R4 and older */
       
       XDrawArcs(wi->dpy, wi->draw_buffer, wi->gc,
-		(XArc *) RadarListArray(map->dashed_arcs),
-		RadarListSize(map->dashed_arcs));
+		(XArc *) ZnListArray(map->dashed_arcs),
+		ZnListSize(map->dashed_arcs));
     }
     
-    if (RadarListSize(map->dotted_arcs)) {
+    if (ZnListSize(map->dotted_arcs)) {
       
       SetLineStyle(wi->dpy, wi->gc, LINE_DOTTED);
       values.fill_style = FillSolid;
@@ -1192,11 +1192,11 @@ Draw(Item	item)
 	 in releases R4 and older */
       
       XDrawArcs(wi->dpy, wi->draw_buffer, wi->gc,
-		(XArc *) RadarListArray(map->dotted_arcs),
-		RadarListSize(map->dotted_arcs));
+		(XArc *) ZnListArray(map->dotted_arcs),
+		ZnListSize(map->dotted_arcs));
     }
     
-    if (RadarListSize(map->mixed_arcs)) {
+    if (ZnListSize(map->mixed_arcs)) {
       
       SetLineStyle(wi->dpy, wi->gc, LINE_MIXED);
       values.fill_style = FillSolid;
@@ -1207,21 +1207,21 @@ Draw(Item	item)
 	 in releases R4 and older */
       
       XDrawArcs(wi->dpy, wi->draw_buffer, wi->gc,
-		(XArc *) RadarListArray(map->mixed_arcs),
-		RadarListSize(map->mixed_arcs));
+		(XArc *) ZnListArray(map->mixed_arcs),
+		ZnListSize(map->mixed_arcs));
     }
     
-    if (RadarListSize(map->texts)) {
+    if (ZnListSize(map->texts)) {
       /* For the Tk widget we don't have to bother with old
        * compatibility issues.
        */
-      values.font = RadarFontId(map->text_font);
+      values.font = ZnFontId(map->text_font);
       values.fill_style = FillSolid;
       XChangeGC(wi->dpy, wi->gc,
 		GCFillStyle | GCFont | GCForeground, &values);
       
-      cnt = RadarListSize(map->texts);
-      points = (RadarPoint *) RadarListArray(map->texts);
+      cnt = ZnListSize(map->texts);
+      points = (ZnPoint *) ZnListArray(map->texts);
       for (i = 0; i < cnt; i++) {
 	MapInfoGetText(map_info, i, NULL, NULL, NULL, NULL, NULL, &text);
 	XDrawString(wi->dpy, wi->draw_buffer, wi->gc,
@@ -1229,7 +1229,7 @@ Draw(Item	item)
       }
     }
       
-    if (RadarListSize(map->symbols) || RadarListSize(map->marks)) {
+    if (ZnListSize(map->symbols) || ZnListSize(map->marks)) {
       int    w, h, ox, oy;
       Pixmap sym;
       
@@ -1237,15 +1237,15 @@ Draw(Item	item)
       XChangeGC(wi->dpy, wi->gc, GCFillStyle, &values);
       
       if (map->symbol_patterns) {
-	Pixmap *syms = (Pixmap *) RadarListArray(map->symbol_patterns);
-	int    num_syms = RadarListSize(map->symbol_patterns);
+	Pixmap *syms = (Pixmap *) ZnListArray(map->symbol_patterns);
+	int    num_syms = ZnListSize(map->symbol_patterns);
 	
-	cnt = RadarListSize(map->symbols);
-	points = (RadarPoint *) RadarListArray(map->symbols);
+	cnt = ZnListSize(map->symbols);
+	points = (ZnPoint *) ZnListArray(map->symbols);
 	for (i = 0; i < cnt; i++) {
 	  MapInfoGetSymbol(map_info, i, NULL, NULL, NULL, &(tmp_str[0]));
 	  sym = syms[tmp_str[0]%num_syms];
-	  if (sym != RadarUnspecifiedPattern) {
+	  if (sym != ZnUnspecifiedPattern) {
 	    Tk_SizeOfBitmap(wi->dpy, sym, &w, &h);
 	    ox = points[i].x-w/2;
 	    oy = points[i].y-h/2;
@@ -1259,10 +1259,10 @@ Draw(Item	item)
 	}
       }
 
-      if (wi->map_distance_symbol != RadarUnspecifiedPattern) {
+      if (wi->map_distance_symbol != ZnUnspecifiedPattern) {
 	Tk_SizeOfBitmap(wi->dpy, wi->map_distance_symbol, &w, &h);
-	cnt = RadarListSize(map->marks);
-	points = (RadarPoint *) RadarListArray(map->marks);
+	cnt = ZnListSize(map->marks);
+	points = (ZnPoint *) ZnListArray(map->marks);
 	values.stipple = wi->map_distance_symbol;
 	XChangeGC(wi->dpy, wi->gc, GCStipple, &values);
 	for (i = 0; i < cnt; i++) {
@@ -1292,12 +1292,12 @@ Draw(Item	item)
  *
  **********************************************************************************
  */
-static RadarBool
+static ZnBool
 IsSensitive(Item	item,
 	    int		item_part)
 {
   return (ISSET(item->flags, SENSITIVE_BIT) &&
-	  item->parent->class->IsSensitive(item->parent, RADAR_NO_PART));
+	  item->parent->class->IsSensitive(item->parent, ZN_NO_PART));
 }
 
 
@@ -1315,7 +1315,7 @@ IsSensitive(Item	item,
  */
 static double
 Pick(Item	item,
-     RadarPoint	*p,
+     ZnPoint	*p,
      Item	start_item,
      int	aperture,
      Item	*a_item,
@@ -1334,15 +1334,15 @@ Pick(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)
 {
   Tcl_AppendResult(item->wi->interp,
 		   " maps doesn't support the coords command", NULL);
-  return RADAR_ERROR;
+  return ZN_ERROR;
 }
 
 
@@ -1392,4 +1392,4 @@ static ItemClassStruct MAP_ITEM_CLASS = {
   PostScript
 };
 
-RadarItemClassId RadarMap = (RadarItemClassId) &MAP_ITEM_CLASS;
+ZnItemClassId ZnMap = (ZnItemClassId) &MAP_ITEM_CLASS;