/* ******************************************************************************************************
*																										*
*	Pseudo-Classe CarteGoogle (Constructeur pour utiliser l'API Google).								*
*	Développeur : Stephane Chapdelaine pour Trinôme inc.												*
*	Date : 18 Juin 2008	- 27 Juin 2008																	*
*	Version : Beta 1																					*
*																										*
*********************************************************************************************************
*																										*
*	Paramètres :																						*
*		idConteneur:String, le ID de l'element html qui contiendra la carte Google.						*
*		strHost:String, le site sur lequel la carte est chargée (votre site).							*
*		strDossierImages:String, le dossier dans lequel se trouve les images pour les marqueurs.		*
*	Retourne : Un instance de cette pseudo-classe														*
*	Exemple : oGoogle = new CarteGoogle("map","http://www.destenouest.local/","googleapi/images/");		*
*	Packer URL : http://dean.edwards.name/packer/														*
********************************************************************************************************/

function CarteGoogle(idConteneur,strHost,strDossierImages) {

	this.conteneur = document.getElementById(idConteneur); // Contient l'élément dans lequel l'API est chargé
	this.carte; // Obj GMap2, Contient la mappe
	this.clientGeocoder; // Objet GClientGeocoder pour afficher une zone par un nom de ville
	this.latitude; // Float, Contient la coordonnée de la latitude
	this.longitude; // Float, Contient la coordonnée de la longitude
	this.zoom; // Integer, Contient le niveau du zoom de la carte
	this.host = strHost; // String, Contient le nom du site web.
	this.dossierImages = strDossierImages; // String, Le répertoire dans lequel les icônes se trouvent
	this.listeIcones = new Array(); // Array, Contient des objets avec les propriétés des icônes
	this.listeMarqueurs = new Array(); // Array, Liste des marqueurs permanente
	this.listeTempMarqueurs = new Array(); // Array, Liste temporaire pour l'ajout des groupes de marqueurs
	this.groupesMarqueurs = new Array(); // Array, Liste pour les groupes de marqueurs, contient les objets GMarker générés
	this.gestionnaireMarqueurs; // Objet MarkerManager, Gestion des marqueurs selon le niveau de zoom
	this.coordonneeClick; // Pourra contenir la coordonnée cliquée lorsqu'on aura activé le listenner du click pour la map par la fonction EcouteCoordonnee()
	this.coordGeoCoder; // Contiendra la coordonnée de la ville recherchée par CadreVille()
	this.trajet = new Array(); // Objet GPolyline, Contient la trajectoire
	this.punaise; // Objet GMarker pour la punaise que l'utilisateur peut mettre dans la carte (fonction UtilisateurPunaise)
	this.frontiere = new GLatLngBounds(); // Objet GLatLngBounds pour pouvoir cadrer selon le contenu dans la carte
	
	/* 
	### FONCTION AjusteFrontiere :
		Utilisé à l'interne dans la création de marqueur et de trajectoires
		Génère un rectangle qui contient les frontières pour que les marqueurs et trajectoires soient cadrées le mieux possible
	### PARAMÈTRES :
		glatlng:GLatLng du marqueur ou point de la trajectoire
	*/
	this.AjusteFrontiere = function(glatlng) {
		this.frontiere.extend(glatlng);
	}
	/* 
	### FONCTION AjusteFrontiere :
		Permet de cadrer la carte sur la frontière des éléments contenus dans la carte
	### EXEMPLE : oGoogle.CadreFrontiere();
	*/
	this.CadreFrontiere = function() {
		this.carte.setZoom(this.carte.getBoundsZoomLevel(this.frontiere));
		this.carte.setCenter(this.frontiere.getCenter());
	}
	/* 
	### FONCTION NavigateurCompatible :
		Teste si le navigateur est compatible ou non avec l'API
	### PARAMÈTRES : Aucun.
	### RETOURNE : true/false.
	### EXEMPLE : oGoogle.NavigateurCompatible();
	*/
	this.NavigateurCompatible = function() {
		return (GBrowserIsCompatible());
	}
	/* 
	### FONCTION GenereCarte :
		Créé un objet mappe qui vas se placer dans notre conteneur. Créé le gestionnaire des marqueurs
	### PARAMÈTRES : Aucun.
	### RETOURNE : Rien.
	### EXEMPLE : this.GenereCarte();
	*/
	this.GenereCarte = function() {
		this.carte = new GMap2(this.conteneur);
		this.carte.enableDoubleClickZoom();
	}
	/* 
	### FONCTION ChangeLatitude :
		Change la latitude de la carte
	### PARAMÈTRES :
		fLatitude:Integer, La latitude désirée
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.ChangeLatitude(45.234124);
	*/
	this.ChangeLatitude = function(fLatitude) {
		this.latitude = fLatitude;
		this.CentreMappe(this.latitude,this.longitude,this.zoom);
	}
	/* 
	### FONCTION ChangeLongitude :
		Change la longitude de la carte
	### PARAMÈTRES :
		fLongitude:Integer, La longitude désirée
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.ChangeLongitude(45.234124);
	*/
	this.ChangeLongitude = function(fLongitude) {
		this.longitude = fLongitude;
		this.CentreMappe(this.latitude,this.longitude,this.zoom);
	}
	/* 
	### FONCTION CentreMappe :
		Recentre la carte selon des coordonnées et un niveau de zoom.
	### PARAMÈTRES :
		fLatitude:Integer, Coordonnée pour la latitude
		fLongitude:Integer, Coordonnée pour la longitude
		intZoom:Integer, Le niveau du zoom
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.CentreMappe(45.518527,-73.556578,16);
	*/
	this.CentreMappe = function(fLatitude,fLongitude,intZoom) {
		this.carte.setCenter(new GLatLng(fLatitude, fLongitude),intZoom);
	}
	/* 
	### FONCTION placeMarkerOnTop :
		Fonction utilisé à l'interne (dans AjouteMarqueur) pour permettre de placer en premier plan le marqueur
	### PARAMÈTRES :
		marqueur:GMarker
		b: aucune idée.. mais c'était dans un exemple sur le web http://econym.googlepages.com/example_zindex.htm
	### RETOURNE : le nouveau z-index
	*/
	this.placeMarkerOnTop = function(marqueur,b) {
		return GOverlay.getZIndex(marqueur.getPoint().lat()) + marqueur.importance * 1000000;
	}
	/* 
	### FONCTION AjouteMarqueur :
		Ajoute un marqueur sur la map.
	### PARAMÈTRES :
		strGroupe:String, Nom du groupe du marqueur (pour toggle entre les groupes)
		fLatitude:Float, Coordonnée pour la latitude
		fLongitude:Float, Coordonnée pour la longitude
		strIcone:String, Le nom de l'icône (index dans le array this.listeIcones). Si null, l'icone par défaut sera utilisée.
		strTitre:String, Titre du marqueur affiché lorsque notre souris passe sur le marqueur. Sert aussi pour charger les données quand on clique sur le marqueur
		strInformations:String, texte sous format HTML ou plain text à afficher dans la bulle lorsqu'on clique.
		bAjax:Boolean, Sera true si on vas chercher de l'information par Ajax pour afficher dans l'infobulle
		strClasseCSS:String, Nom de la classe CSS a utiliser pour faire ouvrir un extInfoWindow quand on clique sur le marqueur (optionnel)
		onTop:Integer, Permet de placer un marqueur sur le dessus des autres (plus le chiffre est élevé plus il est au dessus)
	### RETOURNE : l'objet marqueur ajouté sur la carte.
	### EXEMPLE : oGoogle.AjouteMarqueur('mongroupe',45.518527,-73.556578,"monIcone",'le_titre','Description..',false,'classCSS',true)
	*/

	this.AjouteMarqueur = function(strGroupe,fLatitude,fLongitude,strIcone,strTitre,strInformations,bAjax,strClasseCSS,onTop) {
		var position = new GLatLng(fLatitude, fLongitude); // Position du marqueur
		// Récupération de l'icône dans la liste des icônes.
		var oIcone = this.listeIcones[strIcone];
		// Initialisation des options du marqueur
		var marqueurOptions = new Object();
		// Si strTitre est fourni on le met dans les propriétés des options
		if (strTitre != undefined) {
			marqueurOptions.title = strTitre;
		}
		// Si onTop est spécifié on ajoute la gestion du z-index
		if (onTop != undefined && onTop != null) {
			marqueurOptions.zIndexProcess = this.placeMarkerOnTop;
		}
		// Si une icone est spécifiée
		if (oIcone != null) {
			marqueurOptions.icon = oIcone;
			var marqueur = new GMarker(position,marqueurOptions); // Création du marqueur
		} else {
		// Si aucune icone est spécifiée
			if (marqueurOptions != null) {
				var marqueur = new GMarker(position,marqueurOptions); // Création du marqueur avec un title
			} else {
				var marqueur = new GMarker(position); // Création du marqueur de type default
			}
		}
		// Ajoute l'importance de zindex si nécéssaire
		if (onTop != undefined && onTop != null) {
			marqueur.importance = onTop;
		}
		var me = this;
		// Si on veut faire afficher de l'information quand on clique dessus (strInformations doit être fournie dans l'appel de la fonction)
		if (bAjax != undefined && bAjax != "") {
			// C'est ici qu'on vas gérer le click pour zoomer, pour l'instant c'est seulement pour afficher l'information
			marqueur.requeteAjax = "&groupe="+strGroupe+"&id="+bAjax;
			marqueur.strClasseCSS = strClasseCSS;
			GEvent.addListener(marqueur, "click", function() {
				if (strClasseCSS != undefined) {
					marqueur.openExtInfoWindow(me.carte,strClasseCSS,"<strong>Chargement en cours...</strong>");
				} else {
					marqueur.openInfoWindowHtml("<strong>Chargement en cours...</strong>");
				}
				var addStrClasseCSS = (marqueur.strClasseCSS != undefined ? ',"'+marqueur.strClasseCSS+'"' : '');
				$j.ajax({
					url: "/googleapi/getMarkerInfo.php",
					data: marqueur.requeteAjax,
					success:function(response) {
						eval('oGoogle.UpdateMarqueur("'+marqueur.uniqueID+'",response'+addStrClasseCSS+')');
					}
				});

			});
		} else if (strInformations != null && strInformations != undefined) {
			// Si on fourni de l'information à afficher
			GEvent.addListener(marqueur, "click", function() {
				if (strClasseCSS != undefined) {
					marqueur.openExtInfoWindow(me.carte,strClasseCSS,strInformations); // Fenetre custom
				} else {
					marqueur.openInfoWindowHtml(strInformations);
				}
			});
		}
		// Si le groupe désiré n'existe pas on le créé
		if (!this.groupesMarqueurs[strGroupe]) {
			this.groupesMarqueurs[strGroupe] = new Array();
		}
		this.groupesMarqueurs[strGroupe].push(marqueur);		// On ajoute le marqueur dans le groupe
		this.listeMarqueurs.push(marqueur); // Ajout dans la liste globale des marqueurs.. je sais pas si on vas vraiment s'en servir mais bon je l'ai mis.
		
		marqueur.uniqueID = me.listeMarqueurs.length - 1;
		this.AjusteFrontiere(position); // On ajuste la frontiere des éléments sur la carte
		this.listeTempMarqueurs.push(marqueur); // Ajout dans la liste temporaire jusqu'a temp qu'on utilise la fonction afficheMarqueurs()
		return marqueur; // retourne le marqueur ajouté
	}
	/* 
	### FONCTION UpdateMarqueur :
		Appelée par le Listener du marqueur ajouté dans la carte pour faire afficher du contenu par Ajax.
	### PARAMÈTRES :
		idMarqueur:Integer, Le numéro du marqueur dans la liste des marqueurs (this.listeMarqueurs) sur lequel on fera ouvrir une fenêtre
		strData:String, Le contenu html à afficher dans la fenêtre
		strClasseCSS:String, Nom de la classe CSS a utiliser pour faire ouvrir un extInfoWindow quand on clique sur le marqueur (optionnel)
	### RETOURNE : Rien
	### EXEMPLE : oGoogle.UpdateMarqueur(8,"<h1>Mon titre</h1><p>Contenu X</p>","nom_de_ma_classe_css")
	*/
	this.UpdateMarqueur = function(idMarqueur,strData,strClasseCSS) {
		if (strClasseCSS != undefined) {
			this.listeMarqueurs[idMarqueur].openExtInfoWindow(this.carte,strClasseCSS,strData); // Fenetre custom
		} else {
			this.listeMarqueurs[idMarqueur].openInfoWindowHtml(strData);
		}
	}
	
	/* 
	### FONCTION AfficheMarqueurs :
		Permet d'ajouter dans le gestionnaire des marqueurs les marqueurs ajoutés précédemment. Doit être utilisé après la fonction AjouteMarqueurs()
	### PARAMÈTRES :
		intMinZoom:Integer, Niveau du zoom minimal auquel le marqueur s'affiche (0 = vue de la terre, 19 = la vue très proche)
		intMaxZoom:Integer, Niveau du zoom maximal auquel le marqueur s'affiche (0 = vue de la terre, 19 = la vue très proche)
	### RETOURNE : Rien
	### EXEMPLE : oGoogle.AfficheMarqueurs(4,9);
	*/
	this.AfficheMarqueurs = function(intMinZoom,intMaxZoom) {
		this.gestionnaireMarqueurs.addMarkers(this.listeTempMarqueurs, intMinZoom, intMaxZoom);
		this.gestionnaireMarqueurs.refresh();
		this.listeTempMarqueurs = [];
	}
	/*
	### FONCTION AjouteIcone :
		Créé un objet contenant les informations sur une icône pour les marqueurs.
	### PARAMÈTRES :
		strNom:String, nom de l'icône à ajouter
		strImage:String, nom du fichier image PNG (avec extension).
				 Pour l'ombrage le fichier image doit commencer par ombre (Exemple : ombreMonImage.png).
		strTransparent:String, nom du fichier image PNG avec 1% d'opacité (pour Internet Explorer)
		intWidth:Integer / intHeight:Integer, largeur et hauteur de l'image.
		anchor:String sous forme "X,Y" qui représente la position à partir du coin haut à gauche pour définir le centre de l'icone qui pointe sur la coordonnée dans la carte
		clicZone:Array contient les coordonnées de la zone cliquable (comme map dans une image dans une page web) exemple: var reportIconeMap = new Array(0,0,35,0,35,32,0,32);
	### RETOURNE : Rien.
	### EXEMPLE : AjouteIcone("test.png","test2.png",15,15,"7,15")
	*/
	this.AjouteIcone = function(strNom,strImage,strTransparent,intWidth,intHeight,anchor,clicZone) {
		var icone = new GIcon(G_DEFAULT_ICON); // Création de l'icône objet
		icone.image = this.host+this.dossierImages+strImage; // Chemin d'accès vers le fichier png
		icone.shadow = this.host+this.dossierImages+"shadow"+strImage;
		icone.shadowSize = new GSize(intWidth,intHeight);
		icone.transparent = this.host+this.dossierImages+strTransparent; // Chemin d'accès vers le fichier png avec 1% opacité (pour IE)
		icone.iconSize = new GSize(intWidth,intHeight); // Dimensions de l'icône
		if (anchor == undefined) {
			var centre = new GPoint(Math.ceil(intWidth/2),Math.ceil(intHeight/2));
		} else {
			var anchorCoord = anchor.split(',');
			var centre = new GPoint(parseInt(anchorCoord[0]),parseInt(anchorCoord[1]));
			var centreIW = new GPoint(parseInt(anchorCoord[0]),15);
		}
		icone.iconAnchor = centre; // pixels qui représente le centre de l'image pour positionner sur la coordonnée géographique
		icone.infoWindowAnchor = centreIW || centre;
		icone.infoShadowAnchor = centreIW || centre;
		if (clicZone != undefined) {
			icone.imageMap = clicZone;
		}
		this.listeIcones[strNom]  = icone;
	}
	/*
	### FONCTION AjouteControle :
		Ajoute les contrôles pour la carte (utilitaire de zoom et type de carte)
	### PARAMÈTRES :
		strControle:String, nom du contrôle à ajouter. mettra tout de base (zoom et typeCarte) si aucun paramètre.
								possibilité de "zoom","typeCarte","largeMap","miniMap","scale"
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.AjouteControle("zoom");
	*/
	this.AjouteControle = function(strControle,position,offset) {
		if (position != undefined) {
			var offsett = eval('new GSize('+offset+')') || null;
			if (position == 'TOP_RIGHT') { var Cpos = new GControlPosition(G_ANCHOR_TOP_RIGHT,offsett); }
			else if (position == 'TOP_LEFT') { var Cpos = new GControlPosition(G_ANCHOR_TOP_LEFT,offsett); }
			else if (position == 'BOTTOM_LEFT') { var Cpos = new GControlPosition(G_ANCHOR_BOTTOM_LEFT,offsett); }
			else if (position == 'BOTTOM_RIGHT') { var Cpos = new GControlPosition(G_ANCHOR_BOTTOM_RIGHT,offsett); }
			if ((strControle == "zoom") || (strControle == null)) {
				this.carte.addControl(new GSmallMapControl(),Cpos);
			}
	        if ((strControle == "typeCarte") || (strControle == null)) {
				this.carte.addControl(new GMapTypeControl(),Cpos);
			} else if (strControle == "largeMap") {
				this.carte.addControl(new GLargeMapControl(),Cpos);
			} else if (strControle == "miniMap") {
				this.carte.addControl(new GOverviewMapControl(),Cpos);
			} else if (strControle == "scale") {
				this.carte.addControl(new GScaleControl(),Cpos);
			}
		} else {
			if ((strControle == "zoom") || (strControle == null)) {
				this.carte.addControl(new GSmallMapControl());
			}
	        if ((strControle == "typeCarte") || (strControle == null)) {
				this.carte.addControl(new GMapTypeControl());
			} else if (strControle == "largeMap") {
				this.carte.addControl(new GLargeMapControl());
			} else if (strControle == "miniMap") {
				this.carte.addControl(new GOverviewMapControl());
			} else if (strControle == "scale") {
				this.carte.addControl(new GScaleControl());
			}
		}
	}
	/* 
	### FONCTION Trajectoire :
		Trace une ligne courbe entre 2 groupes de coordonnées d'une couleur spécifique
	### PARAMÈTRES :
			strGroupe:String, Nom du groupe de la trajectoire, utile s'il y a plusieurs trajectoires
			strCouleur:String, Couleur Hexadecimale avec le # devant
			intGrosseur:Integer, taille de la ligne à tracer
			fDepartLatitude:Float, Coordonnée de départ au niveau Latitude
			fDepartLongitude:Float, Coordonnée de départ au niveau Longitude
			fArriveeLatitude:Float, Coordonnée d'arrivée au niveau Latitude
			fArriveeLongitude:Float, Coordonnée de d'arrivée au niveau Longitude
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.Trajectoire("explorateur","#0000ff",2,40.65642,-73.7883,61.1699849,-149.944496);
	*/
	this.Trajectoire = function(strGroupe,strCouleur,intGrosseur,fDepartLatitude,fDepartLongitude,fArriveeLatitude,fArriveeLongitude) {
        if (!this.trajet[strGroupe]) {
			this.trajet[strGroupe] = new Array(); // Création du groupe s'il n'existe pas déjà
		}
		var polyOptions = {geodesic:true};
		var polyDep = new GLatLng(fDepartLatitude, fDepartLongitude);
		var polyFin = new GLatLng(fArriveeLatitude, fArriveeLongitude);
		var nouvelleLigne = new GPolyline([polyDep,polyFin], strCouleur, intGrosseur, 1, polyOptions);
        this.carte.addOverlay(nouvelleLigne);
		this.trajet[strGroupe].push(nouvelleLigne);
		this.AjusteFrontiere(polyDep); // On ajuste la frontiere des éléments sur la carte
		this.AjusteFrontiere(polyFin); // On ajuste la frontiere des éléments sur la carte
	}
	/* 
	### FONCTION Trajectoires :
		Trace une série de ligne d'une coordonnée à l'autre, la dernière coordonnée d'arrivée sera le point de départ pour la suivante et ainsi de suite.
	### PARAMÈTRES :
			strGroupe:String, Nom du groupe de la trajectoire, utile s'il y a plusieurs trajectoires
			strCouleur:String, Couleur Hexadecimale avec le # devant
			intGrosseur:Integer, taille de la ligne à tracer
			aCoordonnees:Array de Arrays, Coordonnées des trajectoires sous forme Array(Array(lat,lng),Array(lat,lng),....)
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.Trajectoires("exploProchaines","#0000ff",3,arrayTrajet);
	*/
	this.Trajectoires = function(strGroupe,strCouleur,intGrosseur,aCoordonnees) {
        if (!this.trajet[strGroupe]) {
			this.trajet[strGroupe] = new Array(); // Création du groupe s'il n'existe pas déjà
		}
		if (aCoordonnees.length < 2) { alert('fonction Trajectoire: Veuillez spécifier au moins 2 groupes de coordonnées'); return; }
		var polyOptions = {geodesic:true};
		for (var x = 0;x < aCoordonnees.length-1;x++) {
			// Prends un array et son prochain pour établir un point de départ et d'arrivée
			var fDepartLatitude = aCoordonnees[x][0];
			var fDepartLongitude = aCoordonnees[x][1];
			var fArriveeLatitude = aCoordonnees[x+1][0];
			var fArriveeLongitude = aCoordonnees[x+1][1];
			var polyDep = new GLatLng(fDepartLatitude, fDepartLongitude);
			var polyFin = new GLatLng(fArriveeLatitude, fArriveeLongitude);
			var nouvelleLigne = new GPolyline([polyDep,polyFin], strCouleur, intGrosseur, 1, polyOptions);
	        this.carte.addOverlay(nouvelleLigne);
			this.AjusteFrontiere(polyDep); // On ajuste la frontiere des éléments sur la carte
			if ((x + 1) == aCoordonnees.length) { this.AjusteFrontiere(polyFin); } // On ajuste la frontiere des éléments sur la carte
			this.trajet[strGroupe].push(nouvelleLigne);
		}
	}
	/* 
	### FONCTION TrajectoireToggle :
			Permet de cacher ou montrer un groupe de ligne de trajectoire créée
	### PARAMÈTRES :
			strGroupe:String, Le nom du groupe de la trajectoire.
			bEtat:Boolean, paramètre optionnel qui permet de forcer le toggle à montrer ou cacher spécifiquement. true = montrer
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.TrajectoireToggle("explorateur",false);
	*/
	this.TrajectoireToggle = function(strGroupe,bEtat) {
		// Si le groupe de lignes existe
		if (this.trajet[strGroupe]) {
			// On parcoure les objets lignes
			for (var y = 0; y < this.trajet[strGroupe].length; y++) {
				if (bEtat != undefined) {
					// Si on demande de montrer ou cacher par bEtat (true/false)
					if (bEtat) { this.trajet[strGroupe][y].show(); }
					else { this.trajet[strGroupe][y].hide(); }
				} else {
					// Sinon on toggle sa visibilité
					if (this.trajet[strGroupe][y].isHidden()) {
						this.trajet[strGroupe][y].show();
					} else {
						this.trajet[strGroupe][y].hide();
					}
				}
			}
		}
	}
	/* 
	### FONCTION GenereGestionnaireMarqueurs :
		Créé un instance de l'objet MarkerManager et le place dans une variable de notre "classe"
		Initialise la liste des marqueurs
	### PARAMÈTRES : oGestionnaire:Objet MarkerManager, Sert à gérer l'affichage des marqueurs selon le niveau du zoom dans la carte.
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.GenereGestionnaireMarqueurs(oGestionnaireMarqueurs);
	*/
	this.GenereGestionnaireMarqueurs = function() {
		this.gestionnaireMarqueurs = new MarkerManager(this.carte,{maxZoom:19,borderPadding:0});
		this.listeMarqueurs = []; // Initialisation du array qui contiendra la liste de tout les marqueurs
	}
	
	/* 
	### FONCTION Trace :
		Écris un paragraphe dans la page pour tester une propriété ou fonction.
	### PARAMÈTRES : varFunc:String, sera évalué/effectué.
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.Trace("this.zoom");
	*/
	this.Trace = function(varFunc) {
		var chaine = eval(varFunc);
		var paragraphe = document.createElement('p');
		var texte = document.createTextNode("TRACE: "+chaine);
		paragraphe.appendChild(texte);
		paragraphe.setAttribute('style','background-color:white;position:absolute;left:50%;width:300px;margin-left:-150px;vertical-align:middle;height:50px;margin-top:20px;z-index:2');
		document.body.appendChild(paragraphe);
	}
	/* 
	### FONCTION UtilisateurPunaise :
		Permet d'écouter le click de l,utilisateur dans la carte, d'afficher une icone où il clique
	### PARAMÈTRES :
		strIcone:String, nom de l'icône dans la liste d'icône.
		strInput:String, nom du input qui contiendra les coordonnées
		strTitle:String, Permet de spécifier un message au title qui s'affiche quand la souris passe sur l'icône
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.UtilisateurPunaise("monIcone");
	*/
	this.UtilisateurPunaise = function(strIcone,strInput,strTitle) {
		var me = this;
		GEvent.addListener(me.carte,"click", function(overlay,point) {
			if (point != null && point != undefined) {
				// Sauvegarde les coordonnées dans la propriété de la "classe"
				me.coordonneeClick = new Array(point.y,point.x,me.carte.getZoom());
				if (strInput != null) {
					document.getElementById(strInput).value = point.y + ',' + point.x + ',' + me.carte.getZoom();
				}
				// Si une punaise existe déjà dans la map on la supprime
				if (me.punaise != undefined) {
					me.carte.removeOverlay(me.punaise);
				}
				// Options de l'icône
				var marqueurOptions = new Object();
				marqueurOptions.icon = me.listeIcones[strIcone];
				marqueurOptions.title = strTitle || "Cet emplacement sera associé à votre suggestion. Cliquez pour voir de plus près";
				var marker = new GMarker(point,marqueurOptions);
				// Gestion du click sur l'icône pour zoomer/pan sur l'icône pour améliorer la précision
				GEvent.addListener(marker,"click",function() {
					me.carte.zoomIn();
					me.carte.panTo(point);
				});
				me.punaise = marker;
				me.carte.addOverlay(marker);
			}
		});
	}
	/* 
	### FONCTION CadreVille :
		Permet de cadrer la carte sur une ville en particulier avec un niveau de zoom, peut aussi mettre un marqueur sur la ville
	### PARAMÈTRES : 
			strZone:String, La ville qu'on veut cadrer, avec la province pays au besoin.
			intZoom:Integer, Le niveau du zoom pour le cadrage.
			strIcone:String, Le nom de l'icône précédemment ajouté, si l'icône n'existe pas, une icône par défaut sera utilisée.
			strInput:String, Le ID du input dans lequel les coordonnées seront récupérées.
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.CadreVille("Montréal, Qc",12,"monIcone","coordLieu");
	*/
	this.CadreVille = function(strZone,intZoom,strIcone,strInput) {
		if (!this.clientGeocoder) {
			this.clientGeocoder = new GClientGeocoder(); // Création de l'objet qui permet les recherches de villes.
		}
		if (this.clientGeocoder) {
			// On veut récupérer la latitude et longitude et retourner le point
			var me = this;
			strZone = strZone || "";
			strZone = (strZone == "" ? "Canada" : strZone + ", Canada");
			this.clientGeocoder.getLatLng(
				strZone,
				function(point) {
					// Si la ville n'est pas trouvée, on recadre sur le canada
					if (!point) {
						me.CadreVille("Canada",3);
					} else {
						if (strInput != null) {
							document.getElementById(strInput).value = point.y + ',' + point.x + ',' + me.carte.getZoom();
						}
						me.coordGeoCoder = point;
						// Si la ville existe on centre la carte vers le point
						me.carte.setCenter(point, intZoom);
						if (strIcone != null) {
							// Si on a spécifié un nom d'icône
							var oIcone = me.listeIcones[strIcone];
							// Si l'icône figure dans la liste d'icônes.
							if (oIcone != null) {
								// Initialisation des options du marqueur
								var marqueurOptions = new Object();
								marqueurOptions.icon = oIcone;
								var marker = new GMarker(point,marqueurOptions);
							} else {
								var marker = new GMarker(point);
							}
							me.carte.addOverlay(marker);
						}
					}
				}
			);
		}
	}
	/* 
	### FONCTION MarqueursToggle :
		Permet de montrer ou cacher un groupe de marqueurs selon leur état
	### PARAMÈTRES : 
			strGroupe:String, Nom du groupe de marqueurs contenus dans la variable this.groupesMarqueurs de cette "classe"
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.MarqueursToggle("destination");
	*/
	this.MarqueursToggle = function(strGroupe) {
		// On parcoure les marqueurs contenu dans le groupe
		for (var i = 0; i < this.groupesMarqueurs[strGroupe].length; i++) {
			var marker = this.groupesMarqueurs[strGroupe][i];
			// On fait le Toggle
			if (marker.isHidden()) {
			  marker.show();
			} else {
			  marker.hide();
			}
		} 
	}
	/* 
	### FONCTION CacheMarqueurs :
		Permet de cacher un groupe de marqueurs
	### PARAMÈTRES : 
			strGroupe:String, Nom du groupe de marqueurs contenus dans la variable this.groupesMarqueurs de cette "classe"
	### RETOURNE : Rien.
	### EXEMPLE : oGoogle.CacheMarqueurs("destination");
	*/
	this.CacheMarqueurs = function(strGroupe) {
		// On parcoure les marqueurs contenu dans le groupe
		for (var i = 0; i < this.groupesMarqueurs[strGroupe].length; i++) {
			var marker = this.groupesMarqueurs[strGroupe][i].hide();
		} 
	}
	// Génère la carte !!
	this.GenereCarte();

}