var kEDITTRACK 	= 1;
var kEDITMARKER = 2;
var kVIEW 		= 3;
var kMAXPOINTS_SCR 		= 100;
var kMAXPOINTS 			= 2000;
var kLENGTHofJPEGFILE 	= 29;
var kMAXCaptureSpeed 	= 4000;
var kMAXGapOfElevation	= 1000;

var gMarkerPointer = null;
var gHighlighted_marker = null;
var gHighlighted_index	= 0;
var gPoints = [];
var gPoint_markers = [];
var gMode = 0;
var gHdlGLargeMapControl;
var gFileName;

var gHdlSubWindow;
var gGeoCoder = null;
var gExifTime;

var	gWeather 	= [];
var gURL 		= [];
var gTitle 		= [];
var gDesc 		= [];
				
var gRandomStr = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJLKLNOPQRSTUVWXYZ";

var gTraceHdl;
var gJG;

function calcDist(lat1,lng1,lat2,lng2) {
    var r = 3963.0;
	// var MILESASKM = 1.609344;
	   // var multiplier = currentUnit == "miles" ? 1 : MILESASKM;
	var multiplier = 1.609344;
	return multiplier * r * Math.acos(Math.sin(lat1/57.2958) * Math.sin(lat2/57.2958) +     Math.cos(lat1/57.2958) * Math.cos(lat2/57.2958) * Math.cos(lng2/57.2958 - lng1/57.2958));
}



//---------------------------------------------------------
//  Calculation of Interval time
//---------------------------------------------------------
function calcIntTime()
{
	var kTIME = 700;
	
	if ((gTraceHdl.idx + 1) < gPoints.length) {
		curPt	= new GLatLng(gPoints[gTraceHdl.idx].Latitude,gPoints[gTraceHdl.idx].Longitude);
		nxtPt	= new GLatLng(gPoints[gTraceHdl.idx+1].Latitude,gPoints[gTraceHdl.idx+1].Longitude);
		intTime	= curPt.distanceFrom(nxtPt) / gTraceHdl.maxDis2 * kTIME;
	}
	else {
		intTime = kTIME;
	}
	
	return intTime;
}


//---------------------------------------------------------
//  Trace ON
//---------------------------------------------------------
function TraceON()
{
	if (gTraceHdl.timer == null && gPoints.length > 0) {
		gTraceHdl.timer = window.setInterval("updateTracePoint()",calcIntTime());
	}
}

//---------------------------------------------------------
//  Trace OFF
//---------------------------------------------------------
function TraceOFF()
{
	if (gTraceHdl.timer != null && gPoints.length > 0) {
		window.clearInterval(gTraceHdl.timer);
		gTraceHdl.timer = null;
	}
}

//---------------------------------------------------------
//  Trace Reset
//---------------------------------------------------------
function TraceRESET()
{
	if (gPoints.length > 0) {
		TraceOFF();
		newPoint = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
		document.map.panTo(newPoint);
		gTraceHdl.idx = 0;
	}
}

//---------------------------------------------------------
//  Update trace point
//---------------------------------------------------------
function updateTracePoint() {
	window.clearInterval(gTraceHdl.timer);
	gTraceHdl.timer = window.setInterval("updateTracePoint()",calcIntTime());
	
	newPoint = new GLatLng(gPoints[gTraceHdl.idx].Latitude,gPoints[gTraceHdl.idx].Longitude);
	document.map.panTo(newPoint);
	++gTraceHdl.idx;
	
	if (gTraceHdl.idx > (gPoints.length - 1)) {
		TraceOFF();
		gTraceHdl.idx = 0;
	}
}



//---------------------------------------------------------
//  Geo coder
//---------------------------------------------------------
function showAddress(address) {
  if (gGeoCoder) {
    gGeoCoder.getLatLng(address,function(point) {
      	document.map.setCenter(point, 13);
    });
  }
}


//---------------------------------------------------------
//  Get random file name (Generate 29 characters)
//---------------------------------------------------------
function getRandomFileName() {
	var dt = new Date();
	
	var strRnd = "";
	
	for (var i = 0 ; i < 14; ++i) {
		strRnd = strRnd + gRandomStr.charAt(Math.random() * gRandomStr.length);
	}
	
	var strYearTmp 	= ("0000"+dt.getYear());
	var strYear  	= strYearTmp.substr(strYearTmp.length-2,2);
	
	var strMonthTmp	= ("00"+dt.getMonth()).substr(-2);
	var strMonth	= strMonthTmp.substr(strMonthTmp.length-2,2);
	
	var strDateTmp	= ("00"+dt.getDate()).substr(-2);
	var strDate  	= strDateTmp.substr(strDateTmp.length-2,2);
	
	var strHoursTmp = ("00"+dt.getHours()).substr(-2);
	var strHours 	= strHoursTmp.substr(strHoursTmp.length-2,2);
	
	var strMinTmp   = ("00"+dt.getMinutes()).substr(-2);
	var strMin  	= strMinTmp.substr(strMinTmp.length-2,2);
	
	var strSecTmp   = ("00"+dt.getSeconds()).substr(-2);
	var strSec   	= strSecTmp.substr(strSecTmp.length-2,2);
	
	var strMsTmp    = ("000"+dt.getMilliseconds()).substr(-3);
	var strMs   	= strMsTmp.substr(strMsTmp.length-3,3);
	
	var RandomFileName = strYear + strMonth + strDate + strHours + strMin + strSec + strMs + strRnd;
	
	return RandomFileName;
}

//---------------------------------------------------------
//  Save map
//---------------------------------------------------------
function saveMapEntry() {
	
	if (gPoints.length == 0 && gWayPoints_markers.length == 0) {
		alert("保存するデータが存在しません");
	}
	else if (  document.getElementById('ArticlePassword1').value.length == 0) {
		alert("パスワードを入力してください");
	}
	else if ((	document.getElementById('ArticlePassword1').value != 
				document.getElementById('ArticlePassword2').value)) {
		alert("パスワードが一致しません");
	}
	else {
		var mapFileName = getRandomFileName();
		saveMap(mapFileName);
		document.NameFormSave.submit();
	}
}


//---------------------------------------------------------
//  Save map
//---------------------------------------------------------
function saveMap(mapFileName) {
	
	var str = "";
	var sym;
	
	for (var i = 0; i < gPoints.length; ++i) {
		str = str + gPoints[i].Latitude + "," + gPoints[i].Longitude + "," + gPoints[i].Elevation + "," + gPoints[i].Datetime + ",";
	}
		
	document.getElementById('ID_ToPHP_points').value = str;
	
	
	str = "";
	SP  = "^";
	
	for (var i = 0; i < gWayPoints_markers.length; ++i) {
		
		sym = gSymJtoE[gWayPoints_markers[i].sym];
		
		str = str + gWayPoints_markers[i].getPoint().lat() 	+ SP + gWayPoints_markers[i].getPoint().lng()  	+ SP +
					sym										+ SP + gWayPoints_markers[i].name 				+ SP +
					gWayPoints_markers[i].cmt     	 		+ SP + gWayPoints_markers[i].photoFileName		+ SP +
					gWayPoints_markers[i].exifDate			+ SP + gWayPoints_markers[i].exifTime			+ SP +
					gOffsetTime								+ SP;
	}
	
	document.getElementById('ID_ToPHP_markers').value 			= str;
	document.getElementById('ID_FromToPHP_gpxFileName').value 	= mapFileName;
}


//---------------------------------------------------------
//  Add all overlays of gPoint_markers in the current area
//---------------------------------------------------------
function addOverlay_gPoints_area()
{
	var tmpPt;
	var area = document.map.getBounds();
	
	for (var i = 0; i < gPoints.length; ++i) {
		tmpPt = new GLatLng(gPoints[i].Latitude,gPoints[i].Longitude);
		
		if (area.contains(tmpPt)) {
			document.map.addOverlay(gPoint_markers[i]);
			
		}
	}
}

//-----------------------------------------------------------
//  Check all overlays of gPoint_markers in the current area
//-----------------------------------------------------------
function checkOverlay_gPoints_area()
{
	var tmpPt;
	var area = document.map.getBounds();
	var count = 0;
	
	for (var i = 0; i < gPoints.length; ++i) {
		tmpPt = new GLatLng(gPoints[i].Latitude,gPoints[i].Longitude);
		
		if (area.contains(tmpPt)) {
			++count;
		}
	}
	return count;
}

//------------------------------------------------------------
//  Delete all overlays of gPoint_markers in the current area
//------------------------------------------------------------
function deleteOverlay_gPoints_area()
{
	for (var i = 0; i < gPoints.length; ++i) {
		document.map.removeOverlay(gPoint_markers[i]);
	}
}


//-------------------------------------------------
//  Add a Map Dragend even
//-------------------------------------------------
function addEventMapDragend() {
	GEvent.addListener(document.map, "dragend", function(overlay, point) {
	
		if (gMode != kEDITTRACK)
			return;
		
		if (checkOverlay_gPoints_area() > kMAXPOINTS_SCR) {
			setRadioButtonView();
			ViewMode();
			alert("表示されるマーカー数が多過ぎます。地図を拡大してください。");
			return;
		}
		
		deleteOverlay_gPoints_area();
		addOverlay_gPoints_area();
   
	});
}

//-------------------------------------------------
//  Add a Map Zoomend event
//-------------------------------------------------
function addEventMapZoomend() {
	GEvent.addListener(document.map, "zoomend", function(overlay, point) {
		
		if (gMode != kEDITTRACK)
			return;
		
		deleteOverlay_gPoints_area();
		addOverlay_gPoints_area();
   
	});
}


//-------------------------------------------------
//  Set radio button (Track)
//-------------------------------------------------
function setRadioButtonTrack() {
	document.getElementsByName("RadioButtonMode")[0].checked = true;
	document.getElementsByName("RadioButtonMode")[1].checked = false;
	document.getElementsByName("RadioButtonMode")[2].checked = false;
}


//-------------------------------------------------
//  Set radio button (Marker)
//-------------------------------------------------
function setRadioButtonMarker() {
	document.getElementsByName("RadioButtonMode")[0].checked = false;
	document.getElementsByName("RadioButtonMode")[1].checked = true;
	document.getElementsByName("RadioButtonMode")[2].checked = false;
}


//-------------------------------------------------
//  Set radio button (View)
//-------------------------------------------------
function setRadioButtonView() {
	document.getElementsByName("RadioButtonMode")[0].checked = false;
	document.getElementsByName("RadioButtonMode")[1].checked = false;
	document.getElementsByName("RadioButtonMode")[2].checked = true;
}


//-------------------------------------------------
//  Enable buttons (Track)
//-------------------------------------------------
function enableTrackButtons() {
	document.getElementById("IDFormMapEdit").ButtonAddPoint.disabled 	= false;
	document.getElementById("IDFormMapEdit").ButtonInsPoint.disabled 	= false;
	document.getElementById("IDFormMapEdit").ButtonDelPoint.disabled 	= false;
	document.getElementById("IDFormMapEdit").ButtonAllDelPoint.disabled = false;
	
	document.getElementById("IDFormMarker").ButtonAddMarker.disabled 	= true;
	document.getElementById("IDFormMarker").ButtonDelMarker.disabled 	= true;
	document.getElementById("IDFormMarker").ButtonChangeMarker.disabled = true;
}


//-------------------------------------------------
//  Enable buttons (Marker)
//-------------------------------------------------
function enableMarkerButtons() {
	document.getElementById("IDFormMapEdit").ButtonAddPoint.disabled 	= true;
	document.getElementById("IDFormMapEdit").ButtonInsPoint.disabled 	= true;
	document.getElementById("IDFormMapEdit").ButtonDelPoint.disabled 	= true;
	document.getElementById("IDFormMapEdit").ButtonAllDelPoint.disabled = true;
	
	document.getElementById("IDFormMarker").ButtonAddMarker.disabled 	= false;
	document.getElementById("IDFormMarker").ButtonDelMarker.disabled 	= false;
	document.getElementById("IDFormMarker").ButtonChangeMarker.disabled = false;
}


//-------------------------------------------------
//  Disable buttons (Marker)
//-------------------------------------------------
function disableButtons() {
	document.getElementById("IDFormMapEdit").ButtonAddPoint.disabled 	= true;
	document.getElementById("IDFormMapEdit").ButtonInsPoint.disabled 	= true;
	document.getElementById("IDFormMapEdit").ButtonDelPoint.disabled 	= true;
	document.getElementById("IDFormMapEdit").ButtonAllDelPoint.disabled = true;
	
	document.getElementById("IDFormMarker").ButtonAddMarker.disabled 	= true;
	document.getElementById("IDFormMarker").ButtonDelMarker.disabled 	= true;
	document.getElementById("IDFormMarker").ButtonChangeMarker.disabled = true;

}


//-------------------------------------------------
//  Check GLarge Map Control
//
//  If the size of data to display on screen is larger than kMAXPINTS_SCR,
//  the GLarge Map Control is not displayed.
//-------------------------------------------------
function checkGLargeMapControl() {
	if (gMode == kEDITTRACK) {
		if (gPoints.length > kMAXPOINTS_SCR) {
			document.map.removeControl(gHdlGLargeMapControl);
		}
		else {
			document.map.addControl(gHdlGLargeMapControl);
		}
	}
	else {
		document.map.addControl(gHdlGLargeMapControl);
	}
}


//-------------------------------------------------
//  Add a point to the points list.
//-------------------------------------------------
function addPoint() {
	
	var offsetLat;
	var offsetLng;
	
	if (gMarkerPointer == null && gPoints.length == 0) {
			alert("ポイントを指定してください");
			return;
	}
	
	
	if (gMarkerPointer == null) {
		offsetLat = "0.0001";
		offsetLng = "0.0001";
	}
	else {
		offsetLat = "0.0000";
		offsetLng = "0.0000";
	}
	
  var lat = document.getElementById('txtLatitude').value;
  var pLat = parseFloat(lat) + parseFloat(offsetLat);
  lat = pLat.toString();
  document.getElementById('txtLatitude').value = lat;
  
  if (pLat.toString() != lat) {
    alert('Invalid latitude entered. Must be in range of -90 to 90');
    return;
  }

  if (pLat < -90 || pLat > 90) {
    alert('Invalid latitude entered. Must be in range of -90 to 90');
    return;
  }

  var lng = document.getElementById('txtLongitude').value;
  var pLong = parseFloat(lng) + parseFloat(offsetLng);
  lng = pLong.toString();
  document.getElementById('txtLongitude').value = lng;

  if (pLong.toString() != lng) {
    alert('Invalid longitude entered. Must be in range of -180 to 180');
    return;
  }

  if (pLong < -180 || pLong > 180) {
    alert('Invalid longitude entered. Must be in range of -180 to 180');
    return;
  }

  var level = 3;
  var pLevel = parseInt(level,10);

  if (pLevel.toString() != level) {
    alert('Invalid minimum level entered. Must be in range of 0 to 3');
    return;
  }

  if (pLevel < 0 || pLevel > 3) {
    alert('Invalid minimum level entered. Must be in range of 0 to 3');
    return;
  }
	createPoint(lat, lng, pLevel);
 	createEncodings(false);
	checkGLargeMapControl();
	CalcDistance();
}


//-------------------------------------------------
//  Insert a point
//-------------------------------------------------
function insertPoint() {
	
	var index = findMarkerIndex(gHighlighted_marker);
	
	if (index == -1 || index == (gPoints.length - 1) || gPoints.length <= 1) {
		return;
	}
	
	var newPoint = {
		Latitude	: 0,
		Longitude	: 0,
		Elevation	: 0,
		Level		: 0,
		Datetime	: null
	};
	
	gPoints.push(newPoint);
	
	for (var i = gPoints.length - 1; index < i; --i) {
		gPoints[i] = gPoints[i-1];
	}
	
	var point1 = gPoints[index    ];
	var point2 = gPoints[index + 2];
	
	var lat1 = point1.Latitude;
	var lat2 = point2.Latitude;
	if (lat1 > lat2) {
		var tmp1 = Math.floor((lat1 - lat2) / 2 * 1e15)
		var tmp2 = Math.floor(lat2 * 1e15);
	}
	else {
		var tmp1 = Math.floor((lat2 - lat1) / 2 * 1e15);
		var tmp2 = Math.floor(lat1 * 1e15);
	}
	var newLat = (tmp1 + tmp2) / 1e15;
	
	
	var lng1 = point1.Longitude;
	var lng2 = point2.Longitude;
	if (lng1 > lng2) {
		var tmp1 = Math.floor((lng1 - lng2) / 2 * 1e15)
		var tmp2 = Math.floor(lng2 * 1e15);
	}
	else {
		var tmp1 = Math.floor((lng2 - lng1) / 2 * 1e15);
		var tmp2 = Math.floor(lng1 * 1e15);
	}
	var newLng = (tmp1 + tmp2) / 1e15;
	
	var newLevel = gPoints[index].Level;
	
  	var newPoint = {
    	Latitude	: newLat,
    	Longitude	: newLng,
    	Level		: newLevel,
    	Elevation	: point1.Elevation,
    	Datetime	: point1.Datetime
  	};
	
	gPoints[index+1] = newPoint;
	
  	var point_marker = createPointMarker(new GLatLng(newLat, newLng), false);
  	document.map.addOverlay(point_marker);
  	gPoint_markers.push(point_marker);
	
	for (var i = gPoint_markers.length - 1; index < i; --i) {
		gPoint_markers[i] = gPoint_markers[i-1];
	}
	gPoint_markers[index + 1] = point_marker;
	
	createEncodings(false);
	
    highlight(findMarkerIndex(point_marker));
	
	checkGLargeMapControl();
	CalcDistance();
}


//---------------------------------------------------------
//  Confirmation of loading gpx file
//---------------------------------------------------------
function confirmLoadGpx(){
	
	var status = confirm("編集中のデータが失われます。よろしいですか？");
	
	if (status) {
		location.href="/maps/loadgpx/" + getRandomFileName() + 
			"/" + document.getElementById("ArticleForumId").value +
			"/" + document.getElementById("ArticleTopicId").value;
	}
}


//-------------------------------------------------
//  Load a XML file
//-------------------------------------------------
function loadGpx(fileName) {

	initializeAllData();
	
	document.map.clearOverlays();
	
	var wayPointIcon = new GIcon();
	wayPointIcon.image = "/Design/WayPointFlag.png";
	wayPointIcon.iconSize = new GSize(16,20);
	
	wayPointIcon.shadow = "/Design/WayPointFlag40x20_shadow.png";
	wayPointIcon.shadowSize = new GSize(40,20);
	wayPointIcon.iconAnchor = new GPoint(0,17);
	wayPointIcon.infoWindowAnchor = new GPoint(16,1);
	wayPointIcon.infoShadowAnchor = new GPoint(33,33);
	
	var lat,lng;
  
	GDownloadUrl(fileName, function(data, responseCode) {
		
		gOffsetTime = 0;
		
		var xml = GXml.parse(data);
  		
		var wptseg = xml.documentElement.getElementsByTagName("wpt");
		
		var names = xml.documentElement.getElementsByTagName("name");
		var cmts  = xml.documentElement.getElementsByTagName("cmt");
		var syms  = xml.documentElement.getElementsByTagName("sym");
		
		var pLevel = 3;
   		
		var name;
		var cmt;
		var sym;
		
		var lat;
		var lng;
		
		var jpegFileName;
		
		var stridx = 0;
		piecesStr = document.getElementById("ID_FromPHP_markers").value.split(",");
		
		if (wptseg.length < 1) {
			gOffsetTime = 0;
		}
		else {
			
			if (piecesStr[stridx + 3] == '' || piecesStr[stridx + 3] == 'undefined' || piecesStr[stridx + 3] == null) {
				gOffsetTime 	= 0;
			}
			else {
				gOffsetTime		= parseInt(piecesStr[stridx + 3],10);	// Offset time is a global, but each waypoint has a gOffsetTime. 
																		// So this operation has to do only one time.
			}
		}
  		
  		for (var i = 0; i < wptseg.length; i++) {
			
			lat  = parseFloat(wptseg[i].getAttribute("lat"));
			lng  = parseFloat(wptseg[i].getAttribute("lon"));
			
			
			if (names[i] != null)
				name = names[i].firstChild.nodeValue;
			else
				name = "-";
			
			if (syms[i] != null)
				sym  = gSymEtoJ[syms[i].firstChild.nodeValue];
			else
				sym = "-";
			
			if (cmts[i] != null)
				cmt = cmts[i].firstChild.nodeValue;
			else
				cmt = "-";
			
			jpegFileName 	= piecesStr[stridx + 0];
			exifDate		= piecesStr[stridx + 1];
			exifTime		= piecesStr[stridx + 2];
			
			addWayPoint(wayPointIcon,lat,lng,sym,name,cmt,jpegFileName,exifDate,exifTime);
			
			stridx += 4;			// jpegFileName,exifDate,exifTime,gOffsetTime
		}
 		
  		
  		var trkseg 		= xml.documentElement.getElementsByTagName("trkpt");
 		var dtseg		= xml.documentElement.getElementsByTagName("time");
		var	eleseg		= xml.documentElement.getElementsByTagName("ele");
		
  		if (trkseg[0] != null) {
			
			var point;
			
			var stp=1;
			if(trkseg.length > kMAXPOINTS) {
				stp = trkseg.length / (kMAXPOINTS - 1);
				alert("座標ポイント数が" + trkseg.length + "あります。" + kMAXPOINTS + "を超えています。表示まで数十秒かかる場合があります。");
			}
			
			
			lat = parseFloat(trkseg[Math.floor(0)].getAttribute("lat"));
			lng = parseFloat(trkseg[Math.floor(0)].getAttribute("lon"));
			
			prevLatlng = new GLatLng(lat,lng);
			
			gTraceHdl.maxDis1 = 0;
			gTraceHdl.maxDis2 = 0;
 			for (var i = 0; i < trkseg.length; i=i+stp) {
				lat = parseFloat(trkseg[Math.floor(i)].getAttribute("lat"));
				lng = parseFloat(trkseg[Math.floor(i)].getAttribute("lon"));
				curLatlng = new GLatLng(lat,lng);
				
				distance = prevLatlng.distanceFrom(curLatlng);
				prevLatlng = curLatlng;
				
				if (distance > gTraceHdl.maxDis1) {
					gTraceHdl.maxDis1 = distance;
				}
				else if (distance > gTraceHdl.maxDis2) {
					gTraceHdl.maxDis2 = distance;
				}
				
		//		if (distance < kMAXCaptureSpeed) {
					if (dtseg.length > 1 && i < dtseg.length) {						// If dtseg doesn't have the <date> tag, the process is not processed.
						datetime = dtseg[Math.floor(i)].firstChild.nodeValue;
					}
					else {
						datetime = null;
					}
					
					if (eleseg.length > 1 && i < eleseg.length) {
						ele = parseFloat(eleseg[Math.floor(i)].firstChild.nodeValue);
					}
					else {
						ele = null;
					}
					
		//			GLog.write(ele);
					
					createPointForXMLLoad(lat, lng, ele, pLevel, datetime);
				}
		//	}
			
  			createEncodings(false);
			
			lat = parseFloat(trkseg[0].getAttribute("lat"));
			lng = parseFloat(trkseg[0].getAttribute("lon"));
			
		}
		else if (wptseg[0] != null) {
			lat  = parseFloat(wptseg[0].getAttribute("lat"));
			lng  = parseFloat(wptseg[0].getAttribute("lon"));
		}
		
		disableDragWayPoints();
		optimizeZoomLevel();
		
		if (gPoints.length > 0) {
			if (!(gPoints[gPoints.length-1].Elevation == null || gPoints[gPoints.length-1].Elevation == 'undefined' || gPoints[gPoints.length-1].Elevation == '')) {
				
				var ardata = [];

				//
				// Adjust Date and Time
				//
				
				for (var i = 1; i < (gPoints.length - 1); ++i) {
					if (gPoints[i].Datetime == null) {
						if (gPoints[i-1].Datetime != null) {
							dtDefault = gPoints[i-1].Datetime;
							break;
						}
						else if (gPoints[i+1].Datetime != null) {
							dtDefault = gPoints[i+1].Datetime;
							break;
						}
					}
				};
				
				//
				// Adjust Elevation
				//
				eleAv	= 0;
				sum 	= 0;
				sumct 	= 0;
				
				for (var i = 0; i < gPoints.length; ++i) {
					if (gPoints[i].Elevation != 0) {
						sumct++;
						sum += gPoints[i].Elevation;
					}
				};
				
				eleAv = sum / sumct;
				
				//
				// Calculation of MIN/MAX and setting the adjusted data
				//
				if (gPoints[0].Elevation == 0) {
					gPoints[0].Elevation = eleAv;
					if (gPoints[0].Datetime == null) {
						gPoints[0].Datetime = dtDefault;
					}
				}
				
				min 	= gPoints[0].Elevation;
				max 	= gPoints[0].Elevation;
				preEle	= gPoints[0].Elevation;
				
				ardata.push([0,gPoints[0].Elevation]);
				
				for (var i = 1; i < gPoints.length; ++i) {
					if (gPoints[i].Elevation == 0) {
						gPoints[i].Elevation = eleAv;
						if (gPoints[i].Datetime == null) {
							gPoints[i].Datetime = dtDefault;
						}
					}
					
					ardata.push([i,gPoints[i].Elevation]);
					
		//			if ((gPoints[i].Elevation - preEle) > kMAXGapOfElevation)
		//				gPoints[i].Elevation = preEle;
					
					if (min > gPoints[i].Elevation)
						min = gPoints[i].Elevation;
						
					if (max < gPoints[i].Elevation)
						max = gPoints[i].Elevation;
						
					preEle = gPoints[i].Elevation;
				};
				
				var dataset = {
					'myFirstDataset': ardata
				};
				
				var n0 = 0;
				var n1 = Math.floor(gPoints.length / 4);
				var n2 = Math.floor(gPoints.length / 2);
				var n3 = Math.floor(gPoints.length / 4 * 3);
				var n4 = Math.floor(gPoints.length - 1);
				
				var t0 = CreateTime(gPoints[n0].Datetime);
				var t1 = CreateTime(gPoints[n1].Datetime);
				var t2 = CreateTime(gPoints[n2].Datetime);
				var t3 = CreateTime(gPoints[n3].Datetime);
				var t4 = CreateTime(gPoints[n4].Datetime);
				
				var options = {
					padding: {left: 45, right: 0, top: 5, bottom: 10},
					backgroundColor: '#dbdbdb',
					colorScheme: '#3EA247',
	   				xTicks: [
	   					{v:n0	, label:t0}, 
	    		  		{v:n1	, label:t1}, 
	    		  		{v:n2	, label:t2}, 
	    		  		{v:n3	, label:t3},
	    		  		{v:n4	, label:t4}
					],
					yAxis: [min,max]
				};
				
				//initialize a new LineChart with the options specified above
				var line = new Plotr.LineChart('plotr',options);
				//add the dataset
				line.addDataset(dataset);
				//render the linechart in the canvas element with ID 'plotr'
				line.render();
			}
			CalcDistance();
			GetWeather();
		}
	});
	
	
}


function CalcDistance() {
	stLatlng = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
	distance = 0;
	
 	for (var i = 1; i < gPoints.length; ++i) {
		
		curLatlng = new GLatLng(gPoints[i].Latitude,gPoints[i].Longitude);
		
		distance += curLatlng.distanceFrom(stLatlng);
		stLatlng = curLatlng;
	}
	
	document.getElementById('txtDistance').value = Math.ceil(distance);
}



function GetWeather() {
	if (document.getElementById("EDITMODE").value == 'EDIT') {
		return;
	}
	
	var fileName = "/location.xml";
	
	GDownloadUrl(fileName, function(data, responseCode) {
		var xml = GXml.parse(data);
  		
		var cityseg = xml.documentElement.getElementsByTagName("city");
		
  		for (var i = 0; i < cityseg.length; i++) {
			title  	= 	cityseg[i].getAttribute("title");
			id  	= 	cityseg[i].getAttribute("id");
			source  =	cityseg[i].getAttribute("source");
			lat		=	cityseg[i].getAttribute("lat");
			lng		=	cityseg[i].getAttribute("lng");
			
			var newWeather = {
				title	: title,
				id		: id,
				source	: source,
				lat		: lat,
				lng		: lng
			};
			
			gWeather.push(newWeather);
		}
		
		ptFrom 	= new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
		min		= 9999999;
		idx		= 0;
		
		for (i = 0; i < gWeather.length; ++i) { 
			tmpLoc	= new GLatLng(gWeather[i].lat,gWeather[i].lng);
			dt	 	= tmpLoc.distanceFrom(ptFrom);
			
			if (dt < min) {
				idx	= i;
				min = dt;
			}
		}
		
		
		areaText = gWeather[idx].title;
		
		fileURL = "/getWeatherForecast.php?source=/forecast/rss" + gWeather[idx].source;
	//	fileURL = "/sample.xml";
		
	//	GLog.write(fileURL);
		
		point = new GPoint(gWeather[idx].lat,gWeather[idx].lng);
		
		var request = GXmlHttp.create();

      	// use custom mirror since GXmlHttp can only get
      	// data from the same host.
      	// (there might be a better way...)
      	request.open("GET", fileURL, true);

      	request.onreadystatechange = function() {
       		if (request.readyState == 4) {
        		var rssitem = request.responseXML.getElementsByTagName("item");
        		
				idx = 0;
          		for (var i=0; i < rssitem.length; i++) {
            		var cat = rssitem[i].getElementsByTagName("category");
            		if (cat[0].childNodes[0].nodeValue == "PR") {
              			// skip ad
              			continue;
            		}

            		// get url of OTENKI icon
            		urlobj = rssitem[i].getElementsByTagName("url");
            		gURL[idx] = urlobj[0].childNodes[0].nodeValue;

            		titleobj = rssitem[i].getElementsByTagName("description");
            		gTitle[idx] = titleobj[0].childNodes[0].nodeValue;
					
   					++idx;
          		}
          		
            	linkobj = rssitem[1].getElementsByTagName("link");
            	areaLink = linkobj[0].childNodes[0].nodeValue;
				
				document.getElementById("area").innerHTML = '<a href="' + areaLink + '" target="_blank">' + areaText + '</a>';
				document.getElementById(0).src = gURL[0];
				document.getElementById(1).src = gURL[1];
				document.getElementById("today").innerHTML 		= gTitle[0];
				document.getElementById("tomorrow").innerHTML 	= gTitle[1];
	        }
        }
     	request.send(null);
		
		
	});

}
	





function CreateTime(tm) {
	pHourTmp  = "0" + (parseInt(tm.substr(11,2),10) + 9) % 24;
	pHour 	= pHourTmp.substr(pHourTmp.length-2,2);
	pMin  =  tm.substr(14,2),10;
	pSec  =  tm.substr(17,2),10;
	
	rtm	  = pHour + ":" + pMin + ":" + pSec;
	return rtm;
}



//-------------------------------------------------
//  Edit mode
//-------------------------------------------------
function TrackMode() {
	if (gMode == kEDITTRACK)
		return;
	
	if (checkOverlay_gPoints_area() > kMAXPOINTS_SCR) {
		setRadioButtonView();
		alert("表示されるマーカー数が多過ぎます。地図を拡大してください。");
		return;
	}
	
	enableTrackButtons();
	setRadioButtonTrack();
	
	gMode = kEDITTRACK;
	
	deleteOverlay_gPoints_area();
	addOverlay_gPoints_area();
	
	checkGLargeMapControl();
	disableDragWayPoints();
//	enableDragWayPoints();
	
//	clearMarkerInput();
//	recoverMarker();
	
	document.map.closeInfoWindow();
}


//-------------------------------------------------
//  Marker mode
//-------------------------------------------------
function MarkerMode() {
	if (gMode == kEDITMARKER)
		return;
	
	enableMarkerButtons();
	setRadioButtonMarker();
	
	gMode = kEDITMARKER;
	
	deleteOverlay_gPoints_area();
//	addOverlay_gPoints_area();
	
	checkGLargeMapControl();
	enableDragWayPoints();
	
	clearMarkerInput();
	recoverMarker();
	
	document.map.closeInfoWindow();
}


//-------------------------------------------------
//  View mode
//-------------------------------------------------
function ViewMode() {
	disableButtons();
	
	//
	// KEN
	//
  	if (gMarkerPointer) {
  	  document.map.removeOverlay(gMarkerPointer);
  	  gMarkerPointer = null;
	}

	
	if (gMode == kVIEW)
		return;
	
	gMode = kVIEW;
	
	setRadioButtonView();
	
	document.map.enableInfoWindow();
	deleteOverlay_gPoints_area();
	
	checkGLargeMapControl();
	disableDragWayPoints();
	
	clearMarkerInput();
	recoverMarker();
}


// Returns the index of the gMarkerPointer in the polyline.
function findMarkerIndex(point_marker) {
  var index = -1;

  for (var  i = 0; i < gPoint_markers.length; ++i) {
    if (gPoint_markers[i] == point_marker) {
      index = i;
      break;
    }
  }

  return index;
}

// Creates a point and adds it to both the polyline and the list.
function createPointForXMLLoad(lat, lng, ele, pLevel, datetime) {
  var newPoint = {
    Latitude	: lat,
    Longitude	: lng,
    Elevation	: ele,
    Level		: pLevel,
    Datetime	: datetime
  };

  gPoints.push(newPoint);

  var point_marker = createPointMarker(new GLatLng(lat, lng), false);
  gPoint_markers.push(point_marker);
}


function createPoint(lat, lng, pLevel) {
  var newPoint = {
    Latitude: lat,
    Longitude: lng,
    Elevation: 0,
    Level: pLevel
  };

  gPoints.push(newPoint);

  if (gMarkerPointer) {
    document.map.removeOverlay(gMarkerPointer);
    gMarkerPointer = null;
  }

  var point_marker = createPointMarker(new GLatLng(lat, lng), false);
  document.map.addOverlay(point_marker);
  gPoint_markers.push(point_marker);
  
}


// Creates a gMarkerPointer representing a point in the polyline.
function createPointMarker(point, highlighted) {
	var clr = highlighted ? "red" : "blue";

	var point_marker = createMarker(point, clr);
	point_marker.enableDragging();

	GEvent.addListener(point_marker, "drag", function() {
		
		if (gMode != kEDITTRACK)
			return;
		
  		if (gMarkerPointer) {
			document.map.removeOverlay(gMarkerPointer);
  			gMarkerPointer = null;
  		}
		
    	var idx = findMarkerIndex(point_marker);
    	
 		var nLat = point_marker.getPoint().lat();
		var nLng = point_marker.getPoint().lng();
	
		var pLevel 		= gPoints[idx].Level;
		var pDatetime 	= gPoints[idx].Datetime;
		var pEle		= gPoints[idx].Elevation;
		
		var modifiedPoint = {
			Latitude	: nLat,
	        Longitude	: nLng,
	        Elevation	: pEle,
	        Level		: pLevel,
	        Datetime	: pDatetime
		};
	
		gPoints[idx] = modifiedPoint;
	        
		document.getElementById('txtLatitude').value 	= nLat.toString();
		document.getElementById('txtLongitude').value 	= nLng.toString();
	    
	  });

	GEvent.addListener(point_marker, "dragend", function() {
		var index = findMarkerIndex(point_marker);

      	var nLat = point_marker.getPoint().lat();
      	var nLng = point_marker.getPoint().lng();
		
		var pLevel 		= gPoints[index].Level;
		var pDatetime 	= gPoints[index].Datetime;
		var pEle		= gPoints[index].Elevation;
      	
      	var modifiedPoint = {
      		Latitude	: nLat,
      		Longitude	: nLng,
	        Elevation	: pEle,
        	Level		: pLevel,
	        Datetime	: pDatetime
     	};
		
		gPoints[index] = modifiedPoint;
		createEncodings(false);
		
		CalcDistance();
	});


	GEvent.addListener(point_marker, "click", function() {
		clearMarkerInput();
		
  		if (gMarkerPointer) {
  		  document.map.removeOverlay(gMarkerPointer);
  		  gMarkerPointer = null;
  		}
		
		var idx = findMarkerIndex(point_marker)
	    highlight(idx);
		
		if (gPoints[idx].Datetime == 'undefined' || gPoints[idx].Datetime == null || gPoints[idx].Datetime == '') {
			dtStr = '';
		}
		else {
			dtStr = gPoints[idx].Datetime;
		}
		
	    document.getElementById('txtLatitude').value 	= point_marker.getPoint().lat().toString();
	    document.getElementById('txtLongitude').value 	= point_marker.getPoint().lng().toString();
	    document.getElementById('txtDatetime').value 	= dtStr;
    	
    	recoverMarker();
	    
  	});
  	
  	return point_marker;
}


// Highlights the point specified by index in both the map and the point list.
function highlight(index) {
	
	gHilighed_index = index;

	if (gPoint_markers[index] != null
    	  && gPoint_markers[index] != gHighlighted_marker) {
    	document.map.removeOverlay(gPoint_markers[index]);
  	}

  	if (gHighlighted_marker != null) {
    	var oldIndex = findMarkerIndex(gHighlighted_marker);
    	document.map.removeOverlay(gHighlighted_marker);
	
    	if (oldIndex != index) {
    		gPoint_markers[oldIndex]
        		= createPointMarker(gHighlighted_marker.getPoint(), false);
      	document.map.addOverlay(gPoint_markers[oldIndex]);
    	}
  	}

  	gHighlighted_marker = createPointMarker(gPoint_markers[index].getPoint(),
                                         true);
  	gPoint_markers[index] = gHighlighted_marker;
  	document.map.addOverlay(gHighlighted_marker);
}

//-------------------------------------------------
// Encode a signed number in the encode format.
//-------------------------------------------------
function encodeSignedNumber(num) {
  var sgn_num = num << 1;

  if (num < 0) {
    sgn_num = ~(sgn_num);
  }

  return(encodeNumber(sgn_num));
}

//-------------------------------------------------
// Encode an unsigned number in the encode format.
//-------------------------------------------------
function encodeNumber(num) {
  var encodeString = "";

  while (num >= 0x20) {
    encodeString += (String.fromCharCode((0x20 | (num & 0x1f)) + 63));
    num >>= 5;
  }

  encodeString += (String.fromCharCode(num + 63));
  return encodeString;
}


//-------------------------------------------------
//  Initialize all data
//-------------------------------------------------
function initializeAllData() {
		deleteAllMarkers();
		deleteAllWayPoints();
		gPoints = [];
		gPoint_markers = [];
		gWayPoints_markers = [];
		gMarkerPointer = null;
		gMode = 0;
		
		gWeather 	= [];

      	gTraceHdl = {
      		timer	: null,
      		idx		: 0
     	};
		
		createEncodings();
		
		clearMarkerInput();
}

//-------------------------------------------------
//  Delete all data
//-------------------------------------------------
function deleteAllgPoints() {
	var deleteConfirm = confirm("編集中のデータが失われます。よろしいですか？");
	
	if (deleteConfirm) {
		initializeAllData();
		return true;
  	}
  	else {
		return false;
	}
}

//-------------------------------------------------
// Deletes all the markers for the points in the polyline
//-------------------------------------------------
function deleteAllMarkers() {
  for(var i = 0; i < gPoint_markers.length; ++i) {
    document.map.removeOverlay(gPoint_markers[i]);
  }

  gPoint_markers = [];
  gHighlighted_marker = null;
}

//-------------------------------------------------
// Delete a point from the polyline.
//-------------------------------------------------
function deletePoint() {
	if (gPoints.length > 0) {
		var point_index = gHilighed_index;

		if (point_index >= 0 && point_index < gPoints.length) {
			gPoints.splice(point_index, 1);

			if (gHighlighted_marker == gPoint_markers[point_index]) {
				gHighlighted_marker = null;
			}
	
			document.getElementById('txtLatitude').value 	= gPoint_markers[point_index].getPoint().lat().toString()
    		document.getElementById('txtLongitude').value 	= gPoint_markers[point_index].getPoint().lng().toString();
		
			
			
			document.map.removeOverlay(gPoint_markers[point_index]);
			gPoint_markers.splice(point_index, 1);
			createEncodings();
		}

		if (gPoints.length > 0) {
			if (point_index == 0) {
				point_index++;
			}

			highlight(point_index - 1);
		}

		checkGLargeMapControl();
		CalcDistance();
	}
}

//-------------------------------------------------
// Try to encode an unsigned number. Used by the documentation.
//-------------------------------------------------
function tryEncode() {
  var txtValue = document.getElementById('txtNumber').value;
  if (parseInt(txtValue,10).toString() == txtValue) {
    document.getElementById('cdeValue').innerHTML
      = encodeNumber(parseInt(txtValue,10));
  }else{
    document.getElementById('cdeValue').innerHTML = '(None)';
  }
}

//-------------------------------------------------
// Try to encode a signed number. Used by the documentation.
//-------------------------------------------------
function trySignEncode() {
  var txtValue = document.getElementById('txtSignNumber').value;
  if (parseInt(txtValue,10).toString() == txtValue) {
    document.getElementById('cdeSignValue').innerHTML
      = encodeSignedNumber(parseInt(txtValue,10));
  }else{
    document.getElementById('cdeSignValue').innerHTML = '(None)';
  }
}

//-------------------------------------------------
// Create the encoded polyline and level strings. If moveMap is true
// move the map to the location of the first point in the polyline.
//-------------------------------------------------
function createEncodings(moveMap) {
  var i = 0;

  var plat = 0;
  var plng = 0;

  var encoded_points = "";
  var encoded_levels = "";


    var lastGlatlng1 = null;
    var lastGlatlng2 = null;
    var lastGlatlng3 = null;
    var lastGlatlng4 = null;
    var lastGlatlng5 = null;
    var lastGlatlng6 = null;
    var lastGlatlng7 = null;
    var lastGlatlng8 = null;
    var lastGlatlng9 = null;
    var lastGlatlng10 = null;
    var lastGlatlng11 = null;
    var lastGlatlng12 = null;
    var lastGlatlng13 = null;
    var lastGlatlng14 = null;
    var lastGlatlng15 = null;
    var lastGlatlng16 = null;
    var lastGlatlng17 = null;
    if( 0 < gPoints.length ){
        lastGlatlng1 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng2 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng3 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng4 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng5 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng6 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng7 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng8 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng9 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng10 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng11 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng12 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng13 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng14 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng15 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng16 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
        lastGlatlng17 = new GLatLng(gPoints[0].Latitude,gPoints[0].Longitude);
    }
    
    
    levelCount 	= 0;
    
  	for(i = 0; i < gPoints.length; ++i) {
		var lat 		=  parseFloat(gPoints[i].Latitude);
    	var lng 		=  parseFloat(gPoints[i].Longitude);
		
 		var level = 0;
    	
    	if( i == 0 || i == gPoints.length - 1 ){
    	    level = 8;
    	}else{
			var glatlng = new GLatLng(lat,lng);
			
    	    var distance1 = glatlng.distanceFrom(lastGlatlng1);
    	    if( distance1 > 50){ // meters
    	        level = 1;
    	        lastGlatlng1 = glatlng;
    	    }
			
	        var distance2 = glatlng.distanceFrom(lastGlatlng2);
	        if( distance2 > 200){ // meters
	            level = 2;
	            lastGlatlng2 = glatlng;
	        }
			
	        var distance3 = glatlng.distanceFrom(lastGlatlng3);
	        if( distance3 > 600){ // meters
	            level = 3;
	            lastGlatlng3 = glatlng;
	        }
	  		
	        var distance6 = glatlng.distanceFrom(lastGlatlng6);
	        if( distance6 > 1000) { // meters
	            level = 6;
	            lastGlatlng6 = glatlng;
	        }
	    }
	    
	    if (level != 0) {
			levelCount++;
		}
		
		if (levelCount > 0 && level == 0) {
			levelCount = 0;
		}
		
	    if (levelCount > 1) {			// Inserting the data of level 8 when the data of level 0 is continued.
			levelCount = 0;
			level = 8;
		}
	    
		
	  	var late5 = Math.floor(lat * 1e5);
	    var lnge5 = Math.floor(lng * 1e5);
	
	    dlat = late5 - plat;
	    dlng = lnge5 - plng;
	
	    plat = late5;
	    plng = lnge5;
	
	    encoded_points += encodeSignedNumber(dlat) + encodeSignedNumber(dlng);
	    encoded_levels += encodeNumber(level);
  	}
	
	
	// GLog.write(encoded_levels);
	
	
  	if (document.overlay) {
  		document.map.removeOverlay(document.overlay);
  	}
	
  	if (gPoints.length > 1) {
    	document.overlay = new GPolyline.fromEncoded({color: "#FF0000",
                                              weight: 5,
											  opacity: 0.8,
                                              points: encoded_points,
                                              levels: encoded_levels,
                                              zoomFactor:4,
                                              numLevels: 9
                                             });
	
  	document.map.addOverlay(document.overlay);
  }
}


//-------------------------------------------------
// Decode an encoded polyline into a list of lat/lng tuples.
//-------------------------------------------------
function decodeLine (encoded) {
  var len = encoded.length;
  var index = 0;
  var array = [];
  var lat = 0;
  var lng = 0;

  while (index < len) {
    var b;
    var shift = 0;
    var result = 0;
    do {
      b = encoded.charCodeAt(index++) - 63;
      result |= (b & 0x1f) << shift;
      shift += 5;
    } while (b >= 0x20);
    var dlat = ((result & 1) ? ~(result >> 1) : (result >> 1));
    lat += dlat;

    shift = 0;
    result = 0;
    do {
      b = encoded.charCodeAt(index++) - 63;
      result |= (b & 0x1f) << shift;
      shift += 5;
    } while (b >= 0x20);
    var dlng = ((result & 1) ? ~(result >> 1) : (result >> 1));
    lng += dlng;

    array.push([lat * 1e-5, lng * 1e-5]);
  }

  return array;
}

//-------------------------------------------------
// Decode an encoded levels string into a list of levels.
//-------------------------------------------------
function decodeLevels(encoded) {
  var levels = [];

  for (var pointIndex = 0; pointIndex < encoded.length; ++pointIndex) {
    var pointLevel = encoded.charCodeAt(pointIndex) - 63;
    levels.push(pointLevel);
  }

  return levels;
}

//-------------------------------------------------
// Decode the supplied encoded polyline and levels.
//-------------------------------------------------
function decode() {
  var encoded_points = document.getElementById('encodedPolyline').value;
  var encoded_levels = document.getElementById('encodedLevels').value;

  if (encoded_points.length==0 || encoded_levels.length==0) {
    return;
  }

  var enc_points = decodeLine(encoded_points);
  var enc_levels = decodeLevels(encoded_levels);

  if (enc_points.length==0 || enc_levels.length==0) {
    return;
  }

  if (enc_points.length != enc_levels.length) {
    alert('Point count and level count do not match');
    return;
  }

  deleteAllMarkers();
  gPoints = [];

  for (var i = 0; i < enc_points.length; ++i) {
    createPoint(enc_points[i][0], enc_points[i][1], enc_levels[i]);
  }

  createEncodings(true);
}

//-------------------------------------------------
// Create marker
//-------------------------------------------------
function createMarker(point, color) {
  var myIcon = new GIcon();
  myIcon.image = "/Design/marker16x20_" + color + ".png";
  myIcon.shadow = "/Design/marker16x20_shadow.png";
  myIcon.iconSize = new GSize(16,20);
  myIcon.shadowSize = new GSize(40,20);
  myIcon.iconAnchor = new GPoint(8,17);
  myIcon.infoWindowAnchor = new GPoint(8,1);
  myIcon.infoShadowAnchor = new GPoint(17,17);

  newMarker = new GMarker(point,{icon: myIcon, draggable: true, title: '(' + point.lat() + "," + point.lng() + ")"});

  return newMarker;
}


//-------------------------------------------------
//  Create the map
//-------------------------------------------------
function createMap() {
	
	if (!GBrowserIsCompatible()) {
		alert('ブラウザがGoogle Maps APIに対応していません');
		return;
	}
	
	initializeAllData();
	
	document.map = new GMap2(document.getElementById("map"));
	gHdlGLargeMapControl = new GLargeMapControl();
	document.map.setCenter(new GLatLng(36.22731176684055, 138.10750007629395), 13);
	document.map.addControl(new GMapTypeControl());
	document.map.addControl(new GScaleControl());
	new GKeyboardHandler(document.map);
	
	addEventMapClick();
	addEventMapDragend();
	addEventMapZoomend();
	
	setRadioButtonView();
	setRadioButtonRemove();
	document.getElementsByName("RadioButtonWayOfAttaching")[2].disabled = true;
	
	createWaypointSymbols();
	createWaypointIcon();
	
	if (loadGpxAfterSetFileName()) {
		disableButtons();
		setRadioButtonView();
		
		gMode = kVIEW;
	}
	else {
		enableTrackButtons();				// Track mode
		setRadioButtonTrack();
		
//		enableDragWayPoints();
		
		gMode = kEDITTRACK;
	}
	
	checkGLargeMapControl();
	
	gGeoCoder = new GClientGeocoder();
	
}


//-------------------------------------------------
//  Zoom level optimization
//-------------------------------------------------
function optimizeZoomLevel()
{
	var latMin = 180.0;
	var lngMin = 180.0;
	var latMax = -180.0;
	var lngMax = -180.0;
	
	for (var i = 0; i < gPoints.length; i++) {
		if (gPoints[i].Latitude < latMin)
			latMin = gPoints[i].Latitude;
			
		if (gPoints[i].Latitude > latMax)
			latMax = gPoints[i].Latitude;
		
		if (gPoints[i].Longitude < lngMin)
			lngMin = gPoints[i].Longitude;
			
		if (gPoints[i].Longitude > lngMax)
			lngMax = gPoints[i].Longitude;
	}
	
	for (var i = 0; i < gWayPoints_markers.length; i++) {
		if (gWayPoints_markers[i].getPoint().lat() < latMin)
			latMin = gWayPoints_markers[i].getPoint().lat();
			
		if (gWayPoints_markers[i].getPoint().lat() > latMax)
			latMax = gWayPoints_markers[i].getPoint().lat();
		
		if (gWayPoints_markers[i].getPoint().lng() < lngMin)
			lngMin = gWayPoints_markers[i].getPoint().lng();
			
		if (gWayPoints_markers[i].getPoint().lng() > lngMax)
			lngMax = gWayPoints_markers[i].getPoint().lng();
	}

	var northEastLatLng = new GLatLng(latMin,lngMin);
	var southWestLatLng = new GLatLng(latMax,lngMax);
	
	var latLngBounds = new GLatLngBounds(northEastLatLng,southWestLatLng);
	
	var mapCenter = new GLatLng((northEastLatLng.lat() + southWestLatLng.lat()) / 2.0,(northEastLatLng.lng() + southWestLatLng.lng()) / 2.0);
	var zoomLevel	= document.map.getBoundsZoomLevel(latLngBounds);
	document.map.setCenter(mapCenter,zoomLevel);
}


//-------------------------------------------------
//  Set file name and Load GPX file
//-------------------------------------------------
function loadGpxAfterSetFileName()
{
	var fileName = document.getElementById("ID_FromToPHP_gpxFileName");
	
	if (fileName.value.length > 0) {
		loadGpx(fileName.value);
		return true;
	}
	else {
		return false;
	}
}


//-------------------------------------------------
//  Add event of map click
//-------------------------------------------------
function addEventMapClick() {
	GEvent.addListener(document.map, "click", function(overlay, point) {
	
	if (gMode == kVIEW)
		return;
	
	if (point == null)
		return;
	
    document.getElementById('txtLatitude').value = point.y;
    document.getElementById('txtLongitude').value = point.x;
    document.getElementById('txtDatetime').value = '';

    if (gMarkerPointer == null) {
      gMarkerPointer = createMarker(point, "purple");
      gMarkerPointer.enableDragging();
		
		
      GEvent.addListener(gMarkerPointer, "drag", function() {
        document.getElementById('txtLatitude').value = gMarkerPointer.getPoint().y;
        document.getElementById('txtLongitude').value = gMarkerPointer.getPoint().x;
      });

      document.map.addOverlay(gMarkerPointer);
    } else {
      gMarkerPointer.setPoint(point);
    }
    
    recoverMarker();
	setRadioButtonRemove();
	document.getElementsByName("RadioButtonWayOfAttaching")[2].disabled = true;
	
  });
}