// Procédures globales du projet
function AfficheInformation(sTexte, nLatitude, nLongitude, bHTML)
{
	
	if (!gObjCarte)
	return ;
	
	var objCoordonnees;
	// Si la longitude et la latitude sont renseignées, on crée une coordonnée avec ces données
	if (nLatitude && nLongitude)
	{
		objCoordonnees = new GLatLng(nLatitude, nLongitude)
		}else{
		// si la latitude et la longitude ne sont pas renseignées, on prend le centre de la carte
		objCoordonnees = gObjCarte.getCenter();
		}
	
	if (bHTML)
	gObjCarte.openInfoWindowHtml(objCoordonnees,sTexte);
	else
	// On affiche une information aux coordonnées demandée
	gObjCarte.openInfoWindow(objCoordonnees,document.createTextNode(sTexte));
	
}

function AfficheMarqueur(nLatitude, nLongitude, bDragAndDropAutorise)
{
	
	if (!gObjCarte)
	return ;
	
	var objCoordonnees;
	var objMarqueur;
	
	// Si la longitude et la latitude sont renseignées, on crée une coordonnée avec ces données
	if (nLatitude && nLongitude)
	{
		objCoordonnees = new GLatLng(nLatitude, nLongitude)
		}else{
		// si la latitude et la longitude ne sont pas renseignées, on prend le centre de la carte
		objCoordonnees = gObjCarte.getCenter();
		}
	
	if (bDragAndDropAutorise == null)
	bDragAndDropAutorise = true;
	
	// Création du marqueur, par défaut on dit qu'il est déplaçable,
	// Si on ne spécifie pas cette option, elle ne pourra pas être activée après coup
	objMarqueur = new GMarker(objCoordonnees, {draggable:true});
	
	// Si le Drag And Drop est autorisé, on le spécifie au marqueur
	if (bDragAndDropAutorise)
	objMarqueur.enableDragging();
	else
	objMarqueur.disableDragging();
	
	// Affiche l'objet marqueur
	gObjCarte.addOverlay(objMarqueur);
	
	// On renvoie l'objet marqueur
	return objMarqueur;	
}
function AjouteControles(bControleTypeCarte, bControleZoom, bControleEchelle, bMiniatureCarte, bControleCartePetit, bControleCarteGrand)
{
	
	if (!gObjCarte)
	return ;
	
	// pour tous les controles passés, on vérifie si on doit l'ajouter
	
	// Contrôle de type de carte (Plan, Satellite, Mixe)
	if (bControleTypeCarte)
	{
		
		if (!gnControleTypeCarte)
		{	
			
			gnControleTypeCarte = new GMapTypeControl();
			// Ajoute le controle
			gObjCarte.addControl(gnControleTypeCarte);
			
			// Ajoute le controle Relief
			gObjCarte.addMapType(G_PHYSICAL_MAP); 
			}
		}else{
		
		if (gnControleTypeCarte)
		{
			gObjCarte.removeControl(gnControleTypeCarte);
			gnControleTypeCarte = null;
			}
		
		}
	// Contrôle de type Zoom, (+ et - en haut à gauche de la carte)
	if (bControleZoom)
	{	
		if (!gnControleZoom)
		{	
			gnControleZoom = new GSmallZoomControl();
			gObjCarte.addControl(gnControleZoom);
			}
		}else{
		if (gnControleZoom)
		{
			gObjCarte.removeControl(gnControleZoom);
			gnControleZoom = null;
			}
		}
	
	// Contrôle qui donne l'échelle de la carte
	if (bControleEchelle)
	{
		if (!gnControleEchelle)
		{	
			gnControleEchelle = new GScaleControl();
			gObjCarte.addControl(gnControleEchelle);
			}
		}else{
		if (gnControleEchelle)
		{
			gObjCarte.removeControl(gnControleEchelle);
			gnControleEchelle = null;
			}
		
		}
	
	// Contrôle qui affiche la miniature de la carte en bas à droite
	if (bMiniatureCarte)
	{
		if (!gnMiniatureCarte)
		{	
			gnMiniatureCarte = new GOverviewMapControl();
			gObjCarte.addControl(gnMiniatureCarte);
			}
		}else{
		if (gnMiniatureCarte)
		{
			gObjCarte.removeControl(gnMiniatureCarte);
			gnMiniatureCarte = null;
			}
		
		}
	
	// Contrôle de la carte en petit (déplacement, zoom) en haut à gauche
	if (bControleCartePetit)
	{
		if (!gnControleCartePetit)
		{	
			gnControleCartePetit = new GSmallMapControl();
			gObjCarte.addControl(gnControleCartePetit);
			}
		}else{
		if (gnControleCartePetit)
		{
			gObjCarte.removeControl(gnControleCartePetit);
			gnControleCartePetit = null;
			}
		}
	
	// Contrôle de la carte en grand (déplacement, zoom, et potentiomètre pour le zoom) en haut à gauche 
	if (bControleCarteGrand)
	{
		
		if (!gnControleCarteGrand)
		{	
			gnControleCarteGrand = new GLargeMapControl();
			gObjCarte.addControl(gnControleCarteGrand);
			}
		}else{
		if (gnControleCarteGrand)
		{
			gObjCarte.removeControl(gnControleCarteGrand);
			gnControleCarteGrand = null;
			}
		}
}

function AjouteGestionClavier()
{
	if (!gObjCarte)
	return null;
	
	// Ajoute l'évenement qui gère les touches clavier sur la carte
	gnEvenementClavier = new GKeyboardHandler(gObjCarte);
	return gnEvenementClavier;
}

function CentreCarte(nLatitude, nLongitude, nZoom)
{
	if (!gObjCarte)
	return ;
	
	// Si le zoom n'est pas spécifié, on le met à la valeur actuelle
	if (!nZoom)
	nZoom = gObjCarte.getZoom();
	
	// Bouge la carte pour positionner le centre aux coordonnées données
	gObjCarte.setCenter(new GLatLng(nLatitude, nLongitude), nZoom);
	
}
function CreeCarte(sNomChampCarte)
{
	//	 Création de la carte
	gObjCarte = new GMap2(document.getElementById(sNomChampCarte));
	return;	
}

function EvenementClic(sNomFonction)
{
	
	if (!gObjCarte)
	return null;
	
	
	if (gnEvenementClic)
	return gnEvenementClic;
	
	
	var objFunction;
	// On a récupéré le nom de la fonction sous forme de chaîne, donc on récupère le pointeur sur cette fonction
	objFunction = eval(sNomFonction);
	
	// sauvegarde de l'évenement Clic (si on veut le supprimer)
	gnEvenementClic = GEvent.addListener(gObjCarte,"click", objFunction);
	
	// Ajoute l'évenement click
	return gnEvenementClic;
}

function EvenementSurvol(sNomFonction)
{
	
	if (!gObjCarte)
	return null;
	
	
	if (gnEvenementSurvol)
	return gnEvenementSurvol;
	
	// On a récupéré le nom de la fonction sous forme de chaîne, il faut récupérer le pointeur de la fonction
	var objFunction = eval(sNomFonction);
	
	// sauvegarde de l'évenement si on veut le supprimer
	gnEvenementSurvol = GEvent.addListener(gObjCarte,"mousemove", objFunction);
	// ensuite on ajoute l'évenement sur le mousemove
	return gnEvenementSurvol;
}

function ModifieZoom(nZoom)
{
	
	if (!gObjCarte)
	return ;
	
	// Si le zoom n'est pas défini, on sort
	if (!nZoom)
	return false;
	
	// Le zoom doit être une valeur entre 0 et 17
	nZoom = Math.max(nZoom, 0);
	nZoom = Math.min(nZoom,17);
	
	// Modifie le zoom de la carte
	gObjCarte.setZoom(nZoom);
	
}
function PointVersLatitude(objPoint)
{
	
	// Si le point passé est invalide, on renvoie -1
	if (!objPoint)
	return -1;
	
	// Sinon, on renvoie la position y qui correspond à la latitude (y parce qu'on par de l'équateur et qu'on va vers les pôles donc verticalement)
	return objPoint.y;
	
}
function PointVersLongitude(objPoint)
{
	// Si le point passé est invalide, on renvoie -1
	if (!objPoint)
	return -1;
	
	// Sinon, on renvoie la position x qui correspond à la longitude
	return objPoint.x;
	
}
function RechercheCoordonneesDepuisAdresse(sAdresse, sNomFonction)
{
	
	// On a récupéré le nom de la fonction sous forme de chaîne, donc on récupère maintenant le pointeur sur cette fonction
	var objFonction = eval(sNomFonction);
	
	// Création de l'objet GeoCoder
	var ObjGeocoder = new GClientGeocoder();
	
	// Demande de récupération des coordonnées à partir de l'adresse 
	// => cette procédure est asynchrone, c'est à dire qu'elle va exécuter la procédure passée en paramètre lorsqu'elle aura terminée
	ObjGeocoder.getLatLng(sAdresse, objFonction);
	
}
function SupprimeEvenementClic()
{
	if (gnEvenementClic)
	{
		GEvent.removeListener(gnEvenementClic);
		gnEvenementClic = null;
		}
}
function SupprimeEvenementSurvol()
{
	if (gnEvenementSurvol)
	GEvent.removeListener(gnEvenementSurvol);
	gnEvenementSurvol = null;
}
function SupprimeMarqueur(objMarker)
{
	if (!gObjCarte)
	return ;
	
	// Si le marqueur est spécifié, on supprime celui spécifié
	if (objMarker)
	{
		gObjCarte.removeOverlay(objMarker);
		}else{
		// Sinon, on les supprime tous
		gObjCarte.clearOverlays();
		}
	
}

function ZoomAvecRoulette(bZoomAvecRoulette)
{
	
	if (!gObjCarte)
	return ;
	
	// Si on doit activer le zoom sur la roulette de la souris
	if (bZoomAvecRoulette)
	{
		gObjCarte.enableScrollWheelZoom();
		}else{
		// Sinon on le désactive
		gObjCarte.disableScrollWheelZoom();
		}
}