Adaptation des ent�tes.

Suppression de MapInfoP.h

1 files changed, 1289 insertions, 0 deletions

diff --git a/generic/MapInfo.c b/generic/MapInfo.c
new file mode 100644
index 0000000..be4c4ae
--- /dev/null
+++ b/generic/MapInfo.c
@@ -0,0 +1,1289 @@
+/*
+ * MapInfo.c -- MapInfo interface.
+ *
+ * Authors		: Patrick Lecoanet.
+ * Creation date	: 
+ *
+ * $Id$
+ */
+
+/*
+ *  Copyright (c) 1993 - 1999 CENA, Patrick Lecoanet --
+ *
+ * This code is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This code is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this code; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/param.h>
+
+#include "MapInfo.h"
+
+#include <memory.h>
+#include <math.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/param.h>
+
+
+static const char rcsid[] = "$Id$";
+static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $";
+
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * New types
+ *
+ *-----------------------------------------------------------------------
+ */
+typedef struct {
+  RadarPtr		tag;
+  MapInfoLineStyle	style;
+  int			width;
+  MapInfoPointStruct	center;
+  unsigned int		radius;
+  int			start_angle;
+  int			extend;
+} MapInfoArcStruct, *MapInfoArc;
+
+typedef struct {
+  RadarPtr		tag;
+  MapInfoLineStyle	style;
+  int			width;
+  MapInfoPointStruct	from;
+  MapInfoPointStruct	to;
+  unsigned int		num_marks;
+  MapInfoPoint		marks;
+} MapInfoLineStruct, *MapInfoLine;
+
+typedef struct {
+  RadarPtr		tag;
+  MapInfoPointStruct	at;
+  char          	symbol[2];
+} MapInfoSymbolStruct, *MapInfoSymbol;
+
+typedef struct {
+  RadarPtr		tag;
+  MapInfoTextStyle	text_style;
+  MapInfoLineStyle	line_style;
+  MapInfoPointStruct	at;
+  char          	*text;
+} MapInfoTextStruct, *MapInfoText;
+
+typedef struct {
+  char		*name;
+  RadarList	lines;
+  RadarList	symbols;
+  RadarList	texts;
+  RadarList	arcs;
+} MapInfoStruct, *MapInfo;
+
+
+#define	MARKERS_SPACING		80.0	/* 10 nautic miles in 1/8 of a mile */
+#define	BASE_ALLOC_SIZE		8
+
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * Macros.
+ * 
+ *-----------------------------------------------------------------------
+ */
+#define NOT_MARKED_STYLE(style)						\
+((style) == MapInfoLineMarked ? MapInfoLineSimple : (style));
+
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * ComputeLineMarks --
+ *	Add marks to a line in the marks substructure.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void
+ComputeLineMarks(MapInfoLine	marked_line)
+{
+  double	length;
+  unsigned int	j;
+  int		x_from = marked_line->from.x;
+  int		y_from = marked_line->from.y;
+  int		x_to = marked_line->to.x;
+  int		y_to = marked_line->to.y;
+  int		delta_x = x_from - x_to;
+  int		delta_y = y_from - y_to;
+  int		step_x, step_y;
+
+  length = sqrt((double)((delta_x) * (delta_x) + (delta_y) * (delta_y)));
+  step_x = (int) ((x_to - x_from) * MARKERS_SPACING / length);
+  step_y = (int) ((y_to - y_from) * MARKERS_SPACING / length);
+  marked_line->num_marks = (int) length / MARKERS_SPACING;
+
+  /* We don't want markers at ends, so we get rid of the last one
+     if it is at an end */
+  if (fmod(length, MARKERS_SPACING) == 0.0) {
+    (marked_line->num_marks)--;
+  }
+
+  if (marked_line->num_marks) {
+    marked_line->marks = (MapInfoPoint) RadarMalloc(marked_line->num_marks * sizeof(MapInfoPointStruct));
+  }
+  
+  for (j = 0; j < marked_line->num_marks; j++) {
+    marked_line->marks[j].x = x_from + ((j + 1) * step_x);
+    marked_line->marks[j].y = y_from + ((j + 1) * step_y);
+  }
+}
+
+
+MapInfoId
+MapInfoCreate(char	*name)
+{
+  MapInfo	new_map;
+
+  new_map = (MapInfo) RadarMalloc(sizeof(MapInfoStruct));
+  memset((char *) new_map, 0, sizeof(MapInfoStruct));
+  if (!name) {
+    name = "";
+  }
+  new_map->name = (char *) RadarMalloc(strlen(name)+1);
+  strcpy(new_map->name, name);
+  
+  return((MapInfoId) new_map);
+}
+
+
+char *
+MapInfoName(MapInfoId	map_info)
+{
+  if (!map_info) {
+    return "";
+  }
+  return ((MapInfo) map_info)->name;
+}
+
+
+MapInfoId
+MapInfoDuplicate(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfo	new_map;
+  int		i, num_lines, num_texts;
+  MapInfoText	new_texts, cur_texts;
+  MapInfoLine	new_lines, cur_lines;
+
+  if (!cur_map) {
+    return ((MapInfoId) NULL);
+  }
+  
+  new_map = (MapInfo) MapInfoCreate(cur_map->name);
+
+  if (cur_map->lines) {
+    new_map->lines = RadarListDuplicate(cur_map->lines);
+
+    cur_lines = (MapInfoLine) RadarListArray(cur_map->lines);
+    new_lines = (MapInfoLine) RadarListArray(new_map->lines);
+    num_lines = RadarListSize(cur_map->lines);
+
+    for (i = 0; i < num_lines; i++) {
+      if (new_lines[i].style == MapInfoLineMarked) {
+	new_lines[i].marks = (MapInfoPoint) RadarMalloc(new_lines[i].num_marks *
+							sizeof(MapInfoPointStruct));
+	memcpy((char *) new_lines[i].marks,
+	       (char *) cur_lines[i].marks,
+	       new_lines[i].num_marks * sizeof(MapInfoPointStruct));
+      }
+    }
+  }
+  if (cur_map->symbols) {
+    new_map->symbols = RadarListDuplicate(cur_map->symbols);
+  }
+  if (cur_map->texts) {
+    new_map->texts = RadarListDuplicate(cur_map->texts);
+
+    cur_texts = (MapInfoText) RadarListArray(cur_map->texts);
+    new_texts = (MapInfoText) RadarListArray(new_map->texts);
+    num_texts = RadarListSize(cur_map->texts);
+    
+    for (i = 0; i < num_texts; i++) {
+      new_texts[i].text = (char *) RadarMalloc(strlen(cur_texts[i].text) + 1);
+      strcpy(new_texts[i].text, cur_texts[i].text);
+    }
+  }
+  if (cur_map->arcs) {
+    new_map->arcs = RadarListDuplicate(cur_map->arcs);
+  }
+
+  return((MapInfoId) new_map);
+}
+
+
+void
+MapInfoDelete(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  int		i, num_texts, num_lines;
+  MapInfoText	cur_texts;
+  MapInfoLine	cur_lines;
+  
+  if (cur_map) {
+    if (cur_map->texts) {
+      num_texts = RadarListSize(cur_map->texts);
+      cur_texts = (MapInfoText) RadarListArray(cur_map->texts);
+
+      for (i = 0; i < num_texts; i++) {
+	RadarFree((char *) cur_texts[i].text);
+      }
+      
+      RadarListFree(cur_map->texts);
+    }
+
+    if (cur_map->lines) {
+      num_lines = RadarListSize(cur_map->lines);
+      cur_lines = (MapInfoLine) RadarListArray(cur_map->lines);
+
+      for (i = 0; i < num_lines; i++) {
+	if (cur_lines[i].style == MapInfoLineMarked) {
+	  RadarFree((char *) cur_lines[i].marks);
+	}
+      }
+
+      RadarListFree(cur_map->lines);
+    }
+
+    if (cur_map->symbols) {
+      RadarListFree(cur_map->symbols);
+    }
+    
+    if (cur_map->arcs) {
+      RadarListFree(cur_map->arcs);
+    }
+    
+    RadarFree(cur_map->name);
+    RadarFree(cur_map);
+  }
+}
+
+void
+MapInfoEmpty(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+
+  if (cur_map) {
+    if (cur_map->texts) {
+      RadarListEmpty(cur_map->texts);
+    }
+    if (cur_map->lines) {
+      RadarListEmpty(cur_map->lines);
+    }
+    if (cur_map->symbols) {
+      RadarListEmpty(cur_map->symbols);
+    }
+    if (cur_map->arcs) {
+      RadarListEmpty(cur_map->arcs);
+    }
+  }
+}
+
+
+void
+MapInfoAddLine(MapInfoId	map_info,
+	       unsigned int	index,
+	       RadarPtr		tag,
+	       MapInfoLineStyle	line_style,
+	       int		line_width,
+	       int		x_from,
+	       int		y_from,
+	       int		x_to,
+	       int		y_to)
+{
+  MapInfo		cur_map = (MapInfo) map_info;
+  MapInfoLineStruct	line_struct;
+
+  if (cur_map) {
+    if (!cur_map->lines) {
+      cur_map->lines = RadarListNew(16, sizeof(MapInfoLineStruct));
+    }
+
+    line_struct.style = line_style;
+    if (line_width == 1) {
+      line_struct.width = 0;
+    }
+    else {
+      line_struct.width = line_width;
+    }
+    line_struct.tag = tag;
+    line_struct.from.x = x_from;
+    line_struct.from.y = y_from;
+    line_struct.to.x = x_to;
+    line_struct.to.y = y_to;
+    
+    if (line_style == MapInfoLineMarked) {
+      ComputeLineMarks(&line_struct);
+    }
+    
+    RadarListAdd(cur_map->lines, &line_struct, index);
+  }
+}
+
+
+void
+MapInfoReplaceLine(MapInfoId		map_info,
+		   unsigned int		index,
+		   RadarPtr		tag,
+		   MapInfoLineStyle	line_style,
+		   int			line_width,
+		   int			x_from,
+		   int			y_from,
+		   int			x_to,
+		   int			y_to)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoLine	line_ptr;
+
+  if (cur_map && cur_map->lines) {
+    line_ptr = (MapInfoLine) RadarListAt(cur_map->lines, index);
+    if (line_ptr) {
+      if (line_ptr->style == MapInfoLineMarked) {
+	RadarFree((char *) line_ptr->marks);
+      }
+
+      line_ptr->style = line_style;
+      if (line_width == 1) {
+        line_ptr->width = 0;
+      }
+      else {
+        line_ptr->width = line_width;
+      }
+      line_ptr->tag = tag;
+      line_ptr->from.x = x_from;
+      line_ptr->from.y = y_from;
+      line_ptr->to.x = x_to;
+      line_ptr->to.y = y_to;
+
+      if (line_ptr->style == MapInfoLineMarked) {
+	ComputeLineMarks(line_ptr);
+      }
+    }
+  }
+}
+
+
+void
+MapInfoRemoveLine(MapInfoId	map_info,
+		  unsigned int	index)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoLine	line_ptr;
+
+  if (cur_map && cur_map->lines) {
+    line_ptr = (MapInfoLine) RadarListAt(cur_map->lines, index);
+    if (line_ptr) {
+      if (line_ptr->style == MapInfoLineMarked) {
+	RadarFree((char *) line_ptr->marks);
+      }
+
+      RadarListDelete(cur_map->lines, index);
+    }
+  }
+}
+
+
+void
+MapInfoGetLine(MapInfoId		map_info,
+	       unsigned int		index,
+	       RadarPtr			*tag,
+	       MapInfoLineStyle		*line_style,
+	       int			*line_width,
+	       int			*x_from,
+	       int			*y_from,
+	       int			*x_to,
+	       int			*y_to)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoLine	line_ptr;
+
+  if (cur_map && cur_map->lines) {
+    line_ptr = (MapInfoLine) RadarListAt(cur_map->lines, index);
+    if (line_ptr) {
+      if (tag) {
+	*tag = line_ptr->tag;
+      }
+      if (line_style) {
+	*line_style = line_ptr->style;
+      }
+      if (line_width) {
+        if (line_ptr->width == 1) {
+	  *line_width = 0;
+	}
+        else {
+	  *line_width = line_ptr->width;
+	}
+      }
+      if (x_from) {
+	*x_from = line_ptr->from.x;
+      }
+      if (y_from) {
+	*y_from = line_ptr->from.y;
+      }
+      if (x_to) {
+	*x_to = line_ptr->to.x;
+      }
+      if (y_to) {
+	*y_to = line_ptr->to.y;
+      }
+    }
+  }
+}
+
+
+void
+MapInfoGetMarks(MapInfoId	map_info,
+		unsigned int	index,
+		MapInfoPoint 	*marks,
+		unsigned int	*num_marks)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoLine	line_ptr;
+
+  if (cur_map && cur_map->lines) {
+    line_ptr = (MapInfoLine) RadarListAt(cur_map->lines, index);
+    if (line_ptr && line_ptr->style == MapInfoLineMarked) {
+      if (marks) {
+	*marks = line_ptr->marks;
+      }
+      if (num_marks) {
+	*num_marks = line_ptr->num_marks;
+      }
+    }
+  }
+}
+
+
+unsigned int
+MapInfoNumLines(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+
+  if (cur_map && cur_map->lines) {
+    return RadarListSize(cur_map->lines);
+  }
+  else {
+    return 0;
+  }
+}
+ 
+  
+void
+MapInfoAddSymbol(MapInfoId	map_info,
+		 unsigned int	index,
+		 RadarPtr	tag,
+		 int		x,
+		 int		y,
+		 char		symbol)
+{
+  MapInfo		cur_map = (MapInfo) map_info;
+  MapInfoSymbolStruct	symbol_struct;
+
+  if (cur_map) {
+    if (!cur_map->symbols) {
+      cur_map->symbols = RadarListNew(16, sizeof(MapInfoSymbolStruct));
+    }
+    
+    symbol_struct.tag = tag;
+    symbol_struct.at.x = x;
+    symbol_struct.at.y = y;
+    symbol_struct.symbol[0] = symbol;
+    symbol_struct.symbol[1] = '\0';
+    
+    RadarListAdd(cur_map->symbols, &symbol_struct, index);
+  }
+}
+
+
+void
+MapInfoReplaceSymbol(MapInfoId		map_info,
+		     unsigned int	index,
+		     RadarPtr		tag,
+		     int		x,
+		     int		y,
+		     char		symbol)
+{
+  MapInfo		cur_map = (MapInfo) map_info;
+  MapInfoSymbolStruct	symbol_struct;
+
+  if (cur_map && cur_map->symbols) {
+    symbol_struct.tag = tag;
+    symbol_struct.at.x = x;
+    symbol_struct.at.y = y;
+    symbol_struct.symbol[0] = symbol;
+    symbol_struct.symbol[1] = '\0';
+
+    RadarListAtPut(cur_map->symbols, &symbol_struct, index);
+  }
+}
+
+
+void
+MapInfoRemoveSymbol(MapInfoId		map_info,
+		    unsigned int	index)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+
+  if (cur_map && cur_map->symbols) {
+    RadarListDelete(cur_map->symbols, index);
+  }
+}
+
+
+void
+MapInfoGetSymbol(MapInfoId	map_info,
+		 unsigned int	index,
+		 RadarPtr	*tag,
+		 int		*x,
+		 int		*y,
+		 char		*symbol)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoSymbol	symbol_ptr;
+
+  if (cur_map && cur_map->symbols) {
+    symbol_ptr = (MapInfoSymbol) RadarListAt(cur_map->symbols, index);
+    if (symbol_ptr) {
+      if (tag) {
+	*tag = symbol_ptr->tag;
+      }
+      if (x) {
+	*x = symbol_ptr->at.x;
+      }
+      if (y) {
+	*y = symbol_ptr->at.y;
+      }
+      if (symbol) {
+	*symbol = symbol_ptr->symbol[0];
+      }
+    }
+  }
+}
+
+
+unsigned int
+MapInfoNumSymbols(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+
+  if (cur_map && cur_map->symbols) {
+    return RadarListSize(cur_map->symbols);
+  }
+  else {
+    return 0;
+  }
+}
+ 
+  
+void
+MapInfoAddText(MapInfoId	map_info,
+	       unsigned int	index,
+	       RadarPtr		tag,
+	       MapInfoTextStyle	text_style,
+	       MapInfoLineStyle	line_style,
+	       int		x,
+	       int		y,
+	       char		*text)
+{
+  MapInfo		cur_map = (MapInfo) map_info;
+  MapInfoTextStruct	text_struct;
+
+  if (cur_map) {
+    if (!cur_map->texts) {
+      cur_map->texts = RadarListNew(16, sizeof(MapInfoTextStruct));
+    }
+
+    text_struct.tag	   = tag;
+    text_struct.text_style = text_style;
+    text_struct.line_style = NOT_MARKED_STYLE(line_style);
+    text_struct.at.x	   = x;
+    text_struct.at.y	   = y;
+    text_struct.text	   = (char *) RadarMalloc(strlen(text) + 1);
+    strcpy(text_struct.text, text);
+    
+    RadarListAdd(cur_map->texts, &text_struct, index);
+  }
+}
+
+
+void
+MapInfoReplaceText(MapInfoId		map_info,
+		   unsigned int		index,
+		   RadarPtr		tag,
+		   MapInfoTextStyle	text_style,
+		   MapInfoLineStyle	line_style,
+		   int			x,
+		   int			y,
+		   char			*text)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoText	text_ptr;
+
+  if (cur_map && cur_map->texts) {
+    text_ptr = (MapInfoText) RadarListAt(cur_map->texts, index);
+    if (text_ptr) {
+      RadarFree(text_ptr->text);
+
+      text_ptr->tag	   = tag;
+      text_ptr->text_style = text_style;
+      text_ptr->line_style = NOT_MARKED_STYLE(line_style);
+      text_ptr->at.x	   = x;
+      text_ptr->at.y	   = y;
+      text_ptr->text	   = (char *) RadarMalloc(strlen(text) + 1);
+      strcpy(text_ptr->text, text);
+    }
+  }
+}
+
+
+void
+MapInfoRemoveText(MapInfoId	map_info,
+		  unsigned int	index)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoText	text_ptr;
+
+  if (cur_map && cur_map->texts) {
+    text_ptr = (MapInfoText) RadarListAt(cur_map->texts, index);
+    if (text_ptr) {
+      RadarFree(text_ptr->text);
+
+      RadarListDelete(cur_map->texts, index);
+    }
+  }
+}
+
+
+void
+MapInfoGetText(MapInfoId	map_info,
+	       unsigned int	index,
+	       RadarPtr		*tag,
+	       MapInfoTextStyle	*text_style,
+	       MapInfoLineStyle	*line_style,
+	       int		*x,
+	       int		*y,
+	       char		**text)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoText	text_ptr;
+
+  if (cur_map && cur_map->texts) {
+    text_ptr = (MapInfoText) RadarListAt(cur_map->texts, index);
+    if (text_ptr) {
+      if (tag) {
+	*tag = text_ptr->tag;
+      }
+      if (text_style) {
+	*text_style = text_ptr->text_style;
+      }
+      if (line_style) {
+	*line_style = text_ptr->line_style;
+      }
+      if (x) {
+	*x = text_ptr->at.x;
+      }
+      if (y) {
+	*y = text_ptr->at.y;
+      }
+      if (text) {
+	*text = text_ptr->text;
+      }
+    }
+  }
+}
+
+
+unsigned int
+MapInfoNumTexts(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+
+  if (cur_map && cur_map->texts) {
+    return RadarListSize(cur_map->texts);
+  }
+  else {
+    return 0;
+  }
+}
+
+
+void
+MapInfoAddArc(MapInfoId		map_info,
+	      unsigned int	index,
+	      RadarPtr		tag,
+	      MapInfoLineStyle	line_style,
+	      int		line_width,
+	      int		center_x,
+	      int		center_y,
+	      unsigned int	radius,
+	      int		start_angle,
+	      int		extend)
+{
+  MapInfo		cur_map = (MapInfo) map_info;
+  MapInfoArcStruct	arc_struct;
+  
+  if (cur_map) {
+    if (!cur_map->arcs) {
+      cur_map->arcs = RadarListNew(16, sizeof(MapInfoArcStruct));
+    }
+
+    arc_struct.style		= NOT_MARKED_STYLE(line_style);
+    if (line_width == 1) {
+      arc_struct.width		= 0;
+    }
+    else {
+      arc_struct.width		= line_width;
+    }
+    arc_struct.tag		= tag;
+    arc_struct.center.x		= center_x;
+    arc_struct.center.y		= center_y;
+    arc_struct.radius		= radius;
+    arc_struct.start_angle	= start_angle;
+    arc_struct.extend		= extend;
+    
+    RadarListAdd(cur_map->arcs, &arc_struct, index);
+  }
+}
+
+
+void
+MapInfoReplaceArc(MapInfoId		map_info,
+		  unsigned int		index,
+		  RadarPtr		tag,
+		  MapInfoLineStyle	line_style,
+		  int			line_width,
+		  int			center_x,
+		  int			center_y,
+		  unsigned int		radius,
+		  int			start_angle,
+		  int			extend)
+{
+  MapInfo		cur_map = (MapInfo) map_info;
+  MapInfoArc		arc_ptr;
+  
+  if (cur_map && cur_map->arcs) {
+    arc_ptr = (MapInfoArc) RadarListAt(cur_map->arcs, index);
+    if (arc_ptr) {
+      arc_ptr->style		= NOT_MARKED_STYLE(line_style);
+      if (line_width == 1) {
+        arc_ptr->width		= 0;
+      }
+      else {
+        arc_ptr->width		= line_width;
+      }
+      arc_ptr->tag		= tag;
+      arc_ptr->center.x		= center_x;
+      arc_ptr->center.y		= center_y;
+      arc_ptr->radius		= radius;
+      arc_ptr->start_angle	= start_angle;
+      arc_ptr->extend		= extend;      
+    }
+  }
+}
+
+
+void
+MapInfoRemoveArc(MapInfoId	map_info,
+		 unsigned int	index)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoArc	arc_ptr;
+
+  if (cur_map && cur_map->arcs) {
+    arc_ptr = (MapInfoArc) RadarListAt(cur_map->arcs, index);
+    if (arc_ptr) {
+      RadarListDelete(cur_map->arcs, index);
+    }
+  }
+}
+
+
+void
+MapInfoGetArc(MapInfoId		map_info,
+	      unsigned int	index,
+	      RadarPtr		*tag,
+	      MapInfoLineStyle	*line_style,
+	      int		*line_width,
+	      int		*center_x,
+	      int		*center_y,
+	      unsigned int	*radius,
+	      int		*start_angle,
+	      int		*extend)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+  MapInfoArc	arc_ptr;
+
+  if (cur_map && cur_map->arcs) {
+    arc_ptr = (MapInfoArc) RadarListAt(cur_map->arcs, index);
+    if (arc_ptr) {
+      if (tag) {
+	*tag = arc_ptr->tag;
+      }
+      if (line_style) {
+	*line_style = arc_ptr->style;
+      }
+      if (line_width) {
+        if (arc_ptr->width == 1) {
+	  *line_width = 0;
+	}
+        else {
+	  *line_width = arc_ptr->width;
+	}
+      }
+      if (center_x) {
+	*center_x = arc_ptr->center.x;
+      }
+      if (center_y) {
+	*center_y = arc_ptr->center.y;
+      }
+      if (radius) {
+	*radius = arc_ptr->radius;
+      }
+      if (start_angle) {
+	*start_angle = arc_ptr->start_angle;
+      }
+      if (extend) {
+	*extend = arc_ptr->extend;
+      }
+    }
+  }
+}
+
+unsigned int
+MapInfoNumArcs(MapInfoId	map_info)
+{
+  MapInfo	cur_map = (MapInfo) map_info;
+
+  if (cur_map && cur_map->arcs) {
+    return RadarListSize(cur_map->arcs);
+  }
+  else {
+    return 0;
+  }
+}
+
+void
+MapInfoScale(MapInfoId	map_info,
+	     double	factor)
+{
+  MapInfo	mp = (MapInfo) map_info;
+  int		i, num;
+  MapInfoLine	line_ptr;
+  MapInfoSymbol	sym_ptr;
+  MapInfoText	text_ptr;
+  MapInfoArc	arc_ptr;
+
+  if (mp && mp->lines) {
+    num = RadarListSize(mp->lines);
+    line_ptr = (MapInfoLine) RadarListArray(mp->lines);
+    for (i = 0; i < num; i++, line_ptr++) {
+      line_ptr->from.x *= factor;
+      line_ptr->from.y *= factor;
+      line_ptr->to.x *= factor;
+      line_ptr->to.y *= factor;
+    }
+  }
+  if (mp && mp->symbols) {
+    num = RadarListSize(mp->symbols);
+    sym_ptr = (MapInfoSymbol) RadarListArray(mp->symbols);
+    for (i = 0; i < num; i++, sym_ptr++) {
+      sym_ptr->at.x *= factor;
+      sym_ptr->at.y *= factor;
+    }
+  }
+  if (mp && mp->texts) {
+    num = RadarListSize(mp->texts);
+    text_ptr = (MapInfoText) RadarListArray(mp->texts);
+    for (i = 0; i < num; i++, text_ptr++) {
+      text_ptr->at.x *= factor;
+      text_ptr->at.y *= factor;
+    }
+  }
+  if (mp && mp->arcs) {
+    num = RadarListSize(mp->arcs);
+    arc_ptr = (MapInfoArc) RadarListArray(mp->arcs);
+    for (i = 0; i < num; i++, arc_ptr++) {
+      arc_ptr->center.x *= factor;
+      arc_ptr->center.y *= factor;
+      arc_ptr->radius *= factor;
+    }
+  }
+}
+
+void
+MapInfoTranslate(MapInfoId	map_info,
+		 int		x,
+		 int		y)
+{
+  MapInfo	mp = (MapInfo) map_info;
+  int		i, num;
+  MapInfoLine	line_ptr;
+  MapInfoSymbol	sym_ptr;
+  MapInfoText	text_ptr;
+  MapInfoArc	arc_ptr;
+
+  if (mp && mp->lines) {
+    num = RadarListSize(mp->lines);
+    line_ptr = (MapInfoLine) RadarListArray(mp->lines);
+    for (i = 0; i < num; i++, line_ptr++) {
+      line_ptr->from.x += x;
+      line_ptr->from.y += y;
+      line_ptr->to.x += x;
+      line_ptr->to.y += y;
+    }
+  }
+  if (mp && mp->symbols) {
+    num = RadarListSize(mp->symbols);
+    sym_ptr = (MapInfoSymbol) RadarListArray(mp->symbols);
+    for (i = 0; i < num; i++, sym_ptr++) {
+      sym_ptr->at.x += x;
+      sym_ptr->at.y += y;
+    }
+  }
+  if (mp && mp->texts) {
+    num = RadarListSize(mp->texts);
+    text_ptr = (MapInfoText) RadarListArray(mp->texts);
+    for (i = 0; i < num; i++, text_ptr++) {
+      text_ptr->at.x += x;
+      text_ptr->at.y += y;
+    }
+  }
+  if (mp && mp->arcs) {
+    num = RadarListSize(mp->arcs);
+    arc_ptr = (MapInfoArc) RadarListArray(mp->arcs);
+    for (i = 0; i < num; i++, arc_ptr++) {
+      arc_ptr->center.x += x;
+      arc_ptr->center.y += y;
+    }
+  }
+}
+
+
+
+#define TEXT_SIZE		256
+#define ntohi(n) ntohl((n))
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * Videomap record definition. Ints are assumed to be 4 bytes.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+typedef struct {
+  int	id;		/* Map id (internal) */
+  int	dashed;		/* Tell if vectors are dashed (exclusive with marked) */
+  int	expanded;	/* Device coordinates or world coordinates (ignored now) */
+  int   marked;         /* Tell if vectors are marked (exclusive with dashed) */
+  int   color;          /* drawing color (ignored now) */
+  int   elements[50];	/* Element type ('P', 'V', 'T') */
+  int   x[50];          /* Coordinates if 'P' or 'V' */
+  int   y[50];
+  int   symbol[50];	/* Filled if 'P' or 'V' */
+  int   text[50];       /* Low order byte is ascii char if 'T' */
+  int   num_elements;   /* Number of elements */
+} VideoMap;
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * ReorderVidomap - reorder integers according to the endianess
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void
+ReorderVidomap(VideoMap *vm)
+{
+  int   loop;
+  
+  vm->id = ntohi(vm->id);
+  vm->dashed = ntohi(vm->dashed);
+  vm->expanded = ntohi(vm->expanded);
+  vm->marked = ntohi(vm->marked);
+  vm->color = ntohi(vm->color);
+  for (loop = 0; loop < 50; loop++) {
+    vm->elements[loop] = ntohi(vm->elements[loop]);
+    vm->x[loop] = ntohi(vm->x[loop]);
+    vm->y[loop] = ntohi(vm->y[loop]);
+    vm->symbol[loop] = ntohi(vm->symbol[loop]);
+    vm->text[loop] = ntohi(vm->text[loop]);
+  }
+  vm->num_elements = ntohi(vm->num_elements);
+}
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * FillMap - Fill map with data in Videomap record vm.
+ *
+ *-----------------------------------------------------------------------
+ */
+
+static void FillMap(MapInfoId map, VideoMap *vm)
+{
+  unsigned int	i;
+  RadarBool	has_start_pos = False;
+  int		x_cur=0, y_cur=0;
+  char		ch;
+  int		text_x=0, text_y=0;
+  char		text[TEXT_SIZE];
+  RadarBool	in_text = False;
+  RadarBool	in_mod_text = False;
+  unsigned int	text_size=0;
+
+  for (i = 0; i < vm->num_elements; i++) {
+    switch(vm->elements[i] & 0xFF) {
+      case 'p':
+      case 'P':
+        if (in_text) {
+	  in_text = in_mod_text = False;
+	  while (text[text_size - 1] == ' ') {
+	    text_size--;
+	  }
+	  text[text_size] = (char) 0;
+	  MapInfoAddText(map, MapInfoNumTexts(map), NULL, MapInfoNormalText,
+			 MapInfoLineSimple, text_x, text_y, text);
+	}
+
+        x_cur = (int) (short) vm->x[i];
+        y_cur = (int) (short) vm->y[i];
+	has_start_pos = True;
+	
+        if (vm->symbol[i]) {
+	  MapInfoAddSymbol(map, MapInfoNumSymbols(map), NULL, x_cur, y_cur, vm->symbol[i]);
+	}
+        break;
+
+	/* We gather consecutive 'T' elements in a text. We skip
+	   leading and trailing spaces and mod texts (between '@'
+	   and now obsolete) */
+
+      case 't':
+      case 'T':
+	if (!has_start_pos) {
+	  RadarWarning("Bloc carte incorrect, il est elimine");
+	  return;
+	}
+
+	if (in_text == False) {
+	  ch = (char) vm->text[i] & 0xFF;
+	  if (ch == '@') {
+	    if (in_mod_text == True) {
+	      in_mod_text = False;
+	    }
+	    else {
+	      in_mod_text = True;
+	    }
+	  }
+	  else if (in_mod_text == False) {
+	    in_text = True;
+	    text_size = 0;
+	    text_x = x_cur;
+	    text_y = y_cur;
+	    text[0] = (char) 0;
+	  }
+	}
+	if (in_text) {
+	  text[text_size] = (char) vm->text[i] & 0xFF;
+	  text_size++;
+	}
+        break;
+
+      case 'v':
+      case 'V':
+	if (!has_start_pos) {
+	  RadarWarning("Bloc carte incorrect, il est elimine");
+	  return;
+	}
+
+        if (in_text) {
+	  in_text = in_mod_text = False;
+	  while (text[text_size - 1] == ' ') {
+	    text_size--;
+	  }
+	  text[text_size] = (char) 0;
+	  MapInfoAddText(map, MapInfoNumTexts(map), NULL, MapInfoNormalText,
+			 MapInfoLineSimple, text_x, text_y, text);
+	}
+
+        if (vm->dashed)	{
+	  MapInfoAddLine(map, MapInfoNumLines(map), NULL, MapInfoLineDashed, 0,
+			 x_cur, y_cur,
+			 (int) (short) vm->x[i], (int) (short) vm->y[i]);
+	}
+        else if (vm->marked) {
+	  MapInfoAddLine(map, MapInfoNumLines(map), NULL, MapInfoLineMarked, 0,
+			 x_cur, y_cur,
+			 (int) (short) vm->x[i], (int) (short) vm->y[i]);
+	}
+	else {
+	  MapInfoAddLine(map, MapInfoNumLines(map), NULL, MapInfoLineSimple, 0,
+			 x_cur, y_cur,
+			 (int) (short) vm->x[i], (int) (short) vm->y[i]);
+	}
+
+        x_cur = (int) (short) vm->x[i];
+        y_cur = (int) (short) vm->y[i];
+
+        if (vm->symbol[i]) {
+	  MapInfoAddSymbol(map, MapInfoNumSymbols(map), NULL, x_cur, y_cur, vm->symbol[i]);
+	}
+        break;
+      }
+  }
+
+  if (in_text) {
+    in_text = in_mod_text = False;
+    while (text[text_size - 1] == ' ') {
+      text_size--;
+    }
+    text[text_size] = (char) 0;
+    MapInfoAddText(map, MapInfoNumTexts(map), NULL, MapInfoNormalText,
+		   MapInfoLineSimple, text_x, text_y, text);
+  }
+}
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * MapInfoGetVideomap - Load a mapinfo with the content of a videomap
+ *	file named 'filename'. Only the sub map 'index' will be loaded.
+ *	If successful a new mapinfo is returned, NULL otherwise. The
+ *	index is zero based.
+ *
+ *-----------------------------------------------------------------------
+ */
+int
+MapInfoGetVideomap(MapInfoId	map,
+		   char		*filename,
+		   int		index)
+{
+  VideoMap	current_vm;
+  FILE		*file;
+  int		cur_index, cur_id;
+
+  /* Open the specified map file. */
+  file = fopen(filename, "r");
+  if (file == NULL) {
+    return RADAR_ERROR;
+  }
+
+  /* Load the map */
+
+  /* First skip the leading maps up to index. */
+  cur_index = 0;
+  if (fread(&current_vm, sizeof(VideoMap), 1, file) < 0) {
+    goto error;
+  }
+  cur_id = ntohi(current_vm.id);
+  while (cur_index != index) {
+    if (fread(&current_vm, sizeof(VideoMap), 1, file) < 0) {
+      goto error;
+    }
+    if (cur_id != ntohi(current_vm.id)) {
+      cur_index++;
+      cur_id = ntohi(current_vm.id);
+    }
+  };
+
+  /* Then load all the map modules. */
+  do {
+    ReorderVidomap(&current_vm);
+    FillMap(map, &current_vm);
+    if ((fread(&current_vm, sizeof(VideoMap), 1, file) != 1) && !feof(file)) {
+      goto error;
+    }
+  }
+  while ((cur_id == ntohi(current_vm.id)) && !feof(file));
+
+  fclose(file);
+  return RADAR_OK;
+
+error:
+  fclose(file);
+  return RADAR_ERROR;
+}
+
+/*
+ *-----------------------------------------------------------------------
+ *
+ * MapInfoVideomapIds - Return the list of sub map ids contained in a
+ *	videomap file. This makes it possible to iterate through such
+ *	a file without stumbling on an error, to know how much maps
+ *	are there and to sort them according to their ids.
+ *
+ *-----------------------------------------------------------------------
+ */ 
+
+RadarList
+MapInfoVideomapIds(char	*filename)
+{
+  FILE		*file;
+  VideoMap	current_vm;
+  int		cur_id;
+  RadarList	ids;
+  
+  /* Open the specified map file. */
+  file = fopen(filename, "r");
+  if (file == NULL) {
+    return NULL;
+  }
+
+  if (fread(&current_vm, sizeof(VideoMap), 1, file) < 0) {
+    goto error;
+  }
+  cur_id = ntohi(current_vm.id);
+  ids = RadarListNew(16, sizeof(int));
+  /*printf("id %d\n", cur_id);*/
+  RadarListAdd(ids, &cur_id, RadarListTail);
+  
+  do {
+    if (fread(&current_vm, sizeof(VideoMap), 1, file) < 0) {
+      goto error;
+    }
+    if (cur_id != ntohi(current_vm.id)) {
+      cur_id = ntohi(current_vm.id);
+      /*printf("id %d\n", cur_id);*/
+      RadarListAdd(ids, &cur_id, RadarListTail);
+    }
+  }
+  while (!feof(file));
+
+  fclose(file);
+  return ids;
+  
+error:
+  fclose(file);
+  RadarListFree(ids);
+  return NULL;
+}