function load(HLat,HLng,ELat,ELng) {
      if (GBrowserIsCompatible()) {
		  	//create icons
		var icon = new GIcon();
		var icon2 = new GIcon();
	//exchange icon	
   icon2.image = "http://maps.google.com/mapfiles/kml/pal3/icon21.png"; 
   icon2.shadow = "http://maps.google.com/mapfiles/kml/pal3/icon21s.png";
   icon2.iconSize=new GSize(32,32);
   icon2.shadowSize=new GSize(56,32);
   icon2.iconAnchor=new GPoint(16,32);
   icon2.infoWindowAnchor=new GPoint(16,0);		
	//home icon	
   icon.image = "http://maps.google.com/mapfiles/kml/pal2/icon10.png";
   icon.shadow = "http://maps.google.com/mapfiles/kml/pal2/icon10s.png";
   icon.iconSize=new GSize(32,32);
   icon.shadowSize=new GSize(56,32);
   icon.iconAnchor=new GPoint(16,32);
   icon.infoWindowAnchor=new GPoint(16,0);
		  
		  
		var Home = new GLatLng(HLat,HLng);
        var Exchange = new GLatLng(ELat,ELng);
        var map = new GMap2(document.getElementById("map"));
		map.addControl(new GSmallMapControl());
		map.addControl(new GMapTypeControl());
        map.setCenter(Home, 14);
		//add route line
		var polyline = new GPolyline([new GLatLng(HLat, HLng), new GLatLng(ELat, ELng)], "#369999", 6);
        map.addOverlay(polyline);
		
		
		var Hmarker = new GMarker(Home,icon);
		var Emarker = new GMarker(Exchange,icon2);
		//map.addOverlay(new GMarker(points,icon));
		//function createMarker(point, number)
		 //{
		   //var marker = new GMarker(points);
		   GEvent.addListener(Hmarker, "click", function() {    Hmarker.openInfoWindowHtml("Postcode Location");  });
		   GEvent.addListener(Emarker, "click", function() {    Emarker.openInfoWindowHtml("Exchange");  });
		   //return marker;
		 //}
		 var points = Home;
		 map.addOverlay(Hmarker);
		//map.addOverlay(createMarker(points,1));
		points = Exchange;
		map.addOverlay(Emarker);
		//map.addOverlay(createMarker(points,1));
		
	
		
		//var polyline = new GPolyline([Exchange,Home], "#FF0000", 3);
		//map.addOverlay(polyline);
		
		
		//map.openInfoWindow(map.getCenter(),                   
		//document.createTextNode("Hello, world"));
		window.setTimeout(function() {  map.panTo(new GLatLng(ELat,ELng));}, 3000);
		window.setTimeout(function() {  map.panTo(new GLatLng(HLat,HLng));}, 4000);
      }
    }
/*==============================================================================

This routine checks the value of the string variable specified by the parameter
for a valid UK telphone number. It returns false for an invalid number and the
reformatted telephone number false a valid number.

If false is returned, the global variable telNumberError contains an error
number, which may be used to index into the array of error descriptions 
contained in the global array telNumberErrors.

The definition of a valid telephone number has been taken from:
http://www.ofcom.org.uk/telecoms/ioi/numbers/100806.pdf

All inappropriate telephone numbers are disallowed (e.g. premium lines, sex 
lines, radio-paging services etc.)

Author:    John Gardner
Date:      16th November 2003

Updated:   4th August 2006       Updated to include 03 numbers being added by
                                 Ofcom in early 2007.
Version:   V1.2  9th January 2007
           Isle of Man mobile numbers catered for 

Example calling sequnce:

  if (!checkUKTelephone (myTelNo)) {
     alert (telNumberErrors[telNumberErrorNo]);
  }

------------------------------------------------------------------------------*/

function checkUKTelephone (telephoneNumber) {

  // Convert into a string and check that we were provided with something
  var telnum = telephoneNumber + " ";
  if (telnum.length == 1)  {
     telNumberErrorNo = 1;
     return false
  }
  telnum.length = telnum.length - 1;
  
  // Don't allow country codes to be included (assumes a leading "+")
  var exp = /^(\+)[\s]*(.*)$/;
  if (exp.test(telnum) == true) {
     telNumberErrorNo = 2;
     return false;
  }
  
  // Remove spaces from the telephone number to help validation
  while (telnum.indexOf(" ")!= -1)  {
    telnum = telnum.slice (0,telnum.indexOf(" ")) + telnum.slice (telnum.indexOf(" ")+1)
  }
  
  // Remove hyphens from the telephone number to help validation
  while (telnum.indexOf("-")!= -1)  {
    telnum = telnum.slice (0,telnum.indexOf("-")) + telnum.slice (telnum.indexOf("-")+1)
  }  
  
  // Now check that all the characters are digits
  exp = /^[0-9]{10,11}$/
  if (exp.test(telnum) != true) {
     telNumberErrorNo = 3;
     return false;
  }
  
  // Now check that the first digit is 0
  exp = /^0[0-9]{9,10}$/
  if (exp.test(telnum) != true) {
     telNumberErrorNo = 4;
     return false;
  }
  
  // Finally check that the telephone number is appropriate.
  exp = /^(01|02|03|05|070|077|07624|078|079)[0-9]+$/;
  if (exp.test(telnum) != true) {
     telNumberErrorNo = 5;
     return false;
  }
  
  // Telephone number seems to be valid - return the stripped telehone number  
  return telnum;
}
var telNumberErrorNo = 0;
var telNumberErrors = new Array ();
telNumberErrors[0] = "Valid UK telephone number";
telNumberErrors[1] = "Telephone number not provided";
telNumberErrors[2] = "UK telephone number without the country code, please";
telNumberErrors[3] = "UK telephone numbers should contain 10 or 11 digits";
telNumberErrors[4] = "The telephone number should start with a 0";
telNumberErrors[5] = "The telephone number is either invalid or inappropriate";

//end telephone check

//postcode validate
/*==============================================================================

Application:   Utiity Function
Author:        John Gardner

Version:       V1.0
Date:          18th November 2003
Description:   Used to check the validity of a UK postcode

Version:       V2.0
Date:          8th March 2005
Description:   BFPO postcodes implemented.
               The rules concerning which alphabetic characters are alllowed in 
               which part of the postcode were more stringently implementd.
  
Parameters:    toCheck - postcodeto be checked. 

This function checks the value of the parameter for a valid postcode format. The 
space between the inward part and the outward part is optional, although is 
inserted if not there as it is part of the official postcode.

If the postcode is found to be in a valid format, the function returns the 
postcode properly formatted (in capitals with the outward code and the inward
code separated by a space. If the postcode is deemed to be incorrect a value of 
false is returned.
  
Example call:
  
  if (checkPostCode (myPostCode)) {
    alert ("Postcode has a valid format")
  } 
  else {alert ("Postcode has invalid format")};
                    
------------------------------------------------------------------------------*/

function checkPostCode (toCheck) {

  // Permitted letters depend upon their position in the postcode.
  var alpha1 = "[abcdefghijklmnoprstuwyz]";                       // Character 1
  var alpha2 = "[abcdefghklmnopqrstuvwxy]";                       // Character 2
  var alpha3 = "[abcdefghjkstuw]";                                // Character 3
  var alpha4 = "[abehmnprvwxy]";                                  // Character 4
  var alpha5 = "[abdefghjlnpqrstuwxyz]";                          // Character 5
  

  // Array holds the regular expressions for the valid postcodes
  var pcexp = new Array ();

  // Expression for postcodes: AN NAA, ANN NAA, AAN NAA, and AANN NAA
  pcexp.push (new RegExp ("^(" + alpha1 + "{1}" + alpha2 + "?[0-9]{1,2})(\\s*)([0-9]{1}" + alpha5 + "{2})$","i"));
  
  // Expression for postcodes: ANA NAA
  pcexp.push (new RegExp ("^(" + alpha1 + "{1}[0-9]{1}" + alpha3 + "{1})(\\s*)([0-9]{1}" + alpha5 + "{2})$","i"));

  // Expression for postcodes: AANA  NAA
  pcexp.push (new RegExp ("^(" + alpha1 + "{1}" + alpha2 + "?[0-9]{1}" + alpha4 +"{1})(\\s*)([0-9]{1}" + alpha5 + "{2})$","i"));
  
  // Exception for the special postcode GIR 0AA
  pcexp.push (/^(GIR)(\s*)(0AA)$/i);
  
  // Standard BFPO numbers
  pcexp.push (/^(bfpo)(\s*)([0-9]{1,4})$/i);
  
  // c/o BFPO numbers
  pcexp.push (/^(bfpo)(\s*)(c\/o\s*[0-9]{1,3})$/i);

  // Load up the string to check
  var postCode = toCheck;

  // Assume we're not going to find a valid postcode
  var valid = false;
  
  // Check the string against the types of post codes
  for ( var i=0; i<pcexp.length; i++) {
    if (pcexp[i].test(postCode)) {
    
      // The post code is valid - split the post code into component parts
      pcexp[i].exec(postCode);
      
      // Copy it back into the original string, converting it to uppercase and
      // inserting a space between the inward and outward codes
      postCode = RegExp.$1.toUpperCase() + " " + RegExp.$3.toUpperCase();
      
      // If it is a BFPO c/o type postcode, tidy up the "c/o" part
      postCode = postCode.replace (/C\/O\s*/,"c/o ");
      
      // Load new postcode back into the form element
      valid = true;
      
      // Remember that we have found that the code is valid and break from loop
      break;
    }
  }
  
  // Return with either the reformatted valid postcode or the original invalid 
  // postcode
  if (valid) {return postCode;} else return false;
}
//end postcode validate

function validate() {
  if(!document.getElementById) return;
  var post = document.getElementById("post").value;
  var phone = document.getElementById("phone").value; 
  
  var incorrect = new Array();
  var no = 0;
  var errtext = "";

if (!(phone=="")&&!(phone==null))
{
  var resultPhone = checkUKTelephone (phone)
  //if number is invalid
  if (!resultPhone) {
    incorrect[no] = "1";
	errtext = errtext + " Please Enter a Full UK telephone number <br>";
	alert (telNumberErrors[telNumberErrorNo]);
    no++;
  } 
  else
  {
	  //replace formatted number
	  document.getElementById("phone").value = resultPhone;
  }
}

var resultPost = checkPostCode (post)
//post code is invalid
  if (!resultPost) {
    incorrect[no] = "2";
	errtext = errtext + " Please Enter a Full UK Postcode <br>";
	alert ("Plese enter a Valid UK postcode");
    no++;
  }
   else
  {
	  //replace formatted code
	  document.getElementById("post").value = resultPost;
  }


   
   for(i=1;i<3;i++) {
  		document.getElementById(i).style.color="#FFFFFF";
  }

  for(j=0;j<no;j++) {
  		document.getElementById(incorrect[j]).style.color="#FF0000";
  }
  
   if(no == 0) { 
 return true;
 }

  if(no > 0) {
   	document.getElementById("errors").innerHTML = "" + errtext +"</span>";
return false;
 }

  document.getElementById("post").value = post;
 // document.getElementById("phone").value = phone;
}