var trackPointsArray = []
  var pointsArray = [];
  var polyline = null;
  var trackname = ""
    
  var map;

 


  /*------------ Utility functions -----------*/

  function getText(element) {
    return element.textContent ? element.textContent : element.text
  }





  /*------------ Wpt --------------*/
  
  function toPt(marker, i) {
    marker.map_i = i
   }

  


 /*------------- Trkpt ------------*/
 

  GMarker.prototype.convertTtoTrkpt = function(i) {
    this.map_arrayname = "trackPointsArray"
    this.map_gpxelt = "trkpt"
    this.map_areLabelsShown = 0
    this.map_autoalt = true;
    
    toPt(this, i)
  }

  function newTrackpoint(point, alt, name) {
    var pt = new GMarker(point, {draggable: true})
    pt.convertTtoTrkpt(trackPointsArray.length, alt, name)
    trackPointsArray.push(pt)
    pointsArray.push(pt.getPoint())
    return pt
  }

  /*------------ Global functions -----------*/

 

  function map_drawline() {
    if (polyline) {
      map.removeOverlay(polyline);
    }
    if (pointsArray && pointsArray.length > 0) {
      polyline = new GPolyline(pointsArray, "#ff0000", 5);
      map.addOverlay(polyline);
    } else {
      polyline = undefined
    }
  }

  function map_clear() {
    map.clearOverlays()
    var i = 0
    while (i < trackPointsArray.length) {
      i++
    }

    polyline = undefined
    pointsArray = [];
    trackPointsArray = [];
  }
  

  function map_loadGPX(filename) {
       GDownloadUrl(filename, function(data, responseCode) {
      map_importGPX(data);
    });
  }

  // Function to import the points from the GPX data.
  function map_importPoints(xmlpts, is_trk) {
    var point;
    for (var i = 0; i < xmlpts.length; i++) {
      point = new GLatLng(parseFloat(xmlpts[i].getAttribute("lat")),
                          parseFloat(xmlpts[i].getAttribute("lon")));
      var ele = undefined
      var eles = xmlpts[i].getElementsByTagName("ele");
      if (eles.length > 0) {
        ele  = parseFloat(getText(eles[0]))
      }
      var name = undefined
      var names = xmlpts[i].getElementsByTagName("name");
      if (names.length > 0) {
        name  = getText(names[0])
      }
      if (is_trk) {
        pt = newTrackpoint(point, ele, name)
      } 
    }

  }
    
  // Function to import the GPX data.
  function map_importGPX(gpxinput) {
    map_clear();
    if (!gpxinput || gpxinput == "") {
      return
    }
    var xml = GXml.parse(gpxinput);
    var gpx = xml ? xml.getElementsByTagName("gpx") : undefined 
     if (!xml.documentElement || !gpx || (gpx.length == 0)) {
      return
    }
    gpx = xml.documentElement
    if (xml) {
      var bounds = gpx.getElementsByTagName("bounds");
      var pts = gpx.getElementsByTagName("trkpt");
      if (pts) map_importPoints(pts, true);
      pts = gpx.getElementsByTagName("wpt");
      if (pts) map_importPoints(pts, false);
      var center = new GLatLng(0,0)
      var zoom = 15
      if (bounds && bounds.length > 0) {
        var sw = new GLatLng(parseFloat(bounds[0].getAttribute("minlat")),
                             parseFloat(bounds[0].getAttribute("minlon")))
        var ne = new GLatLng(parseFloat(bounds[0].getAttribute("maxlat")),
                             parseFloat(bounds[0].getAttribute("maxlon")))
        var mapbounds = new GLatLngBounds(sw, ne)
        center = new GLatLng((sw.lat()+ne.lat())/2,(sw.lng()+ne.lng())/2)       
        zoom = Math.max(map.getBoundsZoomLevel(mapbounds),15)      
      } else if (trackPointsArray && trackPointsArray.length > 0) {
        center = trackPointsArray[trackPointsArray.length - 1].getPoint()
      }

      // try and calculate the bounds manually if there are no automatic bounds.
      var minlat = -180
      var maxlat = 180
      var minlon = -180
      var maxlon = 180
      var i = 0;
      do {
        var pt = trackPointsArray[i]
	if (pt.getPoint().lat() > minlat) {
          minlat = pt.getPoint().lat()
	}
	if (pt.getPoint().lat() < maxlat) {
          maxlat = pt.getPoint().lat()
	}
	if (pt.getPoint().lng() > minlon) {
          minlon = pt.getPoint().lng()
	}
	if (pt.getPoint().lng() < maxlon) {
          maxlon = pt.getPoint().lng()
	}
	// Move to the next point.
	i++
      } while (i < trackPointsArray.length)

      // set the bounds accordingly.
      var marginRatio = 0.0001;       //leave margin each side 

      var minLatLng = new GLatLng(minlat-marginRatio, minlon-marginRatio);
      var maxLatLng = new GLatLng(maxlat+marginRatio, maxlon+marginRatio);
     
      var bounds = new GLatLngBounds;
      bounds.extend(maxLatLng);
      bounds.extend(minLatLng);      
      map.setZoom(map.getBoundsZoomLevel(bounds));
      map.setCenter(bounds.getCenter());

      // Now draw the line.  
      if (trackPointsArray && trackPointsArray.length > 0) {
         var pt = trackPointsArray[trackPointsArray.length - 1];
         map_drawline();
      }
    }
  }




  
  function map_load(map_num) {
    if (GBrowserIsCompatible()) {
      // Create a map within the division
      var divWithMap = document.getElementById("map")
      map = new GMap2(divWithMap);

      // Add the controls
      map.addControl(new GLargeMapControl());
      map.setCenter(new GLatLng(0,0), 3, G_NORMAL_MAP);
      map.addControl(new GMapTypeControl());
      map.enableScrollWheelZoom();
 
      // Load the relevant map...
     var fileString = "http://www.britishwalks.org/walks/walk_data/stripped_gpx_files/StrippedWalk"+map_num+".gpx"
        map_loadGPX(fileString);
    }
  }