/////////////////////////////////////
//  GPXvGMAP
//  Dernière mise à jour : 2008/02/08
/////////////////////////////////////

var gMap;                               // Carte   

var gTrajetPolyline = null;             // Polyline du trajet au complet
var gEventListenerHandle = null;        // Listener du clique de la souris dans gTrajetPolyline
var gArrayElevations = new Array();     // Tableau des élévations pour chaque point du trajet

var gArrayMarqueurs = new Array(2);     // Tableau contenant les 2 marqueurs de sélection
var gMarqueurElevation = null;          // Marqueur d'élévation maximale (le carré vert)
var gIndexMarqueurSelection;            // Marqueur sélectionné (0 ou 1)
var gIndexMarqueur0;                    // Index du marqueur de début dans le tableau gTrajetPolyline
var gIndexMarqueur1;                    // Index du marqueur de fin dans le tableau gTrajetPolyline

var gPenteMinimale = 0.02;              // Pente requise pour afficher le gTrajetPolyline coloré entre les 2 marqueurs
var gPentePolyline = null;              // Polyline de la portion de trajet sélectionnée

var gMarqueursVisibles = true;

// Info sur la portion de trajet sélectionnée

var gObjTrajet = new Object();

gObjTrajet["elevationMin"] = 999999999;	 
gObjTrajet["elevationMax"] = -999999999;
gObjTrajet["distance"] = 0;
gObjTrajet["AscensionTotale"] = 0;
gObjTrajet["DescenteTotale"] = 0;            
gObjTrajet["nombreDePoints"] = 0;
gObjTrajet["pente"] = 0;
            
var EXTENDED_MAP=
    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.';

function ObtenirValeurFormulaireHtml(id)
{
    if(document.getElementById(id)!=null) 
        return document.getElementById(id).value; 
    else 
        return null;
}

// extendedEncoding
// Encode la valeur val dans le format "Extended encoding"

function extendedEncoding(val) 
{
    var numericVal = new Number(val);
    if(isNaN(numericVal)) {
        alert("Non-numeric value submitted : " + val);
        return "";
    } 
    else if (numericVal < 0 || numericVal > EXTENDED_MAP.length * EXTENDED_MAP.length - 1) 
    {
        alert("Value outside permitted range");
        return "";
    }
    var quotient = Math.floor(numericVal / EXTENDED_MAP.length);
    var remainder = numericVal - EXTENDED_MAP.length * quotient
    return EXTENDED_MAP.charAt(quotient) + EXTENDED_MAP.charAt(remainder);
}

// scaling
// Retourne un tableau contenant les valeurs d'élévation ajustées

function scaling(values) 
{
    var min = Math.floor(gObjTrajet["elevationMin"]/10)*10;
    var max = Math.ceil(gObjTrajet["elevationMax"]/10)*10;
    var ymin=0;
    var ymax=4095;
    var arraylength = values.length;
    var newvalues = new Array();
    for (var i=0; i<=arraylength;i++)
    {
        var v = values[i];
        var y=Math.round((((ymin-ymax)/(max-min))*(max-v))+ymax);
        newvalues.push(y);
    }
    return newvalues;
}

// chargerGMap
// Appelé une seule fois dans le onload de la page

function chargerGMap()
{
	initalisationDeGPXvGMAP();    
	
	if(document.getElementById("map")!=null)
	{
        creerObjetGMap();        
	    afficherTrajet();
	    centrerLaCarte();
	}
}

// initalisationDeGPXvGMAP
// Initialisation des paramètres de base

function initalisationDeGPXvGMAP() 
{
	window.onresize = AjusterGMapEnFonctionDeLaFenetre;
	AjusterGMapEnFonctionDeLaFenetre();
	
	gIndexMarqueur0 = document.getElementById("indexM0").value;
	if (gIndexMarqueur0 < 0 || gIndexMarqueur0 > gArrayElevations.length-1)
	{
	    gIndexMarqueur0 = 0;
	}
	    
	gIndexMarqueur1 = document.getElementById("indexM1").value;
	if (gIndexMarqueur1 <= 0 || gIndexMarqueur1 > gArrayElevations.length-1)
	{
	    gIndexMarqueur1 =  (gArrayElevations.length==0 ? 0 : (gArrayElevations.length-1));
	}
    
    if(document.getElementById("indexM0")!=null)
    {
        document.getElementById("indexM0").value = gIndexMarqueur0;
    }
    
    if(document.getElementById("indexM1")!=null)
    {
        document.getElementById("indexM1").value = gIndexMarqueur1;
    }
    
    gIndexMarqueurSelection = 1;
}

// creerObjetGMap
// Création de l'objet GMAP

function creerObjetGMap()
{
	gMap = new GMap2(document.getElementById("map"), {draggableCursor: 'crosshair', draggingCursor: 'pointer'});	
	
	gMap.addControl(new GSmallMapControl());
	gMap.addControl(new GHierarchicalMapTypeControl());  
	
	gMap.addMapType(G_PHYSICAL_MAP);
   
    GEvent.addListener(gMap, "zoomend", function(oldlevel,newlevel) 
    {
        if(document.getElementById("zoomlevel")!=null)
        {
            document.getElementById("zoomlevel").value = newlevel;
        }
    }); 
    
    centrerLaCarte();
}

// centrerLaCarte
// centre la carte sur le premier point du trajet

function centrerLaCarte()
{
	var defaultZoomLevel = obtenirNiveauDeZoom();
    
    if(contientUnTrajet())
	{
        var pointCentral = gArrayMarqueurs[0] ? gArrayMarqueurs[0].getLatLng() : gTrajetPolyline.getVertex(0);
        
	    var clat = parseFloat(lireValeur('clat', location.search.substring(1, location.search.length)));
	    var clng = parseFloat(lireValeur('clng', location.search.substring(1, location.search.length)));
	                
        if(isNaN(clat) || isNaN(clng))
        {
            gMap.setCenter(pointCentral , defaultZoomLevel);
        }
        else
        {
            gMap.setCenter(new GLatLng(clat,clng) , defaultZoomLevel);
        }
	                   
        var mt = lireValeur('mt', location.search.substring(1, location.search.length));
        
        if( mt == "p")
        {
            gMap.setMapType(G_PHYSICAL_MAP);
        }
        else if( mt == "s")
        {
            gMap.setMapType(G_SATELLITE_MAP);
        }
        else if( mt == "h")
        {
            gMap.setMapType(G_HYBRID_MAP);
        }
	}
    else
    {
        var defaultLat = 45.410807;
        var defaultLon = -73.171971;
        
    	gMap.setCenter(new GLatLng(defaultLat,defaultLon), defaultZoomLevel);
    }
}

// afficherTrajet
// Affiche le trajet s'il y a lieu et information sur le trajet

function afficherTrajet()
{
	if(contientUnTrajet())
	{
		gMap.addOverlay(gTrajetPolyline);
			
        afficherMarqueurs();
	    calculerInformationEntreLesMarqueurs();
        afficherFlecheElevationMaximale();
    	afficherPolylinePente();

        document.getElementById('imgElevation').style.display = 'block';
        AfficherPageElevation();
	}
}

// afficherMarqueurs
// Affiche les 2 marqueurs sur le trajet

function afficherMarqueurs()
{
    if(gMarqueursVisibles)
    {
        afficherMarqueurSurLeTrajet(0,gIndexMarqueur0);
        afficherMarqueurSurLeTrajet(1,gIndexMarqueur1);
        
        // La ligne devient cliquable si on a des marqueurs
        if(gTrajetPolyline!=null)
        {    
            gEventListenerHandle = GEvent.addListener(gTrajetPolyline, "click", function(p) 
            {
                deplacerMarqueurSurLeTrajet(p);
            });
        }
	}
    else
    {
        effacerMarqueurDuTrajet(0);
        effacerMarqueurDuTrajet(1);
        
        if(gTrajetPolyline!=null && gEventListenerHandle!=null)
        {    
            GEvent.removeListener(gEventListenerHandle);
        }
    }
}

// obtenirNiveauDeZoom
// retourne le niveau de zoom courant

function obtenirNiveauDeZoom()
{
    if (document.getElementById("zoomlevel")!=null)
    {
        return parseInt(document.getElementById("zoomlevel").value);
    }    
    else
    {
        return 12;
    }
}

// distanceEntreLesDeuxMarqueurs
// retourne la distance en mètres entre les 2 marqueurs

function distanceEntreLesDeuxMarqueurs(i0,i1)
{
    var dsp = 0;	 
    
    if(contientUnTrajet())
    {
        for(i=Math.min(i0,i1); i<Math.max(i0,i1); i++)
        {
           dsp += gTrajetPolyline.getVertex(i).distanceFrom(gTrajetPolyline.getVertex(i+1)); 
        }
    }  
    
    return dsp;
}

// penteEntreLesDeuxMarqueurs
// retourne la pente en % entre les 2 marqueurs

function penteEntreLesDeuxMarqueurs()
{
    var dsp = distanceEntreLesDeuxMarqueurs(gIndexMarqueur0,gIndexMarqueur1);
    return dsp!=0 ? ((gArrayElevations[gIndexMarqueur1] - gArrayElevations[gIndexMarqueur0]) / dsp) : 0;
}

// calculerInformationEntreLesMarqueurs
// Affiche du label d'info sur la portion de trajet sélectionnée

function calculerInformationEntreLesMarqueurs()
{
    if (contientUnTrajet() && document.getElementById("lbPente") && gMarqueursVisibles)
    {              
        document.getElementById("lbPente").style.visibility="visible";
        
        gObjTrajet["distance"] = distanceEntreLesDeuxMarqueurs(gIndexMarqueur0,gIndexMarqueur1);
        
        if(gObjTrajet["distance"]!=0)
        {
            gObjTrajet["elevationMin"] = 999999999;	 
            gObjTrajet["elevationMax"] = -999999999;
            
            gObjTrajet["AscensionTotale"] = 0;
            gObjTrajet["DescenteTotale"] = 0;
            
            gObjTrajet["nombreDePoints"] = Math.abs((gIndexMarqueur1-gIndexMarqueur0+1));
            
            for(i=Math.min(gIndexMarqueur0,gIndexMarqueur1); i<=Math.max(gIndexMarqueur0,gIndexMarqueur1); i++)
            {
                if(gArrayElevations[i] > gObjTrajet["elevationMax"])
                {
                    gObjTrajet["elevationMax"] = gArrayElevations[i];
                }
                if(gArrayElevations[i] < gObjTrajet["elevationMin"])
                {
                    gObjTrajet["elevationMin"] = gArrayElevations[i];    
                }
                if(i>Math.min(gIndexMarqueur0,gIndexMarqueur1))
                {
                    if(gArrayElevations[i] > gArrayElevations[i-1])
                    {
                        if(gIndexMarqueur0<=gIndexMarqueur1)
                            gObjTrajet["AscensionTotale"]+=gArrayElevations[i]-gArrayElevations[i-1];
                        else
                            gObjTrajet["DescenteTotale"]+=gArrayElevations[i-1]-gArrayElevations[i];
                    }
                    else if (gArrayElevations[i] < gArrayElevations[i-1])
                    {
                        if(gIndexMarqueur0<=gIndexMarqueur1)
                            gObjTrajet["DescenteTotale"]+=gArrayElevations[i-1]-gArrayElevations[i];
                        else
                            gObjTrajet["AscensionTotale"]+=gArrayElevations[i]-gArrayElevations[i-1];
                    }
                }
            }
            
            gObjTrajet["AscensionTotale"] = Math.abs(gObjTrajet["AscensionTotale"]);
            gObjTrajet["DescenteTotale"] = Math.abs(gObjTrajet["DescenteTotale"]);
            
            gObjTrajet["pente"] = penteEntreLesDeuxMarqueurs();
            
           
            document.getElementById("lbPente").innerHTML = 
                '[' + 
                '<b>Dist :</b> ' + (gObjTrajet["distance"]/1000).toFixed(2).toString() + 'km ' +
                '<b>Pts :</b> ' + gObjTrajet["nombreDePoints"] + ' ' +
                '<b>Pent :</b> <font color="' + couleurDeLaPenteEntreLesDeuxMarqueurs(gObjTrajet["pente"]) + '">' + gObjTrajet["pente"].toFixed(2).toString() + '%</font> ' + 
                '<b>EMin :</b> ' + gObjTrajet["elevationMin"].toFixed(2).toString() + 'm ' +
                '<b>EMax :</b> ' + gObjTrajet["elevationMax"].toFixed(2).toString() + 'm ' +
                '<b>Asce :</b> ' + gObjTrajet["AscensionTotale"].toFixed(2).toString() + 'm ' +
                '<b>Desc :</b> ' + gObjTrajet["DescenteTotale"].toFixed(2).toString() + 'm' + 
                ']';
        }
    }
    else
    {
        document.getElementById("lbPente").style.visibility="hidden";
    }
}

// afficherPolylinePente
// affiche un gTrajetPolyline entre les 2 marqueurs si la pente est plus grand ou plus petit que gPenteMinimale

function afficherPolylinePente()
{
    if(contientUnTrajet())
	{
	    if(gPentePolyline!=null)
	    {
	        gMap.removeOverlay(gPentePolyline);
	        gPentePolyline=null;
	    }
        
        if(gMarqueursVisibles)
        {
	        var arrayGLatLng = new Array();
 
            for(i=Math.min(gIndexMarqueur0,gIndexMarqueur1); i<=Math.max(gIndexMarqueur0,gIndexMarqueur1); i++)
            {
                arrayGLatLng.push(gTrajetPolyline.getVertex(i));
            }
            
            gPentePolyline = new GPolyline(arrayGLatLng, couleurDeLaPenteEntreLesDeuxMarqueurs(gObjTrajet["pente"]), 10);
            gMap.addOverlay(gPentePolyline);	
            
            GEvent.addListener(gPentePolyline, "click", function(p) 
            {
                deplacerMarqueurSurLeTrajet(p);
            });
        }
	}
}

// afficherFlecheElevationMaximale
// dessine la flèche pointant sur le point le plus elevé entre les 2 marqueurs

function afficherFlecheElevationMaximale()
{
    if(contientUnTrajet())
    {
        var elevMax = 0;
        var index = -1;
    
        if(gMarqueurElevation!=null)
        {
            gMap.removeOverlay(gMarqueurElevation);
            gMarqueurElevation = null;
        }

        if(gMarqueursVisibles)
        {
            for(i=Math.min(gIndexMarqueur0,gIndexMarqueur1); i<=Math.max(gIndexMarqueur0,gIndexMarqueur1); i++)
            {
                if(gArrayElevations[i] > elevMax)
                {
                    elevMax = gArrayElevations[i];
                    index = i;
                }
            }
    	   
		    pm =gTrajetPolyline.getVertex(index);
    		
            var baseIcon = new GIcon();

            baseIcon.shadow = "images/markerE.png";
            baseIcon.iconSize = new GSize(5, 5);
            baseIcon.shadowSize = new GSize(5, 5);
            baseIcon.iconAnchor = new GPoint(5, 5);
            baseIcon.infoWindowAnchor = new GPoint(5, 5);
            baseIcon.infoShadowAnchor = new GPoint(5, 5);
           
            var letteredIcon = new GIcon(baseIcon);
            letteredIcon.image = "images/markerE.png";

            markerOptions = { icon:letteredIcon,draggable:false };    
      
		    gMarqueurElevation = new GMarker(pm, markerOptions);
		    GEvent.addListener(gMarqueurElevation, "click", function() {
                gMarqueurElevation.openInfoWindowHtml('<p class="TEXTEINFOMARKER"><img src="images/markerE.png">&nbsp;Lat=' + pm.lat() + ' Lon=' + pm.lng() + '<br>' + 
		        'Ele=' + gArrayElevations[index].toFixed(2) + 'm Point : ' + index + '</p>');
            });
     
		    gMap.addOverlay(gMarqueurElevation);
		}
     }
}

// deplacerMarqueurSurLeTrajet
// déplace le marqueur après un drag de l'usager sur le point du trajet le plus rapproché

function deplacerMarqueurSurLeTrajet(p)
{
    var gll = new GLatLng(p.y,  p.x,  true);
    var d = 9999999;
    var df = 0;
    var nouvelIndex = 0;
            
    for(i=0; i<gTrajetPolyline.getVertexCount(); i++)
    {
        df = gll.distanceFrom(gTrajetPolyline.getVertex(i));
        if(df < d)
        {
            d = df;
            nouvelIndex = i;
        }
    }
    
    afficherMarqueurSurLeTrajet(gIndexMarqueurSelection, nouvelIndex);   
    
    if(gIndexMarqueurSelection==0) 
    { 
        gIndexMarqueur0 = nouvelIndex;
        document.getElementById("indexM0").value = gIndexMarqueur0;
    
    } 
    else
    { 
        gIndexMarqueur1 = nouvelIndex;
        document.getElementById("indexM1").value = gIndexMarqueur1;
    }
    
	calculerInformationEntreLesMarqueurs();
	afficherFlecheElevationMaximale();
	afficherPolylinePente();

	AfficherPageElevation();
}

// creerUnMarqueur
// création d'un marqueur

function creerUnMarqueur(point, name, index) 
{
    var baseIcon = new GIcon();

    baseIcon.shadow = "images/shadow50.png";
    baseIcon.iconSize = new GSize(20, 34);
    baseIcon.shadowSize = new GSize(37, 34);
    baseIcon.iconAnchor = new GPoint(9, 34);
    baseIcon.infoWindowAnchor = new GPoint(9, 2);
    baseIcon.infoShadowAnchor = new GPoint(18, 25);
   
    var letteredIcon = new GIcon(baseIcon);
    letteredIcon.image = "images/marker" + (index+1) + ".png";

    markerOptions = { icon:letteredIcon,draggable:true };
    var marker = new GMarker(point, markerOptions);
 
    marker.title = index;
  
    GEvent.addListener(marker, "dragstart", function() {
          gIndexMarqueurSelection = marker.title;
          gMap.closeInfoWindow();
    });

    GEvent.addListener(marker, "dragend", function() {
          gIndexMarqueurSelection = marker.title;
          deplacerMarqueurSurLeTrajet(marker.getPoint());
    });
        
    GEvent.addListener(marker, "click", function() {
        gIndexMarqueurSelection = marker.title;
        marker.openInfoWindowHtml(name);
    });
 
    return marker;
}

// effacerMarqueurDuTrajet
// enlève le marqueur du trajet

function effacerMarqueurDuTrajet(i)
{
    if(gArrayMarqueurs[i]!=null)
    {
        gMap.removeOverlay(gArrayMarqueurs[i]);
        gArrayMarqueurs[i] = null;
    }
}

// afficherMarqueurSurLeTrajet
// Affiche le marqueur sur le trajet

function afficherMarqueurSurLeTrajet(theMarker,theIndex)
{
	if(contientUnTrajet() && gMarqueursVisibles)
	{   
	    effacerMarqueurDuTrajet(theMarker);
		pm =gTrajetPolyline.getVertex(theIndex);
		gArrayMarqueurs[theMarker] = creerUnMarqueur(pm,'<p class="TEXTEINFOMARKER">P' + (theMarker+1) + ':&nbsp;Lat=' + pm.lat() + ' Lon=' + pm.lng() + '<br>' + 
		    'Ele=' + gArrayElevations[theIndex].toFixed(2) + 'm Point : ' + theIndex + '</p>', theMarker);
		gMap.addOverlay(gArrayMarqueurs[theMarker]);
	}
}

// couleurDeLaPenteEntreLesDeuxMarqueurs
// retourne la couleur du gTrajetPolyline de la portion de trajet entre les 2 marqueurs

function couleurDeLaPenteEntreLesDeuxMarqueurs(pente)
{
    if(pente > gPenteMinimale)
        return '#ff0000';
    else if (pente <= -(gPenteMinimale)) 
        return '#4E9C46';
    else
        return '#FD933E';
}

// AjusterGMapEnFonctionDeLaFenetre
// Ajuste la grosseur de la carte en fonction de la grosseur de la fenêtre

function AjusterGMapEnFonctionDeLaFenetre()
{
	var myWidth = 0, myHeight = 0;
	
	if( typeof( window.innerWidth ) == 'number' ) 
	{
		//Non-IE
		myWidth = window.innerWidth;
		myHeight = window.innerHeight;
	} else if( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) 
	{
		//IE 6+ in 'standards compliant mode'
		myWidth = document.documentElement.clientWidth;
		myHeight = document.documentElement.clientHeight;
	} else if( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) 
	{
		//IE 4 compatible
		myWidth = document.body.clientWidth;
		myHeight = document.body.clientHeight;
	}

	redimensionnerLaCarte(myWidth-240,myHeight-28);
	
	return true;
}

// redimensionnerLaCarte
// redimensionne la carte dans la page html

function redimensionnerLaCarte(w,h)
{
    if(document.getElementById("map")!=null)
    {   
	    document.getElementById("map").width=w;
	    document.getElementById("map").height=h;
	}
    document.getElementById("mapCell").width=w;
	document.getElementById("mapCell").height=h;

	document.getElementById("googleads").height=h;
}

// AfficherCacherInformationDuTrajet
// Affiche ou cache l'information sur le trajet

function AfficherCacherInformationDuTrajet()
{
    if(document.getElementById('msg').style.display == 'none')
    {
         document.getElementById('msg').style.display = 'block';
    }
    else
    {
         document.getElementById('msg').style.display = 'none';
    }
}

// AfficherPageElevation
// Génére l'url pour ouvrir le graphe avec l'api de Google Charts

function AfficherPageElevation()
{
    if(document.getElementById('imgElevation').style.display == 'block')
    {   
        var qs = "";    
        var nbrDePts = gObjTrajet["nombreDePoints"];
        
        var skipXNombres = 1;
        if(gObjTrajet["nombreDePoints"]>941)
        {
            skipXNombres = parseInt(Math.ceil(gObjTrajet["nombreDePoints"]/940).toString());
            nbrDePts = gObjTrajet["nombreDePoints"] / Math.ceil(gObjTrajet["nombreDePoints"]/940).toFixed(0);
        }
        
        var valeursElevations = scaling(gArrayElevations);       
        var j = 0;
        var x = 0;
        
        if(gIndexMarqueur0<=gIndexMarqueur1)
            for (var i=gIndexMarqueur0;i<=gIndexMarqueur1;i = parseInt(i) + parseInt(skipXNombres))
            {
                if(i>=gIndexMarqueur0 && i<=gIndexMarqueur1)
                {
                    qs+=extendedEncoding(valeursElevations[i].toFixed(0));
                    if(gArrayElevations[i].toFixed(0)==gObjTrajet["elevationMax"].toFixed(0))
                    {
                        x = j;
                    }
                }
                
                j=j+1;
            }
        else
        {
            for (var i=gIndexMarqueur0;i>=gIndexMarqueur1;i=parseInt(i) - parseInt(skipXNombres))
            {
                if(i>=gIndexMarqueur1 && i<=gIndexMarqueur0)
                {
                    qs+=extendedEncoding(valeursElevations[i].toFixed(0));
                    if(gArrayElevations[i].toFixed(0)==gObjTrajet["elevationMax"].toFixed(0))
                    {
                        x = j;
                    }
                }
                
                j=j+1;
            }
         }
           
            
        // Affiche 10 points sur la ligne d'élévation 
        var interval = -(nbrDePts/10).toFixed(0);
        
        var url = 'http://chart.apis.google.com/chart' + 
            '?chs=500x200' +
            '&cht=lc' + 
            '&chm=o,0066FF,0,' + interval + ',6|v,747474,0,' + x + ',1.0|' + 's,1EFF00,0,' + x + ',5.0' +
            '&chf=c,lg,0,76A4FB,1,FFFFFF,0|bg,s,EFEFEF' +
            '&chd=e:' + qs +
            '&chxt=x,y' + 
            '&chxl=0:|0|' + ((gObjTrajet["distance"]/1000)/2).toFixed(2) + '|' + (gObjTrajet["distance"]/1000).toFixed(2).toString() + '|1:|' + (gObjTrajet["elevationMin"]*0.9).toFixed(0) + '|'+ (gObjTrajet["elevationMin"]+(gObjTrajet["elevationMax"]-gObjTrajet["elevationMin"])/2).toFixed(0) + '|' + (gObjTrajet["elevationMax"]*1.10).toFixed(0);
       
        
        document.getElementById('imgElevation').src = url;
    }
}

// TogglePageElevation
// Affiche ou cache l'image du profil d'élévation

function TogglePageElevation()
{
    if(document.getElementById('imgElevation').style.display == 'none' && contientUnTrajet())
    {   
          document.getElementById('imgElevation').style.display = 'block';
          AfficherPageElevation();
    }
    else
    {
         document.getElementById('imgElevation').style.display = 'none';
    }
}

// contientUnTrajet
// retourne vrai si on a une carte et un trajet

function contientUnTrajet()
{
    return(gMap!=null && gTrajetPolyline!=null);
}

// contientUnTrajet
// retourne vrai si on a des marqueurs

function contientDesMarqueurs()
{
    return(marker[0]!=null && marker[1]!=null);
}

// LireValeur
// Retourne la valeur du paramètre "nom" parmi la liste des paramètres de la QS

function lireValeur(nom,liste)
{
	var tableau=liste.split('&');
	for (var i=0;i<tableau.length;i++)
	{
		var pair = tableau[i].split('=');
				
		if(pair[0] == nom)
		{
			return pair[1];
		}
	}
	
	return null;
}

// GenererUrl
// Recharge la page selon l'état actuel avec les bons paramètres dans la QS

function GenererUrl ()
{  
    var mt = gMap.getCurrentMapType();
    var mtqs = "";
    
    if(mt==G_SATELLITE_MAP)
        mtqs = "&mt=s";
    else if (mt==G_HYBRID_MAP)
        mtqs = "&mt=h";
    else if (mt==G_PHYSICAL_MAP)
        mtqs = "&mt=p";
    
    var url = 
        location.protocol + "//" + location.host + location.pathname + 
        '?r=' + lireValeur('r', location.search.substring(1, location.search.length)) + 
        '&p1=' + document.getElementById("indexM0").value + 
        '&p2=' + document.getElementById("indexM1").value + 
        '&zl=' + document.getElementById("zoomlevel").value + 
        '&clat=' + gMap.getCenter().lat() + 
        '&clng=' + gMap.getCenter().lng() +
        mtqs;
    
    window.location = url;
}

function ToggleMarqueurs()
{
    gMarqueursVisibles = !gMarqueursVisibles;
    afficherTrajet();
}