// (C)opyright N-Gine Innovation 2008 - Tous droits réservés
// http://www.ngine-innovation.com

var DebugPoly = new Array();
var baseIconSingles = new Array(); // une icone pour chaque catégorie de lieu (musée, monument, etc.)
var baseIconMultiple = null; // une seule icone pour les regroupements

// variables à surcharger
var ImgMarkerMultiple = 'Images/GMarker/bleu.png';
var ImgMarkerMultipleHighlight = 'Images/GMarker/bleub.png';
var MWCloseBtnAction = null;
var MWZoomBtnAction = null;

// ----------------------------------------------------------------------------------------------------------------------
function getImgSize(imgSrc)
{
  Size = imgSrc.split( '_');
  return new Array( Size[1], Size[2]);
 }

// ----------------------------------------------------------------------------------------------------------------------
function removeDOMElement(Parent) {
 if (!Parent) return;
 while (Parent.firstChild) Parent.removeChild(Parent.firstChild);
}

// **********************************************************************************************************************
// **********************************************************************************************************************
// Classe GeoMap
// **********************************************************************************************************************
// **********************************************************************************************************************

// ----------------------------------------------------------------------------------------------------------------------
// Constructeur :
//  DivID : id du div conteneur de la carte
//  Tableau des évènements
//  MapType : optionnel. Spécifie le type de carte. Valeurs possibles : G_NORMAL_MAP (par défaut), G_SATELLITE_MAP, G_HYBRID_MAP, G_PHYSICAL_MAP
function GeoMap( DivID, Tab, MapType)
{
  this.IDGMap = DivID;
  this.GMap = null;

  this.ZoomControlMoteur=null;
  this.MTControlMoteur=null;
  this.geocoder = null;
  // Tableau des marqueurs
  this.MarkerList = null;
  this.ImgMarkerSingles = new Array(); //ImgMarkerSingles;
  this.IconSingle = null;
  this.ImgMarkerSingleHighlights = new Array(); //ImgMarkerSingleHighlights;
  this.IconSingleH = null;
  this.ImgMarkerMultiple = ImgMarkerMultiple;
  this.IconMultiple = null;
  this.ImgMarkerMultipleHighlight = ImgMarkerMultipleHighlight;
  this.IconMultipleH = null;
  // 04/02/2008
  // this.TabEvent = Tab;
  this.TabEvent = new Array;
  this.MouseOverMark = null;
  this.MouseOutMark = null;
  this.MouseClickMark = null;
  // Creation de la carte Google
  this.GMap = new GMap2(document.getElementById( this.IDGMap));
  // Cache par défaut : la carte est doublée
  this.CacheX = 1;
  this.CacheY = 1;
  this.CacheBound = new GBounds;
  // Création de la zone d'affichage du tooltip
  this.GMap.TooltipDiv = document.createElement("div");
  this.GMap.TooltipDiv.className = "ToolTip";
  this.GMap.TooltipDiv.style.zIndex = 2;
  document.getElementById(this.IDGMap).appendChild(this.GMap.TooltipDiv);
  this.GMap.TooltipDiv.style.visibility="hidden";
  // Création de la  zone d'affichage de la bulle d'aide
  // MegaWindow appartient à GMAp pour pouvoir y accéder depuis les évènements
  this.GMap.MegaMarker = null;
  this.GMap.MegaWindowDiv = document.createElement("div");
  //this.GMap.MegaWindowDiv.className = "MegaWindow";
  this.GMap.MegaWindowDiv.style.zIndex = 2;
  this.GMap.MegaWindowDiv.innerHTML = '<table class="MegaWindow" id="MegaWindow" cellpadding="0" cellspacing="0" style="width:346px;"><tr><td class="MegaBorderTL"></td><td class="MegaBorderT"></td><td title="Cliquez pour centrer la carte sur ces entreprises" class="MegaBorderZoomBtn" onClick="javascript:MegaWindowZoomClick();"></td><td class="MegaBorderCloseBtn" title="Cliquez pour fermer cette fen&ecirc;tre" onClick="javascript:MegaWindowCloseClick();"></td><td class="MegaBorderTR"></td></tr>' +
  		'<tr><td class="MegaBorderL"></td><td colspan="3"><div id="MegaWindowContent1" class="MegaWindowContent"></div></td><td class="MegaBorderR"></td></tr>' +
  		'<tr><td class="MegaBorderBL"></td><td colspan="3" class="MegaBorderB"></td><td class="MegaBorderBR"></td></tr></table>';
  this.GMap.MegaWindowContentDiv = document.getElementById("MegaWindowContent1");
  document.getElementById(this.IDGMap).appendChild(this.GMap.MegaWindowDiv);
  //document.getElementsByTagName("body")[0].appendChild(this.GMap.MegaWindowDiv);
  this.GMap.MegaWindowDiv.style.visibility="hidden";

  /*if (this.TabEvent)
  {
	  for (var i = 0; i < this.TabEvent.TabEvt.length; i++)
	  {
      if ( this.TabEvent.TabEvt[i].EventName == "onMarkerClick")
        this.MouseClickMark = this.TabEvent.TabEvt[i].Fonction;
      else
      {
	  	  GEvent.addListener( this.GMap, this.TabEvent.TabEvt[i].EventName, this.TabEvent.TabEvt[i].Fonction);
	  	}
	  }
	}*/

  this.click = GEvent.addListener(this.GMap, 'click', this.OnClick);
  this.move = GEvent.addListener(this.GMap, 'move', this.OnMove);

  if (Tab)
  {
	for (var i = 0; i < Tab.TabEvt.length; i++)
	{
	   	if ( Tab.TabEvt[i].EventName == "onMarkerClick")
	     	this.MouseClickMark = Tab.TabEvt[i].Fonction;
	   	else
	   	{
		  this.TabEvent.push( GEvent.addListener( this.GMap, Tab.TabEvt[i].EventName, Tab.TabEvt[i].Fonction));
		}
	}

	this.GMap.addMapType(G_PHYSICAL_MAP);
	if (MapType)
		this.GMap.setMapType(MapType);
	else
		this.GMap.setMapType(G_NORMAL_MAP);
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setCacheSize	 = function( X, Y){
    // 04/02/2008
    if ( this.MarkerList != null)
      this.MarkerList.Clear();

    this.CacheX = X;
    this.CacheY = Y;
    var Lng1, Lng2, Lat1, Lat2;
    var X1, X2, Y1, Y2;
    var DeltaX, DeltaY;

    X1 = this.getCoordLeft();
    X2 = this.getCoordRight();
    Y1 = this.getCoordTop();
    Y2 = this.getCoordBottom();
    Lng1 = Math.min( X1, X2);
    Lng2 = Math.max( X1, X2);
    Lat1 = Math.min( Y1, Y2);
    Lat2 = Math.max( Y1, Y2);

		DeltaX = ( Lng2 - Lng1) / (1/this.CacheX);
		DeltaY = ( Lat2 - Lat1) / (1/this.CacheY);

    Lng1 -= DeltaX;
    Lng2 += DeltaX;
    Lat1 -= DeltaY;
    Lat2 += DeltaY;
    if ( this.CacheBounds != null)
      delete this.CacheBounds;
    this.CacheBounds = new GLatLngBounds();
    this.CacheBounds.extend( new GLatLng( Lat1, Lng1));
    this.CacheBounds.extend( new GLatLng( Lat2, Lng2));
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.isViewPortInCache = function(){
    if ( this.CacheBounds)
      return( this.CacheBounds.containsBounds( this.GMap.getBounds()));
    else
      return false;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.isMarkerVisible = function(lat, lng){
    return this.GMap.getBounds().containsLatLng( new GLatLng( lat, lng));
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setMouseOverMark = function (fn){
    this.MouseOverMark = fn;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setMouseOutMark = function (fn){
    this.MouseOutMark = fn;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setMouseClickMark = function (fn){
    this.MouseClickMark = fn;
  }

  // --------------------------------------------------------------------------------------------------------------------
  // Images des marqueurs
  this.setSingleMarkUrl = function (Category, url){
    baseIconSingles[Category] = new GIcon();
    var size = getImgSize( url);
    if ( (size[0] == 0) || ( size[1]==0))
    {
      size[0] = 32;
      size[1] = 32;
    }
    baseIconSingles[Category].iconSize = new GSize(size[0], size[1]);
    baseIconSingles[Category].iconAnchor = new GPoint(size[0] / 2, size[1] / 2);
    baseIconSingles[Category].infoWindowAnchor = new GPoint(size[0] / 2, size[1] / 2);
    this.ImgMarkerSingles[Category] = url;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setMultipleMarkUrl = function ( url){
    baseIconMultiple = new GIcon();
    var size = getImgSize( url);
    if ( (size[0] == 0) || ( size[1]==0))
    {
      size[0] = 32;
      size[1] = 32;
    }
    baseIconMultiple.iconSize = new GSize(size[0], size[1]);
    baseIconMultiple.iconAnchor = new GPoint(size[0] / 2, size[1] / 2);
    baseIconMultiple.infoWindowAnchor = new GPoint(size[0] / 2, size[1] / 2);
    this.ImgMarkerMultiple = url;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setSingleMarkHighlighUrl = function (Category, url){
    this.ImgMarkerSingleHighlights[Category] = url;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.setMultipleMarkHighlightUrl = function ( url){
    this.ImgMarkerMultipleHighlight = url;
  }

  // --------------------------------------------------------------------------------------------------------------------
  // Récupération des coordonnées de la carte
  this.getCoordLeft = function(){
    if (this.GMap)
	   return this.GMap.getBounds().getNorthEast().lng();
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.getCoordTop = function(){
    if (this.GMap)
	   return this.GMap.getBounds().getNorthEast().lat();
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.getCoordBottom = function(){
    if (this.GMap)
	   return this.GMap.getBounds().getSouthWest().lat();
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.getCoordRight = function(){
    if (this.GMap)
	   return this.GMap.getBounds().getSouthWest().lng();
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.ShowTooltip = function(MyMarker) {
	// on affiche un tooltip seulement :
	//  - s'il y a du texte à afficher ET
	//  - si la MegaWindow n'est pas visible (La MegaWindow a la priorité sur le tooltip)
	if ((MyMarker.TooltipContent == null) || (this.MegaWindowDiv.style.visibility == "visible"))
	  return;
	this.TooltipDiv.innerHTML = MyMarker.TooltipContent;
	var point=this.getCurrentMapType().getProjection().fromLatLngToPixel(this.getBounds().getSouthWest(),this.getZoom());
	var offset=this.getCurrentMapType().getProjection().fromLatLngToPixel(MyMarker.GMark.getPoint(),this.getZoom());
	var anchor=MyMarker.GMark.getIcon().iconAnchor;
	var width=MyMarker.GMark.getIcon().iconSize.width;
	var pos = new GControlPosition(G_ANCHOR_BOTTOM_LEFT, new GSize(offset.x - point.x - anchor.x, -offset.y + point.y + anchor.y));
	pos.apply(this.TooltipDiv);
	this.TooltipDiv.style.visibility="visible";
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.HideTooltip = function() {
	this.TooltipDiv.style.visibility="hidden";
	removeDOMElement(this.TooltipDiv);
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.UpdateMegaWindowInnerHTML = function(InnerHTML) {
	removeDOMElement(this.MegaWindowContentDiv);
	this.MegaWindowContentDiv.innerHTML = InnerHTML;
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.ShowMegaWindowPrivate = function(MyMarker, InnerHTML, ZoomAction, CloseAction) {
	this.HideTooltip();
	this.MegaMarker = MyMarker;
//	GDownloadUrl(Url, function(data, responseCode) {
//	  // To ensure against HTTP errors that result in null or bad data,
//	  // always check status code is equal to 200 before processing the data
//	  if(responseCode == 200) {
//	  	this.MegaWindowContentDiv = document.getElementById("MegaWindowContent1");
//		this.MegaWindowContentDiv.innerHTML = data;
//	  } else if(responseCode == -1) {
//	    this.MegaWindowContentDiv.innerHTML = "Data request timed out. Please try later.";
//	  } else {
//	    this.MegaWindowContentDiv.innerHTML = "Request resulted in error. Check XML file is retrievable.";
//	  }
//	});
  	this.MegaWindowContentDiv = document.getElementById("MegaWindowContent1");
	this.UpdateMegaWindowInnerHTML(InnerHTML);

	MWZoomBtnAction = ZoomAction;
	MWCloseBtnAction = CloseAction;

	this.UpdateMegaWindowPosition();
    this.MegaWindowDiv.style.visibility="visible";
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.UpdateMegaWindowPosition = function() {
    var point=this.getCurrentMapType().getProjection().fromLatLngToPixel(this.getBounds().getSouthWest(),this.getZoom());
    var offset=this.getCurrentMapType().getProjection().fromLatLngToPixel(this.MegaMarker.getPoint(),this.getZoom());
    var anchor=this.MegaMarker.getIcon().iconAnchor;
    var pos = new GControlPosition(G_ANCHOR_BOTTOM_LEFT, new GSize(offset.x - point.x, -offset.y + point.y + anchor.y));
    pos.apply(this.MegaWindowDiv);
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.ShowMegaWindow = function(MyMarker, InnerHTML, ZoomAction, CloseAction) {
  	this.savePosition();
    this.ShowMegaWindowPrivate(MyMarker, InnerHTML, ZoomAction, CloseAction);
  }

  // --------------------------------------------------------------------------------------------------------------------
  // Pan sur la carte de facon à ce que le marqueur soit positionné dans la zone délimitée par (MinX, MaxX, MinY, MaxY) exprimés en % de 0 à 1
  this.GMap.ShowMegaWindowAndPan = function(MyMarker, InnerHTML, ZoomAction, CloseAction, MinX, MaxX, MinY, MaxY) {
	var latlng = MyMarker.getLatLng();
    var coord = this.fromLatLngToContainerPixel(latlng);
    var dim = this.getSize();
    var deltaX = 0;
    var deltaY = 0;

    if (coord.x > dim.width * MaxX)
    	deltaX = dim.width * MaxX - coord.x;
    else if (coord.x < dim.width * MinX)
    	deltaX = dim.width * MinX - coord.x;
    if (coord.y > dim.height * MaxY)
    	deltaY = dim.height * MaxY - coord.y;
    else if (coord.y < dim.height * MinY)
    	deltaY = dim.height * MinY - coord.y;

  //alert (deltaX + ', ' + deltaY);
    this.savePosition();
    this.panBy(new GSize(deltaX, deltaY));

    this.ShowMegaWindowPrivate(MyMarker, InnerHTML, ZoomAction, CloseAction);
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.HideMegaWindow = function() {
  	this.MegaMarker = null;
    this.MegaWindowDiv.style.visibility="hidden";
	removeDOMElement(this.MegaWindowContentDiv);
    this.returnToSavedPosition();
  }

  // --------------------------------------------------------------------------------------------------------------------
  this.GMap.IsMegaWindowVisible = function() {
    return (this.MegaWindowDiv.style.visibility == "visible");
  }
}

// ----------------------------------------------------------------------------------------------------------------------
//04/02/2008
GeoMap.prototype.Clear = function(){
  // Nettoyage mémoire
  this.DeleteMarkers();
  delete CacheBounds;
  delete this.Center;
  for (var j= this.TabEvent.length-1; j>=0; j--)
  {
    GEvent.removeListener(this.TabEvent[j]);
  }
  delete this.TabEvent;
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.OnClick = function(overlay, latlng, overlaylatlng){
  //alert(overlay);
  if ((overlay == null) && (this.MegaWindowDiv.style.visibility == "visible"))
    this.HideMegaWindow();
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.OnMove = function(){
  if (this.MegaMarker == null)
    return;
  var visible = this.IsMegaWindowVisible();
  var shouldBeVisible = this.getBounds().containsLatLng(this.MegaMarker.getLatLng());
  if (visible && shouldBeVisible)
    this.UpdateMegaWindowPosition();
  else if (visible && !shouldBeVisible)
    this.MegaWindowDiv.style.visibility = "hidden";
  else if (!visible && shouldBeVisible) {
    this.MegaWindowDiv.style.visibility = "visible";
    this.UpdateMegaWindowPosition();
  }
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.GetMarker = function( ID)
{
  if ( this.MarkerList == null)
    return null;
  return this.MarkerList.GetMarker( ID);
}

// ----------------------------------------------------------------------------------------------------------------------
// Tri des marqueurs du nord vers le sud
GeoMap.prototype.SortMarker = function()
{
  if ( this.MarkerList == null)
    return null;
  return this.MarkerList.SortMarker();
}

// ----------------------------------------------------------------------------------------------------------------------
// Rajoute une donnée
GeoMap.prototype.AddMark = function( ID, lat, lng, W, Zone, Category, TooltipContent)
{
  // Rajoute les nouveles coordonnées
  var latlng = new GLatLng( lat, lng);
  if ( this.MarkerList == null)
    this.MarkerList = new MarkerList();
  var iMarker = this.MarkerList.AddMarker( this, latlng, ID, Zone, Category, TooltipContent);
  iMarker.Weight = W;
  return iMarker.GMark;
  // 04/02/2008
  delete latlng;
}

// ----------------------------------------------------------------------------------------------------------------------
// Positionne la carte à une adresse données
// ex :
//    address = 75000 Paris
//    zoom   = niveau de zoom
GeoMap.prototype.SetAddress = function( address, zoom)
{
  if ( this.geocoder == null)
    this.geocoder = new GClientGeocoder();

  var temp = this;
  this.geocoder.getLatLng( address,
    function(point){
      if (!point)
        alert("L'adresse spécifiée est introuvable");
      else
        temp.GMap.setCenter(point, zoom);
      });
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.DeletePolys = function()
{
	for ( var i = 0; i < DebugPoly.length; i++)
		this.GMap.removeOverlay( DebugPoly[i]);
	while( DebugPoly.length != 0)
	{
		DebugPoly.pop();
	}
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.DeleteMarkers = function()
{

  if ( this.MarkerList != null)
    this.MarkerList.Clear();
  delete this.MarkerList;
  this.MarkerList = null;
}

// ----------------------------------------------------------------------------------------------------------------------
// Affichage des marqueurs
GeoMap.prototype.DisplayMarks = function()
{
  if ( this.MarkerList != null)
    this.MarkerList.ShowMarkers();
}

// ----------------------------------------------------------------------------------------------------------------------
// Création de la carte et affichage
GeoMap.prototype.Show = function()
{
  // Pour pallier au pb de redimensionnement de la carte
  this.GMap.checkResize();

  // Rajoute le zoom à la carte
  if ( this.ZoomControlMoteur == null)
    this.ZoomControlMoteur = this.GMap.addControl(new GLargeMapControl(), new GControlPosition(G_ANCHOR_TOP_LEFT,new GSize(0,0)));

  // rajoute un indicateur d'echelle sur la carte
  if ( this.MTControlMoteur == null)
    this.MTControlMoteur = new GScaleControl();
  this.GMap.addControl( this.MTControlMoteur, new GControlPosition(G_ANCHOR_BOTTOM_RIGHT,new GSize(5,20)));

  // rajoute le choix du type de carte
  this.GMap.addControl(new GMapTypeControl(), new GControlPosition(G_ANCHOR_TOP_RIGHT,new GSize(0,0)));
  this.GMap.addMapType(G_PHYSICAL_MAP);


  // On positionne la carte au "centre" de la france
  this.SetAddress( 'Bourges', 5);
}

// ----------------------------------------------------------------------------------------------------------------------
// Recalcule les zones de la carte, refait l'aggrégation et affiche les marqueurs
GeoMap.prototype.Invalidate = function()
{
  this.DisplayMarks(); // Affichage
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.AddPoly = function( X1, Y1, X2, Y2, borderColor, fillColor, fillOpacity)
{
if (! borderColor)
	borderColor = "#ff0000";
if (! fillColor)
	fillColor = "#ffaaaa";
if (! fillOpacity)
	fillOpacity = 0.2;
  var Poly = new GPolygon( [new GLatLng( Y1, X1), new GLatLng( Y1, X2), new GLatLng( Y2, X2), new GLatLng( Y2, X1), new GLatLng( Y1, X1)], borderColor, 1, 1, fillColor, fillOpacity);
  DebugPoly.push( Poly);
  this.GMap.addOverlay( Poly);
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.SetDetail = function( lng, lat, zoom, mode, nom, url){
  if (this.Center != null)
    delete this.Center;
  this.Center = new GLatLng( lat, lng);
  this.ZoomLevel = zoom;
  this.DetailName = nom;
  this.DetailMode = mode;
  this.DetailURL = url;
  // Positionnement
  this.GMap.setCenter( this.Center, this.ZoomLevel);
}

// ----------------------------------------------------------------------------------------------------------------------
GeoMap.prototype.DisplayDetailMap = function(){
  this.GMap.checkResize();
  // Changement du mode de la carte
  this.GMap.setMapType( this.GMap.getMapTypes()[parseInt(this.DetailMode)]);

  var GlobCurrentMark = new GMarker(this.Center, { draggable:false});
  // Rajoute le marqueur
  this.GMap.addOverlay( GlobCurrentMark);
  // Création du texte
  var InfoText = '<div align="center"><a href="'+this.DetailURL+'" target="_blank"><b>' + this.DetailName +'</b></a></div></br>';
  // InfoText = InfoText + 'Cliquez sur le lien pour visiter le site';
  GlobCurrentMark.infoWindow = InfoText;
  GlobCurrentMark.openInfoWindowHtml(GlobCurrentMark.infoWindow, {maxWidth:250});
  // 04/02/2008
  delete GlobCurrentMark;
}

// **********************************************************************************************************************
// **********************************************************************************************************************
// Classe Marker
// **********************************************************************************************************************
// **********************************************************************************************************************

// ----------------------------------------------------------------------------------------------------------------------
// Permet de matérialiser un marqueur de type GMarker
function Marker(geomap, Id, Category, TooltipContent)
{
	this.ID = Id;
	this.GeoMap = geomap;
	this.GMark = null;
	this.Coord = null;
	this.Bounds = null;
	this.Weight = 0;
	this.Category = Category; // musée, monument, etc.
	this.TooltipContent = null;
	if (TooltipContent != null)
		this.TooltipContent = '<div class="markerTooltip">' + TooltipContent + '</div>';
}

// ----------------------------------------------------------------------------------------------------------------------
Marker.prototype.OnMouseOver = function(){
  // récupère le marker (type Marker) qui encapsule le GMarker "this"
  var MyMarker = this.GeoMap.GetMarker(this.ID);

  if ( this.Weight == 1)
	this.setImage( this.GeoMap.ImgMarkerSingleHighlights[MyMarker.Category]);
  else
	this.setImage( this.GeoMap.ImgMarkerMultipleHighlight);

  this.GeoMap.GMap.ShowTooltip(MyMarker);

  if ( this.GeoMap.MouseOverMark != null)
    this.GeoMap.MouseOverMark( this);
 }

// ----------------------------------------------------------------------------------------------------------------------
Marker.prototype.OnMouseOut = function(){
  // récupère le marker (type Marker) qui encapsule le GMarker "this"
  var MyMarker = this.GeoMap.GetMarker(this.ID);

  if ( this.Weight == 1)
    this.setImage( this.GeoMap.ImgMarkerSingles[MyMarker.Category]);
  else
    this.setImage( this.GeoMap.ImgMarkerMultiple);

  this.GeoMap.GMap.HideTooltip();

  if ( this.GeoMap.MouseOutMark != null)
    this.GeoMap.MouseOutMark( this);
}

// ----------------------------------------------------------------------------------------------------------------------
Marker.prototype.OnClick = function(){
  if ( this.GeoMap.MouseClickMark != null)
    this.GeoMap.MouseClickMark( this);
}

// ----------------------------------------------------------------------------------------------------------------------
Marker.prototype.ShowMarker = function(){
	if ( this.GMark == null)
	{
	  if ( this.Weight == 1)
	  {
	      var Icon = new GIcon(baseIconSingles[this.Category]);
	      Icon.image = this.GeoMap.ImgMarkerSingles[this.Category];
	      markerOptions = { icon:Icon };
	      this.GMark = new GMarker( new GPoint( this.Coord.lng(), this.Coord.lat()), markerOptions);
		}
		else
		{
	      var Icon = new GIcon(baseIconMultiple);
	      Icon.image = this.GeoMap.ImgMarkerMultiple;
	      markerOptions = { icon:Icon };
		  this.GMark = new GMarker( new GPoint( this.Coord.lng(), this.Coord.lat()), markerOptions);
		}
		// Repporte les données sur le marqueur
		this.GMark.ID = this.ID;         // ID du site touristique
		this.GMark.Bounds = this.Bounds; // zone englobante
		this.GMark.Weight = this.Weight; // Pondération
		this.GMark.GeoMap = this.GeoMap; // Carte google

		this.GeoMap.GMap.addOverlay( this.GMark, { draggable:false});
		// 04/02/2008
	    /*
	      GEvent.addListener( this.GMark, 'click', this.OnClick);
	      GEvent.addListener( this.GMark, 'mouseover', this.OnMouseOver);
	      GEvent.addListener( this.GMark, 'mouseout', this.OnMouseOut);
	    */
	    this.GMark.click = GEvent.addListener( this.GMark, 'click', this.OnClick);
	    this.GMark.mouseover = GEvent.addListener( this.GMark, 'mouseover', this.OnMouseOver);
	    this.GMark.mouseout = GEvent.addListener( this.GMark, 'mouseout', this.OnMouseOut);
	}
	return (this.GMark);
}

// ----------------------------------------------------------------------------------------------------------------------
Marker.prototype.HideMarker = function(){
	if ( this.GMark != null)
	{
		this.GeoMap.GMap.removeOverlay( this.GMark);
		// 04/02/2008
		GEvent.removeListener( this.GMark.click);
		GEvent.removeListener( this.GMark.mouseover);
		GEvent.removeListener( this.GMark.mouseout);
		delete this.GMark;
		this.GMark = null;
	}
}


// **********************************************************************************************************************
// **********************************************************************************************************************
// Classe MarkerList
// **********************************************************************************************************************
// **********************************************************************************************************************

// ----------------------------------------------------------------------------------------------------------------------
// Contient la totalité des marqueurs
function MarkerList()
{
	this.Index = 0;
	this.List = new Array;
}

// ----------------------------------------------------------------------------------------------------------------------
// Rajoute un marqueur aux coordoonées spécifiées
MarkerList.prototype.AddMarker = function( geomap, latlng, nID, Zone, Category, TooltipContent){
  var iItem = new Marker(geomap, nID, Category, TooltipContent);
  iItem.Coord = latlng;
  // Découpage de la zone englobante
  var Bound = Zone.split( "|");
  var bounds2=new GLatLngBounds();
  bounds2.extend(new GLatLng( Bound[1], Bound[0]));
  bounds2.extend(new GLatLng( Bound[3], Bound[2]));
  iItem.Bounds = bounds2;
  this.List.push( iItem);
  this.Index++;
  return iItem;
}

// ----------------------------------------------------------------------------------------------------------------------
// Affiche tous les marqueurs de la liste
MarkerList.prototype.ShowMarkers = function(){
	for (var i = 0; i < this.List.length; i++)
		this.List[i].ShowMarker();
}

// ----------------------------------------------------------------------------------------------------------------------
// Affiche le marqueur d'index nIndex
MarkerList.prototype.ShowMarker = function( nIndex){
  if ( nIndex < this.List.length)
    this.List[ nIndex].ShowMarker();
}

// ----------------------------------------------------------------------------------------------------------------------
// Masque les marqueurs
MarkerList.prototype.HideMarkers = function(){
	for (var i = 0; i < this.List.length; i++)
		this.List[i].HideMarker();
}

// ----------------------------------------------------------------------------------------------------------------------
// Retourne un marker
MarkerList.prototype.GetMarker = function( ID){
  var bFound = false;
  for ( i = 0; i < this.List.length; i++)
  {
    if ( this.List[i].ID == ID)
      return this.List[i];
  }
  return null;
}

// ----------------------------------------------------------------------------------------------------------------------
// Efface toute la liste
MarkerList.prototype.Clear = function(){
	while( this.List.length != 0)
	{
		var iMark = this.List.pop();
		iMark.HideMarker();
		delete iMark.Coord;
		this.Index--;
	}
}

// -----------------------------------------------------------------------------------------------------------------------
MegaWindowZoomClick = function() {
	if (MWZoomBtnAction != null)
		MWZoomBtnAction();
}

// -----------------------------------------------------------------------------------------------------------------------
MegaWindowCloseClick = function() {
	if (MWCloseBtnAction != null)
		MWCloseBtnAction();
}

// **********************************************************************************************************************
// **********************************************************************************************************************
// **********************************************************************************************************************
// **********************************************************************************************************************
// **********************************************************************************************************************
// **********************************************************************************************************************
// Marqueur Interface.inc.js
// Ne pas effacer les deux premières lignes du fichier qui servent de marqueur afin de déterminer si l'interface a déjà été chargée lors d'un appel précédent

// (C)opyright N-Gine Innovation 2008 - Tous droits réservés
// http://www.ngine-innovation.com

function AppelCrossDomain(URL)
{
  var BaliseScript = document.createElement('script');
  BaliseScript.language="JavaScript";
  BaliseScript.src = URL;
  BaliseScript.type = 'text/javascript';
  document.body.appendChild(BaliseScript);
}
gSpotEmploiNdd = "www.spotemploi.com";
gContractKey = "23a58cfee5456ea1272b1cbe289316f8"
// (C)opyright N-Gine Innovation 2008 - Tous droits réservé.
// http://www.ngine-innovation.com
// fichier créé le 30/09/2008 par m.c.

// ------------------------------------------------------------------------------------------------
// Variables globales
var markerCount = 3; // nombre d'images différentes pour les marqueurs
var markerDefault = 1; // category par défaut (quand le champ categorie1 n'est pas renseigné) -- attention : indicé à partir de 1
var markerSingle = "/api2/pictures/marker2-s_18_18_.png";
var markerSingleHighlight = "/api2/pictures/marker2-h_20_19_.png";
var markerMultiple = "/api2/pictures/marker2-m-s_21_20_.png";
var markerMultipleHighlight = "/api2/pictures/marker2-m-h_21_21_.png";
var useMegaWindow = true;
//var divSearchHeight = 30; // px
//var divSearchMarginBottom = 10; // px
var markerURLs = Array();
var markerRawBounds = Array();
var maxLinkCount = 4; // nombre de liens dans le cadre de navigation dans la liste des résultats

// ------------------------------------------------------------------------------------------------
// créé une closure
// code magique qui permet de lier une méthode à un contexte (il est ainsi possible de différer
// l'exécution d'une méthode d'instance pour un évènement par ex)
// param object : le contexte d'exécution (le plus souvent this)
//       method : la méthode à lier au contexte
function bindMethod(object, method) {
	return function() {
		return method.apply(object, arguments);
	}
}

// ------------------------------------------------------------------------------------------------
// Appel cross-domain
// permet de passer outre la limitation du httpRequest et de de faire des requètes ajax sur d'autres
// domaines. La solution est d'ajouter une balise <script> au document, celle-ci pouvant provenir
// d'un autre domaine.
function CrossDomainCall(URL)
{
	var BaliseScript = document.createElement('script');
	BaliseScript.id = new Date().getTime(); // genere un id unique
	BaliseScript.language="JavaScript";
	BaliseScript.src = URL + '%26ScriptID=' + BaliseScript.id;
	BaliseScript.type = 'text/javascript';
	document.body.appendChild(BaliseScript);
}

// la liste des annuaires. Si un annuaire venait  etre supprimé, la taille de la liste reste
// inchangée mais l'élément devient null.
var annuaires = new Array();

// ************************************************************************************************
// ************************************************************************************************
// ***      Classe JobsDirectory
// ************************************************************************************************
// ************************************************************************************************
// Constructeur
// param clefContrat : clef du contrat d'utilisation de l'API resoeco
//       resoecoNdd : nom de domaine de resoeco (null => www.resoeco.com)
//       parentDiv : id du div dans lequel placer la carte
//       searchFields : id des champs de recherche dans l'ordre suivant :
//                      [category, subCategory, location, locationRadius, name, onlyTypePMor, onlyTypeEntPers, (submit)]
//                      si submit est renseigné, les recherches se font de manière asynchrone
//       width : largeur du parentDiv en px
//       height : hauteur du parentDiv en px
//       resoecoNdd : nom de domaine de resoeco
function JobsDirectory(parentDiv, mapWidth, mapHeight/*, searchFields, resultParentDiv, resListHeight*/)
{
	this.targetBlank = true;
	this.clefContratAPIRES = gContractKey;
	if (gSpotEmploiNdd && (gSpotEmploiNdd != ''))
		this.ndd = gSpotEmploiNdd;
	else
		this.ndd = "www.spotemploi.com";
	this.mainDiv = document.getElementById(parentDiv);
//	this.textDiv = document.getElementById(resultParentDiv);
	this.widgetWidth = mapWidth;
	this.widgetHeight = mapHeight;
//	this.resultListHeight = resListHeight;
//	if (searchFields == undefined) searchFields = [];
//	if ((searchFields.constructor.toString().indexOf("Array") == -1) || ((searchFields.length != 7) && (searchFields.length != 8) && (searchFields.length != 0)))
//		alert('ERREUR : Le parametre searchFields est incorrect dans l\'appel a JobsDirectory()');
//	else
//	{
//		if (searchFields.length > 0) {
//			this.categoryField = searchFields[0];
//
//			var options = '<option value="-1"></option>';
//			for(var i = 0; i < gDomainCategories.length; i++)
//				options += '<option value="' + gDomainCategories[i].CATID + '">' + gDomainCategories[i].CATNOM + '</option>';
//			jQuery("#" + this.categoryField).html(options).change(bindMethod(this, this.onCategoryChange));
//
//			this.subCategoryField = searchFields[1];
//			jQuery("#" + this.subCategoryField).html('<option value="-1">&nbsp;</option>');
//			this.locationField = searchFields[2];
//			this.locationRadiusField = searchFields[3];
//			this.nameField = searchFields[4];
//			this.onlyTypePMorField = searchFields[5];
//			this.onlyTypeEntPersField = searchFields[6];
//			if (searchFields[7]) {
//				this.submitField = searchFields[7];
//				jQuery("#" + this.submitField).click(bindMethod(this, this.onSearchSubmit));
//			}
//		}
//	}

	this.id = annuaires.length;
	annuaires[this.id] = this;

	this.mainDiv.innerHTML = '<div id="divGoogleMap' + this.id + '" style="height:' + mapHeight + 'px;width: ' + mapWidth + 'px"></div>';

	this.mapDiv = 'divGoogleMap' + this.id;

	this.dZoom = null;
	this.megaWindowMarker = null;
	// Nombre maxi de marqueurs à regrouper
	this.maxWeight = 2;
	// Pondération du dernier marqueur cliqué
	this.lastWeight = this.maxWeight;
	// Mémorisation de la dernière position visible de la carte
	this.mLeft = 0;
	this.mRight = 0;
	this.mTop = 0;
	this.mBottom = 0;

	this.updating = false;
	this.hasMoved = false;
	this.initAnnuaire();
}

// ------------------------------------------------------------------------------------------------
// supprime l'annuaire de la page HTML (libération de la mémoire ?)
JobsDirectory.prototype.destroy = function()
{
	removeDomElement(this.mainDiv);
	annuaires[this.id] = null;
}

// ------------------------------------------------------------------------------------------------
// debut de mise a jour de la carte. Les évènements move() zoom() etc ne doivent plus avoir d'effet
JobsDirectory.prototype.beginUpdate = function()
{
	this.updating = true;
}

// ------------------------------------------------------------------------------------------------
// fin de mise a jour de la carte. Les évènements move() zoom() etc doivent de nouveau avoir un effet
JobsDirectory.prototype.endUpdate = function()
{
	this.updating = false;
}

// ------------------------------------------------------------------------------------------------
// Initialisation de la carte.
// Creation de la carte (utilisation de l'API NGine)
JobsDirectory.prototype.initAnnuaire = function()
{
	// TODO creation des critères
	if (GBrowserIsCompatible())
	{
		this.beginUpdate();
		this.geoMap = new GeoMap(this.mapDiv, {
			"TabEvt":[

			{
				"EventName":"load",
				"Fonction":bindMethod(this, this.onMapLoad)
				},

				{
				"EventName":"onMarkerClick",
				"Fonction":bindMethod(this, this.onMarkerClick)
				}
			]
			}, G_PHYSICAL_MAP);
		this.geoMap.Show();
		this.endUpdate();
	}
//	this.loadResultList();
}

// ------------------------------------------------------------------------------------------------
// Quand l'utilisateur change de catégorie => chargement de la liste des sous-catégories
//JobsDirectory.prototype.onCategoryChange = function(){
//	var catId = jQuery("#" + this.categoryField).val();
//	if (catId != "-1" && catId != "")
//	{
//		jQuery('#' + this.subCategoryField).html('<option value="-1">Chargement...</option>');
//		CrossDomainCall('http://' + this.ndd + '/api2/resoeco/f/GetSubCategoryList.js-Key=' + this.clefContratAPIRES + "%26category="+catId+"%26callback=updateSubCatList%26targetId="+this.subCategoryField);
//	} else {
//		jQuery("#" + this.subCategoryField).html('<option value="-1">&nbsp;</option>');
//	}
//}

// ------------------------------------------------------------------------------------------------
// Initialisation des propriétés de la carte. Executé lorsque la carte est prète
JobsDirectory.prototype.onMapLoad = function()
{
	this.beginUpdate();
	// Initialisation images pour les marqueurs
	this.geoMap.setSingleMarkUrl(0, 'http://' + this.ndd + markerSingle);
	this.geoMap.setSingleMarkHighlighUrl(0, 'http://' + this.ndd + markerSingleHighlight);
	this.geoMap.setMultipleMarkUrl('http://' + this.ndd + markerMultiple);
	this.geoMap.setMultipleMarkHighlightUrl('http://' + this.ndd + markerMultipleHighlight);

	// Gestion du zoom
	if (this.dZoom == null)
	{
		this.dZoom = new DragZoomControl({
			nOpacity:.2,
			sBorder:"2px solid red"
		},{
			buttonHTML:"<img width='32' height='32' src='http://" + this.ndd + "/api2/pictures/geozoom.gif' />",
			buttonZoomingHTML:"<img width='32' height='32' src='http://" + this.ndd + "/api2/pictures/geozoom+.gif' />",
			buttonStartingStyle:{
				width:'32px',
				height:'32px'
			},
			buttonStyle:{
				background:''
			},
			overlayRemoveTime:1000,
			stickyZoomEnabled:false,
			wantZoom:true
		},{});
		this.geoMap.GMap.addControl(this.dZoom, new GControlPosition(G_ANCHOR_TOP_LEFT, new GSize(60,12)));
	}


	// lecture de la position sur la carte dans un cookie
	if (readCookie("SavePosition") == 'true') {
		var centerLat = readCookie("centerLat");
		var centerLng = readCookie("centerLng");
		var zoom = readCookie("zoom");
		var scrollTop = readCookie("scrollTop");

		this.geoMap.GMap.setCenter(new GLatLng(centerLat, centerLng), parseInt(zoom));

		document.documentElement.scrollTop = scrollTop;

		writeCookie("SavePosition", 'false');

		this.hasMoved = false;

		this.computeMap(false);
	}
	else
	{
		this.computeMap(true);
	}

	// on ajoute ces évènements seulement maintenant pour ne pas qu'ils soient déclenchés pdt la préparation de la carte
	GEvent.addListener(this.geoMap.GMap, 'moveend', bindMethod(this, this.onMapMoveEnd));
	GEvent.addListener(this.geoMap.GMap, 'zoomend', bindMethod(this, this.onMapZoomEnd));

	this.geoMap.GMap.checkResize();

	var css = document.createElement("link");
	css.setAttribute("href","http://" + this.ndd + "/api2/styles/jobsAPI.css");
	css.setAttribute("rel","stylesheet");
	css.setAttribute("type","text/css");
	css.setAttribute("media","all");
	if (document.getElementsByTagName("head")[0])
		document.getElementsByTagName("head")[0].insertBefore(css, document.getElementsByTagName("head")[0].firstChild);
	else
		alert("ERREUR : Le document de contient pas de section <HEAD>.\nLa feuille de style annuaireAPI.css n'a pas pu etre appliquee.")

	this.endUpdate();
}

// ------------------------------------------------------------------------------------------------
// Exécuté à la fin d'un mouvement panoramique
JobsDirectory.prototype.onMapMoveEnd = function()
{
	if (this.updating)
		return;

	this.hasMoved = true; // pour la gestion des cookies
	if (!this.geoMap.GMap.IsMegaWindowVisible() && !this.geoMap.isViewPortInCache())
		this.computeMap(false);
}

// ------------------------------------------------------------------------------------------------
// Exécuté après un zoom
JobsDirectory.prototype.onMapZoomEnd = function()
{
	if (this.updating)
		return;

	this.computeMap(false);
}

// ------------------------------------------------------------------------------------------------
// Exécuté lors d'une recherche
JobsDirectory.prototype.onSearchSubmit = function() {
	this.loadResultList();
	this.computeMap(true);
	return false;
}
// ------------------------------------------------------------------------------------------------
// Evt exécuté lorsqu'on clique sur un marqueur
JobsDirectory.prototype.onMarkerClick = function(marker)
{
	if ((marker == this.megaWindowMarker) && (this.geoMap.GMap.IsMegaWindowVisible())) {
		this.geoMap.GMap.HideMegaWindow();
		this.megaWindowMarker = null;
		return;
	}
	if (marker.Weight > 1)
		if (useMegaWindow)
		{ // marqueur mutliple avec l'utilisation des megawindow
			var zone = markerRawBounds[marker.ID].split("|");
			marker.GeoMap.GMap.ShowMegaWindowAndPan(marker, "Chargement...", bindMethod(this, this.onMWZoomClick), bindMethod(this, this.onMWCloseClick), 0, 0.2, 0.8, 1);
			var params = '';
			if (this.categoryField) {
				params = '%26SearchName=' + jQuery("#" + this.nameField).val() +
				'%26SearchLoc=' + jQuery("#" + this.locationField).val() +
				'%26SearchLocRadius=' + jQuery("#" + this.locationRadiusField).val();
			} else {
				params = '%26SearchName=%26SearchLoc=%26SearchLocRadius=';
			}
			CrossDomainCall('http://' + this.ndd + '/api2/jobs/f/GetListForMegaWindow.js-Key=' + this.clefContratAPIRES +
				'%26Lng1=' + (parseFloat(zone[0])-0.000001) +
				'%26Lat1=' + (parseFloat(zone[1])-0.000001) +
				'%26Lng2=' + (parseFloat(zone[2])+0.000001) +
				'%26Lat2=' + (parseFloat(zone[3])+0.000001) +
				params +
				'%26AnnuaireID=' + this.id);
			this.megaWindowMarker = marker;
		} else { // marqueur mutliple sans l'utilisation des megawindow
			this.zoomOnMarker(marker);
		} else {
			if (this.targetBlank) {
				window.open(markerURLs[marker.ID]);
			} else {
				this.saveMapBounds();
				document.location.href = markerURLs[marker.ID];
			}
	}
}

// ------------------------------------------------------------------------------------------------
// Evt exécuté lorsqu'on clique sur le bouton de zoom de la mega window
JobsDirectory.prototype.onMWZoomClick = function()
{
	if (this.megaWindowMarker)
	{
		this.zoomOnMarker(this.megaWindowMarker);
		this.megaWindowMarker = null;
	}
}

// ------------------------------------------------------------------------------------------------
// Evt exécuté lorsqu'on clique sur le bouton de fermeture de la mega window
JobsDirectory.prototype.onMWCloseClick = function()
{
	this.geoMap.GMap.HideMegaWindow();
	this.megaWindowMarker = null;
}

// ------------------------------------------------------------------------------------------------
// Mise à jour de la carte
// param recrop : spécifie s'il faut recadrer la carte
JobsDirectory.prototype.computeMap = function(recrop)
{
	// vérifie que la carte a bougée
	if ((this.mLeft == this.geoMap.getCoordLeft())
		&& (this.mRight == this.geoMap.getCoordRight())
		&& (this.mTop == this.geoMap.getCoordTop())
		&& (this.mBottom == this.geoMap.getCoordBottom())
		&& !recrop)
		return;

	// Définie la taille du cache et recalcule les coordonnées du cache
	this.geoMap.setCacheSize( 1.0 / 4, 1.0 / 4);

	this.mLeft = this.geoMap.getCoordLeft();
	this.mRight = this.geoMap.getCoordRight();
	this.mTop = this.geoMap.getCoordTop();
	this.mBottom = this.geoMap.getCoordBottom();
	var params = '';
	if (this.categoryField) {
		params = '%26SearchName=' + jQuery("#" + this.nameField).val() +
		'%26SearchLoc=' + jQuery("#" + this.locationField).val() +
		'%26SearchLocRadius=' + jQuery("#" + this.locationRadiusField).val();
	} else {
		params = '%26SearchName=%26SearchLoc=%26SearchLocRadius=';
	}
	CrossDomainCall('http://' + this.ndd + '/api2/jobs/f/DisplayMap.js-Key=' + this.clefContratAPIRES +
		'%26Lng1=' + this.geoMap.getCoordLeft() +
		'%26Lat1=' + this.geoMap.getCoordTop() +
		'%26Lng2=' + this.geoMap.getCoordRight() +
		'%26Lat2=' + this.geoMap.getCoordBottom() +
		'%26Recrop=' + (recrop?'true':'false') +
		'%26IDCarte=' + this.geoMap.IDGMap +
		'%26Width=' + jQuery("#"+this.mapDiv).width() +
		'%26Height=' + jQuery("#"+this.mapDiv).height() +
		'%26DivX=' + this.geoMap.maxX +
		'%26DivY=' + this.geoMap.maxY +
		'%26Weight=' + this.lastWeight +
		'%26MaxWeight=' + this.maxWeight +
		'%26CacheX=' + this.geoMap.CacheX +
		'%26CacheY=' + this.geoMap.CacheY +
		'%26NDD=' + this.ndd +
		params +
		'%26AnnuaireID=' + this.id);
}

// ------------------------------------------------------------------------------------------------
// Charge la liste des résultats (liste sous forme de texte)
//JobsDirectory.prototype.loadResultList = function(order, randOffset, page)
//{
//	if (this.textDiv) {
//
//		this.mLeft = this.geoMap.getCoordLeft();
//		this.mRight = this.geoMap.getCoordRight();
//		this.mTop = this.geoMap.getCoordTop();
//		this.mBottom = this.geoMap.getCoordBottom();
//		var urlComplement = '';
//		if (order != undefined) {urlComplement = '%26orderBy=' + order;}
//		if (randOffset != undefined) {urlComplement += '%26randOffset=' + randOffset;}
//		if (page != undefined) {urlComplement += '%26page=' + page;}
//		this.textDiv.innerHTML = '<p style="text-align:center; padding-top: ' + ((jQuery(this.textDiv).height() -20) / 2) + 'px;"><img src="http://' + this.ndd + '/api2/pictures/loading.gif" border="0" alt=""/> Chargement...</p>';
//		var params = '';
//		if (this.categoryField) {
//			params = '%26SearchName=' + jQuery("#" + this.nameField).val();
//			params += '%26SearchLoc=' + jQuery("#" + this.locationField).val();
//			params += '%26SearchLocRadius=' + jQuery("#" + this.locationRadiusField).val();
//		} else {
//			params = '%26SearchName=%26SearchLoc=%26SearchLocRadius=';
//		}
//		CrossDomainCall('http://' + this.ndd + '/api2/resoeco/f/GetSearchResultList.js-Key=' + this.clefContratAPIRES +
//			'%26Lng1=' + this.geoMap.getCoordLeft() +
//			'%26Lat1=' + this.geoMap.getCoordTop() +
//			'%26Lng2=' + this.geoMap.getCoordRight() +
//			'%26Lat2=' + this.geoMap.getCoordBottom() +
//			'%26IDCarte=' + this.geoMap.IDGMap +
//			'%26Width=' + jQuery("#"+this.mapDiv).width() +
//			'%26Height=' + jQuery("#"+this.mapDiv).height() +
//			'%26DivX=' + this.geoMap.maxX +
//			'%26DivY=' + this.geoMap.maxY +
//			'%26Weight=' + this.lastWeight +
//			'%26MaxWeight=' + this.maxWeight +
//			'%26CacheX=' + this.geoMap.CacheX +
//			'%26CacheY=' + this.geoMap.CacheY +
//			'%26NDD=' + this.ndd +
//			params +
//			'%26AnnuaireID=' + this.id + urlComplement);
//	}
//}

// ------------------------------------------------------------------------------------------------
// zoom sur la zone correspondant à un marqueur regroupé
// param marker : le marqueur sur lequel zoomer
// TODO utiliser le paramètre marker. LastMark sera sans doute à supprimer dans tout le doc
JobsDirectory.prototype.zoomOnMarker = function(marker)
{
	if (marker) {
		this.geoMap.GMap.HideTooltip();
		this.geoMap.GMap.HideMegaWindow();
		// ajoute un peu de marge pour ne pas que les marqueurs soient trop au bord
		var deltaLat = (marker.Bounds.getNorthEast().lat() - marker.Bounds.getSouthWest().lat()) / 8.0;
		var deltaLng = (marker.Bounds.getNorthEast().lng() - marker.Bounds.getSouthWest().lng()) / 8.0;
		var bounds = new GLatLngBounds(	new GLatLng(marker.Bounds.getSouthWest().lat() - deltaLat, marker.Bounds.getSouthWest().lng() - deltaLng),
			new GLatLng(marker.Bounds.getNorthEast().lat() + deltaLat, marker.Bounds.getNorthEast().lng() + deltaLng));
		// Positionne le zoom et recentre la carte
		this.beginUpdate();
		this.geoMap.GMap.setCenter(marker.Bounds.getCenter(), this.geoMap.GMap.getBoundsZoomLevel(bounds));
		this.endUpdate();
		this.lastWeight = marker.Weight;
		// charge les marqueurs
		this.computeMap(false);
	}
}

// ------------------------------------------------------------------------------------------------
// Sauve les coordonnées de la carte dans un cookie
JobsDirectory.prototype.saveMapBounds = function()
{
	if (this.hasMoved) { // seulement si la carte a bougé
		writeCookie("SavePosition", 'true');
		writeCookie("centerLat", this.geoMap.GMap.getCenter().lat());
		writeCookie("centerLng", this.geoMap.GMap.getCenter().lng());
		writeCookie("zoom", this.geoMap.GMap.getZoom());
		writeCookie("scrollTop", document.documentElement.scrollTop);
	}
}

// ************************************************************************************************
// ************************************************************************************************
// ***      Méthodes globales
// ************************************************************************************************
// ************************************************************************************************

// ------------------------------------------------------------------------------------------------
// Supprime tous les marqueurs. Fonction exécutée en retour d'un appel cross-domain
// param annuaireID : l'annuaire à l'origine de cet appel
function RemoveMarkers(annuaireID)
{
	var annuaire = annuaires[annuaireID];
	if (annuaire)
	{
		annuaire.geoMap.DeleteMarkers();
	}
}

// ------------------------------------------------------------------------------------------------
// Met à jours les marqueurs. Fonction exécutée en retour d'un appel cross-domain
// param annuaireID : l'annuaire à l'origine de cet appel
//       jsonData : flux JSON contenant les marqueurs
//       recrop : specifie s'il faut recadrer la carte sur les marqueurs
//       displayNbResults : appelle ou pas à UpdateSearchResult
//       scriptID : id du script créé par l'appel cross-domain
function UpdateMarkers(annuaireID, jsonData, recrop, displayNbResults, scriptID)
{
	var annuaire = annuaires[annuaireID];
	if (annuaire)
	{
		// on commence par supprimer tous les marqueurs existants
		annuaire.geoMap.DeleteMarkers();
		markerURLs = Array();
		var resCount = 0;
		var data;
		if (jsonData.Markers)
		{
			if (recrop && jsonData.Markers.length > 0)
			{
				var bounds = new GLatLngBounds();
				for (i = 0; i < jsonData.Markers.length; i++)
				{
					data = jsonData.Markers[i];
					if (data.Type == 'R')
					{
						var zone = data.Zone.split("|");
						bounds.extend(new GLatLng(zone[1], zone[0]));
						bounds.extend(new GLatLng(zone[3], zone[2]));
					//if (data.Poids == '7')
					//annuaire.geoMap.AddPoly(zone[0], zone[1], zone[2], zone[3], "#0000ff", "#aaaaff", 0);
					}
					else
					{
						bounds.extend(new GLatLng(data.Lat, data.Lng));
					}
				}
				// on ajoute des marges (25% : 12.5% de chaque côté) pour ne pas que les marqueurs ne se trouvent trop
				// près des bords de la carte
				var deltaLat = (bounds.getNorthEast().lat() - bounds.getSouthWest().lat()) / 8.0;
				var deltaLng = (bounds.getNorthEast().lng() - bounds.getSouthWest().lng()) / 8.0;
				bounds.extend(new GLatLng(bounds.getNorthEast().lat() + deltaLat, bounds.getNorthEast().lng() + deltaLng));
				bounds.extend(new GLatLng(bounds.getSouthWest().lat() - deltaLat, bounds.getSouthWest().lng() - deltaLng));
				// on ne veut pas que ce deplacement/zoom de la carte provoque une màj des marqueurs
				annuaire.beginUpdate();
				annuaire.geoMap.GMap.setCenter(bounds.getCenter(), annuaire.geoMap.GMap.getBoundsZoomLevel(bounds));
				annuaire.geoMap.setCacheSize( 1.0 / 4, 1.0 / 4);
				annuaire.endUpdate();
			}
			for (i = 0; i < jsonData.Markers.length; i++)
			{
				data = jsonData.Markers[i];
				resCount += parseInt(data.Poids);
				var tooltip;
				if (data.Poids > 1)
				{
					markerRawBounds[data.ID] = data.Zone; // on stocke ca pour eviter des problèmes d'arrondis avec GLatLngBounds
					tooltip = '<div style="width:200px;"><p><b>Cliquez pour consulter le<br/>d&eacute;tail de ' + data.Poids + ' annonces d\'emploi</b></p></div>';
				}
				else
				{
					tooltip = '<div style="width:350px">'+
					'<span class="tooltipEltTitle">' + data.Titre + '</span><br /><span class="tooltipEltBody">' + data.Contrat + ' - ' + data.Lieu +
					'<br />Recruteur' + data.Recruteur + '</span>' +
					'<p class="xsmall"><b>Cliquez sur le symbole <img src="http://' + annuaire.ndd + markerSingleHighlight + '" alt="" style="vertical-align:middle;"/> pour consulter la fiche<b></p>';
					markerURLs[data.ID] = data.URL;
				}
				annuaire.geoMap.AddMark(data.ID, data.Lat, data.Lng, data.Poids, data.Zone, 0, tooltip);
			}
			annuaire.geoMap.DisplayMarks();
		}

		if (displayNbResults)
		{
			if (resCount > 1)
				UpdateSearchResult(annuaireID, resCount + " entreprises trouv&eacute;es");
			else if (resCount > 0)
				UpdateSearchResult(annuaireID, "1 entreprise trouv&eacute;e");
			else
				UpdateSearchResult(annuaireID, "Aucune entreprise trouv&eacute;e");
		}
	}
	// on supprime l'objet <script> créé par la fonction CrossDomainCall()
	if (scriptID && (scriptID != ''))
		jQuery("#" + scriptID).remove();
}

// ------------------------------------------------------------------------------------------------
// Met à jours la liste des résultats. Fonction exécutée en retour d'un appel cross-domain
// param annuaireID : l'annuaire à l'origine de cet appel
//       jsonData : flux JSON contenant le détail des entreprises
//       scriptID : id du script créé par l'appel cross-domain
function UpdateResultList(annuaireID, jsonData, scriptID)
{
//	var annuaire = annuaires[annuaireID];
//	if (annuaire)
//	{
//		var sortName = '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.sortName + ', ' + '0 , 1);return false;">Nom' + jsonData.sortNameImg + '</a>';
//		var sortDomain = '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.sortDomain + ', ' + '0 , 1);return false;">Domaine d\'activit&eacute;' + jsonData.sortDomainImg + '</a>';
//		var sortLocation = '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.sortLocation + ', ' + '0 , 1);return false;">Localit&eacute;' + jsonData.sortLocationImg + '</a>';
//		var page = parseInt(jsonData.page);
//		var nbPages = parseInt(jsonData.nbPages);
//		var html = '<table style="width:100%"><tr><td>';
//		if (jsonData.nbRes > 0) {
//			html += 'R&eacute;sultats ' + jsonData.resMin + '-' + jsonData.resMax + ' sur ' + jsonData.nbRes;
//		} else {
//			html += 'Aucun r&eacute;sultat';
//		}
//		html += '</td><td style="text-align:right;padding-right:20px;">Trier par ' + sortName + ' - ' + sortDomain + ' - ' + sortLocation + '</td></tr></table>' +
//			'<hr/><div id="divResultList" style="height:'+annuaire.resultListHeight+'px">';
//		var ent, url, i;
//		for (i in jsonData.Ents) {
//			ent = jsonData.Ents[i];
//			if (typeof ent.url != "undefined") {
//				url = ent.url;
//				html += '<table class="resultContainer ' + ((i % 2 == 0) ? 'resultEven' : 'resultOdd') + '" style="text-align:left;width:100%;*width:99%"><tr><td style="width:60%;">' +
//					'<a href="' + url + '"' + (annuaire.targetBlank ? ' target="_blank"' : '') + '>' + ent.name + '</a></td><td style="width: 30%">' + ent.type + '</td></td><td rowspan="2" style="width:10%;text-align:center;">' +
//					'<a href="' + url + '"' + (annuaire.targetBlank ? ' target="_blank"' : '') + ' title="Consulter la fiche"><img src="' + ent.img + '" alt="Consulter la fiche"/></a></td></tr><tr><td>' +
//					ent.cat + '</td><td>' + ent.loc + '</td></tr></table>';
//			}
//		}
//		html += '</div><hr/>';
//		if (nbPages > 1) {
//			html += '<div class="divBrowseControls">';
//			if (page > 2) {
//				html += '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.order + ', ' + jsonData.randOffset + ', 1);return false;"><span class="browseLinkPicture"><img src="http://' + annuaire.ndd + '/api2/pictures/resultset-first.gif" border="0"></span></a>';
//			}
//			if (page > 1) {
//				html += '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.order + ', ' + jsonData.randOffset + ', ' + (page - 1) + ');return false;"><span class="browseLinkPicture"><img src="http://' + annuaire.ndd + '/api2/pictures/resultset-previous.gif" border="0"></span></a>';
//			}
//
//			var firstPageLink = Math.max(1, page - Math.floor(maxLinkCount / 2));
//			var lastPageLink = Math.min(nbPages, firstPageLink + maxLinkCount - 1);
//			firstPageLink = Math.max(1, lastPageLink - maxLinkCount + 1);
//			for (i = firstPageLink; i <= lastPageLink; i++)
//				if (i == page)
//					html += '<span class="browseLinkNumber">' + i + '</span> ';
//				else
//					html += '<a  href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.order + ', ' + jsonData.randOffset + ', ' + i + ');return false;"><span class="browseLinkNumber">' + i + '</span></a> ';
//
//			if (page < nbPages) {
//				html += '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.order + ', ' + jsonData.randOffset + ', ' + (page + 1) + ');return false;"><span class="browseLinkPicture"><img src="http://' + annuaire.ndd + '/api2/pictures/resultset-next.gif" border="0"></span></a>';
//			}
//			if (page < nbPages - 1) {
//				html += '<a href="" onclick="searchClick(' + annuaireID + ', ' + jsonData.order + ', ' + jsonData.randOffset + ', ' + nbPages + ');return false;"><span class="browseLinkPicture"><img src="http://' + annuaire.ndd + '/api2/pictures/resultset-last.gif" border="0"></span></a>';
//			}
//
//			html += '</div>';
//		}
//		annuaire.textDiv.innerHTML = html;
//
//		jQuery(".resultContainer td", annuaire.textDiv).bind('mouseenter',
//				function(){
//					jQuery(".resultHover").removeClass("resultHover");
//					jQuery(this).parents("table:first").addClass("resultHover");
//				}
//			).bind('mouseleave',function(){jQuery(this).parents("table:first").removeClass("resultHover")});
//	}
//	// on supprime l'objet <script> créé par la fonction CrossDomainCall()
//	if (scriptID && (scriptID != ''))
//		jQuery("#" + scriptID).remove();
}

// ------------------------------------------------------------------------------------------------
// Met à jours le contenu de la bulle "megawindow". Fonction exécutée en retour d'un appel cross-domain
// param annuaireID : l'annuaire à l'origine de cet appel
//       jsonData : flux JSON contenant le détail des entreprises
//       scriptID : id du script créé par l'appel cross-domain
function UpdateMegaWindow(annuaireID, jsonData, scriptID)
{
	var annuaire = annuaires[annuaireID];
	if (annuaire && jsonData.Jobs) {
		var codeHTML = '';
		for (i = 0; i < jsonData.Jobs.length; i++)
		{
			var data = jsonData.Jobs[i];

			codeHTML += '<div class="DivOff" id="company' + data.ID + '"';
			if (jQuery.browser.msie)
				codeHTML += 'onmouseleave="jQuery(\'#company'+data.ID+'\').attr(\'class\', \'DivOff\');" ';
			else
				codeHTML += 'onmouseout="jQuery(\'#company'+data.ID+'\').attr(\'class\', \'DivOff\');" ';
			codeHTML += 'onmouseover="jQuery(\'#company'+data.ID+'\').attr(\'class\', \'DivOn\');">';
			codeHTML += ' <div style="width:1000px;padding: 5px">';
			codeHTML += '  <a href="' + data.URL + '"' + (annuaire.targetBlank ? ' target="_blank"' : ' onclick="SaveMapBounds()"') + ' title="' + data.Titre + '"><span class="tooltipEltTitle">' + data.Titre + '</span></a><br /><span class="tooltipEltBody">';
			codeHTML += data.Contrat + ' - ' + data.Lieu + '<br/>Recruteur : ' + data.Recruteur + '</span></div></div>';

		}
		if (jsonData.PlusDeResultats) {
			codeHTML += '<div style="padding:6px; text-align:right;"><a href="javascript:MegaWindowZoomClick()" title="Zoomer">Zoomer pour plus de r&eacute;sultats</a></div>';
		}
		annuaire.geoMap.GMap.UpdateMegaWindowInnerHTML(codeHTML);
	}
	// on supprime l'objet <script>
	if (scriptID && (scriptID != ''))
		jQuery("#" + scriptID).remove();
}

// ------------------------------------------------------------------------------------------------
// Met à jour le message de resultat de recherche pour un annuaire donné
function UpdateSearchResult(annuaireID, msg)
{
//jQuery("#spanResultSearchMessage" + annuaireID).html(msg);
}

// ----------------------------------------------------------------------------------------------------------------------
// sauvegarde l'état de la carte dans un cookie
function SaveMapBounds() {
	for (var i = 0; i < annuaires.length; i++)
	{
		annuaires[i].saveMapBounds();
	}
}

// ---------------------------------------------------------------------------------------------------------------------
// Effectue une nouvelle recherche
function searchClick(annuaireID, order, randOffset, page) {
	var annuaire = annuaires[annuaireID];
	if (annuaire) {
		annuaire.loadResultList(order, randOffset, page);
	}
}

/**
* Callback appelée après un changement de catégorie.
* Les sous catégories sont mises à jour.
* @param {JSON} json les sous-catégories
* @param targetId id du <select> cible
* @param scriptID id du script pour le supprimer en fin d'exécution
*/
function updateSubCatList(json, targetId, scriptID)
{
//	var options = '<option value="-1"></option>';
//	for (var i = 0; i < json.length; i++)
//		options += '<option value="' + json[i].c + '">' + json[i].n + '</option>';
//	jQuery("#"+targetId).html(options);
//
//	// on supprime l'objet <script>
//	if (scriptID && (scriptID != ''))
//		jQuery("#" + scriptID).remove();
}// (C)opyright N-Gine Innovation 2008 - Tous droits réservés
// http://www.ngine-innovation.com
// source : http://www.actulab.com/les-cookies-en-javascript.php
// fichier créé le 12/09/2008 par m.c.

// ---------------------------------------------------------------------------------------------
// la fonction writeCookie, écrit un cookie. Elle permet de définir les attributs du cookie (expire, path, domaine, secure).
// S'il ne sont pas spécifiés, elle positionne les attributs optionnels à leur valeur par défaut.
function writeCookie(nom, valeur)
{
	var argv = writeCookie.arguments;
	var argc = writeCookie.arguments.length;
	var expires = (argc > 2) ? argv[2] : null;
	var path = (argc > 3) ? argv[3] : null;
	var domain = (argc > 4) ? argv[4] : null;
	var secure = (argc > 5) ? argv[5] : false;
	document.cookie = nom + "=" + escape(valeur) +
	((expires==null) ? "" : ("; expires="+expires.toGMTString())) +
	((path==null) ? "" : ("; path="+path)) +
	((domain==null) ? "" : ("; domain="+domain)) +
	((secure==true) ? "; secure" : "");
}

// ----------------------------------------------------------------------------------------------
// La fonction readCookie, retourne la valeur du cookie demandé, en utilisant la fonction getCookieVal.
// Si ce cookie n'existe pas, la fonction readCookie retourne la valeur null.
function getCookieVal(offset)
{
	var endstr=document.cookie.indexOf (";", offset);
	if (endstr==-1) endstr=document.cookie.length;
	return unescape(document.cookie.substring(offset, endstr));
}

function readCookie(nom)
{
	var arg = nom + "=";
	var alen = arg.length;
	var clen = document.cookie.length;
	var i = 0;
	while (i < clen)
	{
		var j = i + alen;
		if (document.cookie.substring(i, j) == arg) return getCookieVal(j);
		i = document.cookie.indexOf(" ",i)+1;
		if (i == 0) break;
	}
	return null;
}

// --------------------------------------------------------------------------------------------------
// La fonction removeCookie, utilise la fonction writeCookie. Pour effacer efficacement un cookie il faut:
//   - lui donner la valeur null,
//   - lui donner une date d'expiration située dans le passée.
// La raison pour laquelle les deux actions sont nécessaires tient au fait que la date d'expiration ne sera
// modifiée qu'à la fermeture du navigateur. Attribuer la valeur null au cookie permet de le tester correctement
// pendant la session du navigateur en cours, et revient donc à l'effacer virtuellement.
function removeCookie(nom)
{
	date = new Date;
	date.setFullYear(date.getFullYear() - 1);
	EcrireCookie(nom, null, date);
}/*
* DragZoomControl Class
*  Copyright (c) 2005-2007, Andre Lewis, andre@earthcode.com
*
* Back Button functionality
*  Copyright (c)  2007, Richard Garland, papabear.newyork@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*       http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This class lets you add a control to the map which will let the user
*  zoom by dragging a rectangle.
*  More info on original GZoom at http://earthcode.com
*
* Back Button functionality provides the user with a one click means to return the map state
*  to its state prior to the DragZoom.  Sequential DragZooms are backed out in reverse order.
*/

/**
 * Constructor for DragZoomControl, which takes 3 option hashes and
 *  uses them to customize the control.
 * @param {opts_boxStyle} Named optional arguments:
 *   opts_boxStyle.opacity {Number} Opacity from 0-1
 *   opts_boxStyle.fillColor {String} Hex value of fill color
 *   opts_boxStyle.border {String} CSS-style declaration of border
 * @param {opts_other} Named optional arguments:
 *   opts_other.buttonHTML {String} The zoom button HTML in non-activated state
 *   opts_other.buttonStartingStyle {Object} A hash of css styles for the
 *     zoom button which are common to both un-activated and activated state
 *   opts_other.buttonStyle {Object} A hash of css styles for the zoom button
 *     which will be applied when the button is in un-activated state.
 *   opts_other.buttonZoomingHTML {String} HTML which is placed in the
 *     zoom button when the button is activated.
 *   opts_other.buttonZoomingStyle {Object} A hash of css styles for the
 *    zoom button which will be applied when the button is activated.
 *   opts_other.overlayRemoveTime {Number} The number of milliseconds to wait before
 *     removing the rectangle indicating the zoomed-in area after the zoom has happened.
 *   opts_other.stickyZoomEnabled {Boolean} Whether or not the control stays in
 *     "zoom mode" until turned off. When true, the user can zoom repeatedly,
 *     until clicking on the zoom button again to turn zoom mode off.
 *   opts_other.backButtonEnabled {Boolean} enables Back Button functionality
 *   opts_other.backButtonHTML {String} The back button HTML
 *   opts_other.backButtonStyle {Object} A hash of css styles for the back button
 *     which will be applied when the button is created.
 * @param {opts_callbacks} Named optional arguments:
 *   opts_callbacks.buttonclick {Function} Called when the DragZoom is activated
 *     by clicking on the "zoom" button.
 *   opts_callbacks.dragstart {Function} Called when user starts to drag a rectangle.
 *     Callback args are x,y -- the PIXEL values, relative to the upper-left-hand
 *     corner of the map, where the user began dragging.
 *   opts_callbacks.dragging {Function} Called repeatedly while the user is dragging.
 *     Callback args are startX,startY, currentX,currentY -- the PIXEL values of the
 *     start of the drag, and the current drag point, respectively.
 *   opts_callbacks.dragend {Function} Called when the user releases the mouse button
 *     after dragging the rectangle. Callback args are: NW {GLatLng}, NE {GLatLng},
 *     SE {GLatLng}, SW {GLatLng}, NW {GPoint}, NE {GPoint}, SE {GPoint}, SW {GPoint}.
 *     The first 4 are the latitudes/longitudes; the last 4 are the pixel coords on the map.
 *   opts_callbacks.backbuttonclick {Function} Called when the back button is activated
 *     after the map context is restored. Callback args: methodCall (boolean) set true if
 *     this backbuttonclick was to restore context set by the mathod call, else false.
 * Method
 *    this.saveMapContext(text) Call to push map context onto the backStack and set the button text
 */
var CurrentZoomArea=null;
function DragZoomControl(opts_boxStyle, opts_other, opts_callbacks) {
  // Holds all information needed globally
  // Not all globals are initialized here
  this.globals = {
    draggingOn: false,
    cornerTopDiv: null,
    cornerRightDiv: null,
    cornerBottomDiv: null,
    cornerLeftDiv: null,
    mapPosition: null,
    outlineDiv: null,
    mapWidth: 0,
    mapHeight: 0,
    mapRatio: 0,
    startX: 0,
    startY: 0,
    borderCorrection: 0
  };

  //box style options
  this.globals.style = {
    opacity: .2,
    fillColor: "#000",
    border: "2px solid blue"
  };

  var style = this.globals.style;
  for (var s in opts_boxStyle) {
    style[s]=opts_boxStyle[s];
  }

  var borderStyleArray = style.border.split(' ');
  style.outlineWidth = parseInt(borderStyleArray[0].replace(/\D/g,''));
  style.outlineColor = borderStyleArray[2];
  style.alphaIE = 'alpha(opacity=' + (style.opacity * 100) + ')';

  // map context stack for back button
  this.globals.backStack = [];

  // Other options
  this.globals.options={
    buttonHTML: 'zoom ...',
    buttonStartingStyle:
      {width: '52px', border: '1px solid black', padding: '2px'},
    buttonStyle: {background: '#FFF'},
    backButtonHTML: 'zoom back',
    backButtonStyle: {background: '#FFF', display: 'none'},
    buttonZoomingHTML: 'Drag a region on the map',
    buttonZoomingStyle: {background: '#FF0'},
    overlayRemoveTime: 6000,
    backButtonEnabled: false,
    stickyZoomEnabled: false,
	wantZoom:true
  };

  for (var s in opts_other) {
    this.globals.options[s] = opts_other[s]
  }

  // callbacks: buttonclick, dragstart, dragging, dragend, backbuttonclick
  if (opts_callbacks == null) {
    opts_callbacks = {}
  }
  this.globals.callbacks = opts_callbacks;

}

DragZoomControl.prototype = new GControl();


/**
 * Back Button functionality:
 * Method of this object called to save the map context before the zoom.
 * @param {text} text string for the back button
 */
DragZoomControl.prototype.saveMapContext = function(text) {
  if (this.globals.options.backButtonEnabled) {
    this.saveBackContext_(text,true);
    this.globals.backButtonDiv.style.display = 'block';
  }
};


/**
 * Creates a new button to control gzoom and appends to the button container div.
 * @param {DOM Node} buttonContainerDiv created in main .initialize code
 */
DragZoomControl.prototype.initButton_ = function(buttonContainerDiv) {
  var G = this.globals;
  var buttonDiv = document.createElement('div');
  buttonDiv.innerHTML = G.options.buttonHTML;
  buttonDiv.id = 'gzoom-control';
  DragZoomUtil.style([buttonDiv], {cursor: 'pointer', zIndex:200});
  DragZoomUtil.style([buttonDiv], G.options.buttonStartingStyle);
  DragZoomUtil.style([buttonDiv], G.options.buttonStyle);
  buttonContainerDiv.appendChild(buttonDiv);
  return buttonDiv;
};

/**
 * Creates a second new button to control backup zoom and appends to the button container div.
 * @param {DOM Node} buttonContainerDiv created in main .initialize code
 */
DragZoomControl.prototype.initBackButton_ = function(buttonContainerDiv) {	//**BB** entire function
  var G = this.globals;
  var backButtonDiv = document.createElement('div');
  backButtonDiv.innerHTML = G.options.backButtonHTML;
  backButtonDiv.id = 'gzoom-back';
  DragZoomUtil.style([backButtonDiv], {cursor: 'pointer', zIndex:200});
  DragZoomUtil.style([backButtonDiv], G.options.buttonStartingStyle);
  DragZoomUtil.style([backButtonDiv], G.options.backButtonStyle);
  buttonContainerDiv.appendChild(backButtonDiv);
  return backButtonDiv;
};

/**
 * Sets button mode to zooming or otherwise, changes CSS & HTML.
 * @param {String} mode Either "zooming" or not.
 */
DragZoomControl.prototype.setButtonMode_ = function(mode){
  var G = this.globals;
  if (mode == 'zooming') {
    G.buttonDiv.innerHTML = G.options.buttonZoomingHTML;
    DragZoomUtil.style([G.buttonDiv], G.options.buttonStartingStyle);
    DragZoomUtil.style([G.buttonDiv], G.options.buttonZoomingStyle);
  } else {
    G.buttonDiv.innerHTML = G.options.buttonHTML;
    DragZoomUtil.style([G.buttonDiv], G.options.buttonStartingStyle);
    DragZoomUtil.style([G.buttonDiv], G.options.buttonStyle);
  }
};

/**
 * Is called by GMap2's addOverlay method. Creates the zoom control
 * divs and appends to the map div.
 * @param {GMap2} map The map that has had this DragZoomControl added to it.
 * @return {DOM Object} Div that holds the gzoomcontrol button
 */
DragZoomControl.prototype.initialize = function(map) {
  var G = this.globals;
  var me = this;
  var mapDiv = map.getContainer();

  // Create div for both buttons
    var buttonContainerDiv = document.createElement("div");
    DragZoomUtil.style([buttonContainerDiv], {cursor: 'pointer', zIndex: 150});

  // create and init the zoom button
    //DOM:button
    var buttonDiv = this.initButton_(buttonContainerDiv);

  // create and init the back button
    //DOM:button
    var backButtonDiv = this.initBackButton_(buttonContainerDiv);

  // Add the two buttons to the map
    mapDiv.appendChild(buttonContainerDiv);

  //DOM:map covers
    var zoomDiv = document.createElement("div");
    zoomDiv.id ='gzoom-map-cover';
    zoomDiv.innerHTML ='<div id="gzoom-outline" style="position:absolute;display:none;"></div><div id="gzoom-cornerTopDiv" style="position:relative;display:none;"></div><div id="gzoom-cornerLeftDiv" style="position:absolute;display:none;"></div><div id="gzoom-cornerRightDiv" style="position:absolute;display:none;"></div><div id="gzoom-cornerBottomDiv" style="position:absolute;display:none;"></div>';
    DragZoomUtil.style([zoomDiv], {position: 'relative', display: 'none', overflow: 'hidden', cursor: 'crosshair', zIndex: 101});
    mapDiv.appendChild(zoomDiv);

  // add event listeners
    GEvent.addDomListener(buttonDiv, 'click', function(e) {
      me.buttonclick_(e);
    });
    GEvent.addDomListener(backButtonDiv, 'click', function(e) {
      me.backButtonclick_(e);
    });
    GEvent.addDomListener(zoomDiv, 'mousedown', function(e) {
      me.coverMousedown_(e);
    });
    GEvent.addDomListener(document, 'mousemove', function(e) {
      me.drag_(e);
    });
    GEvent.addDomListener(document, 'mouseup', function(e) {
      me.mouseup_(e);
    });
    // Rajout du click
  GEvent.addDomListener(map, 'click', function(e, ptClicked) {
    me.mouseclick_(e, ptClicked);
  });
  GEvent.addDomListener(map, 'dragend', function(e) {
    me.dragend_(e);
  });
  // get globals
    G.mapPosition = DragZoomUtil.getElementPosition(mapDiv);
    G.outlineDiv = DragZoomUtil.gE("gzoom-outline");
    G.buttonDiv = DragZoomUtil.gE("gzoom-control");
    G.backButtonDiv = DragZoomUtil.gE("gzoom-back");
    G.mapCover = DragZoomUtil.gE("gzoom-map-cover");
    G.cornerTopDiv = DragZoomUtil.gE("gzoom-cornerTopDiv");
    G.cornerRightDiv = DragZoomUtil.gE("gzoom-cornerRightDiv");
    G.cornerBottomDiv = DragZoomUtil.gE("gzoom-cornerBottomDiv");
    G.cornerLeftDiv = DragZoomUtil.gE("gzoom-cornerLeftDiv");
    G.map = map;

    G.borderCorrection = G.style.outlineWidth * 2;
    this.setDimensions_();

  //styles
    this.initStyles_();
  return buttonContainerDiv;
};

/**
 * Required by GMaps API for controls.
 * @return {GControlPosition} Default location for control
 */
DragZoomControl.prototype.getDefaultPosition = function() {
  return new GControlPosition(G_ANCHOR_TOP_LEFT, new GSize(3, 120));
};
DragZoomControl.prototype.mouseclick_ = function(e, ptClicked){
  var G = this.globals;
  if (G.callbacks.click != null)
      G.callbacks.click( ptClicked);
};
DragZoomControl.prototype.dragend_ = function(e){
};

/**
 * Function called when mousedown event is captured.
 * @param {Object} e
 */
DragZoomControl.prototype.coverMousedown_ = function(e){
  var G = this.globals;
  var pos = this.getRelPos_(e);
  G.startX = pos.left;
  G.startY = pos.top;

  DragZoomUtil.style([G.mapCover], {background: 'transparent', opacity: 1, filter: 'alpha(opacity=100)'});
  DragZoomUtil.style([G.outlineDiv], {left: G.startX + 'px', top: G.startY + 'px', display: 'block', width: '1px', height: '1px'});
  G.draggingOn = true;

  G.cornerTopDiv.style.top = (G.startY - G.mapHeight) + 'px';
  G.cornerTopDiv.style.display ='block';
  G.cornerLeftDiv.style.left = (G.startX - G.mapWidth) +'px';
  G.cornerLeftDiv.style.top = G.startY + 'px';
  G.cornerLeftDiv.style.display = 'block';

  G.cornerRightDiv.style.left = G.startX + 'px';
  G.cornerRightDiv.style.top = G.startY + 'px';
  G.cornerRightDiv.style.display = 'block';
  G.cornerBottomDiv.style.left = G.startX + 'px';
  G.cornerBottomDiv.style.top = G.startY + 'px';
  G.cornerBottomDiv.style.width = '0px';
  G.cornerBottomDiv.style.display = 'block';

  // invoke the callback if provided
  if (G.callbacks.dragstart != null) {
    G.callbacks.dragstart(G.startX, G.startY);
  }

  return false;
};

/**z
 * Function called when drag event is captured
 * @param {Object} e
 */
DragZoomControl.prototype.drag_ = function(e){
  var G = this.globals;

  document.onselectstart = function() {
    return false;
  };

  if(G.draggingOn) {
    var pos = this.getRelPos_(e);
    rect = this.getRectangle_(G.startX, G.startY, pos, G.mapRatio);

    if (rect.left) {
      addX = -rect.width;
    } else {
      addX = 0;
    }

    if (rect.top) {
      addY = -rect.height;
    } else {
      addY = 0;
    }

    DragZoomUtil.style([G.outlineDiv], {left: G.startX + addX + 'px', top: G.startY + addY + 'px', display: 'block', width: '1px', height: '1px'});

    G.outlineDiv.style.width = rect.width + "px";
    G.outlineDiv.style.height = rect.height + "px";

    G.cornerTopDiv.style.height = ((G.startY + addY) - (G.startY - G.mapHeight)) + 'px';
    G.cornerLeftDiv.style.top = (G.startY + addY) + 'px';
    G.cornerLeftDiv.style.width = ((G.startX + addX) - (G.startX - G.mapWidth)) + 'px';
    G.cornerRightDiv.style.top = G.cornerLeftDiv.style.top;
    G.cornerRightDiv.style.left = (G.startX + addX + rect.width + G.borderCorrection) + 'px';
    G.cornerBottomDiv.style.top = (G.startY + addY + rect.height + G.borderCorrection) + 'px';
    G.cornerBottomDiv.style.left = (G.startX - G.mapWidth + ((G.startX + addX) - (G.startX - G.mapWidth))) + 'px';
    G.cornerBottomDiv.style.width = (rect.width + G.borderCorrection) + 'px';

    // invoke callback if provided
    if (G.callbacks.dragging != null) {
      G.callbacks.dragging(G.startX, G.startY, rect.endX, rect.endY)
    }

    return false;
  }
};

/**
 * Function called when mouseup event is captured
 * @param {Event} e
 */
DragZoomControl.prototype.mouseup_ = function(e){
  var G = this.globals;
  if (G.draggingOn) {
    var pos = this.getRelPos_(e);
    G.draggingOn = false;

    var rect = this.getRectangle_(G.startX, G.startY, pos, G.mapRatio);

    if (rect.left) rect.endX = rect.startX - rect.width;
    if (rect.top) rect.endY = rect.startY - rect.height;

    this.resetDragZoom_();

    var nwpx = new GPoint(rect.startX, rect.startY);
    var nepx = new GPoint(rect.endX, rect.startY);
    var sepx = new GPoint(rect.endX, rect.endY);
    var swpx = new GPoint(rect.startX, rect.endY);
    var nw = G.map.fromContainerPixelToLatLng(nwpx);
    var ne = G.map.fromContainerPixelToLatLng(nepx);
    var se = G.map.fromContainerPixelToLatLng(sepx);
    var sw = G.map.fromContainerPixelToLatLng(swpx);

    var zoomAreaPoly = new GPolyline([nw, ne, se, sw, nw], G.style.outlineColor, G.style.outlineWidth + 1,.4);
    CurrentZoomArea = zoomAreaPoly;
    try{
      G.map.addOverlay(zoomAreaPoly);
      if ( G.options.wantZoom)
        setTimeout (function() {G.map.removeOverlay(zoomAreaPoly)}, G.options.overlayRemoveTime);
    }catch(e) {}

    polyBounds = zoomAreaPoly.getBounds();
    var ne = polyBounds.getNorthEast();
    var sw = polyBounds.getSouthWest();
    var se = new GLatLng(sw.lat(), ne.lng());
    var nw = new GLatLng(ne.lat(), sw.lng());
    zoomLevel = G.map.getBoundsZoomLevel(polyBounds);
    center = polyBounds.getCenter();
    if ( G.options.wantZoom)
      G.map.setCenter(center, zoomLevel);
    else
      G.map.setCenter(center);

    // invoke callback if provided
    if (G.callbacks.dragend != null) {
      G.callbacks.dragend(nw, ne, se, sw, nwpx, nepx, sepx, swpx);
    }

    //re-init if sticky
    if (G.options.stickyZoomEnabled) {
      //GLog.write("stickyZoomEnabled, re-initting");
      this.initCover_();
      if (G.options.backButtonEnabled) this.saveBackContext_(G.options.backButtonHTML,false); // save the map context for back button
      G.backButtonDiv.style.display='none';
    }
  }
};

/**
 * Set the cover sizes according to the size of the map
 */
DragZoomControl.prototype.setDimensions_ = function() {
  var G = this.globals;
  var mapSize = G.map.getSize();
  G.mapWidth  = mapSize.width;
  G.mapHeight = mapSize.height;

  G.mapRatio  = G.mapHeight / G.mapWidth;
  DragZoomUtil.style([G.mapCover, G.cornerTopDiv, G.cornerRightDiv, G.cornerBottomDiv, G.cornerLeftDiv],
    {width: G.mapWidth + 'px', height: G.mapHeight +'px'});
};

/**
 * Initializes styles based on global parameters
 */
DragZoomControl.prototype.initStyles_ = function(){
  var G = this.globals;
  DragZoomUtil.style([G.mapCover, G.cornerTopDiv, G.cornerRightDiv, G.cornerBottomDiv, G.cornerLeftDiv],
    {filter: G.style.alphaIE, opacity: G.style.opacity, background:G.style.fillColor});
  G.outlineDiv.style.border = G.style.border;
};

/**
 * Function called when the zoom button's click event is captured.
 */
DragZoomControl.prototype.buttonclick_ = function(){
  var G = this.globals;
  G.backButtonDiv.style.display='none';
  if (G.mapCover.style.display == 'block') { // reset if clicked before dragging
    this.resetDragZoom_();
    if (G.options.backButtonEnabled) {
      this.restoreBackContext_();  // pop the backStack on a button reset
      if (G.backStack.length==0) G.backButtonDiv.style.display='none';
    }
  } else {
    this.initCover_();
    if ( G.options.backButtonEnabled ) this.saveBackContext_(G.options.backButtonHTML,false); // save the map context for back button
  }
};

/**
 * Back Button functionality:
 * Function called when the back button's click event is captured.
 * calls the function to set the map context back to where it was before the zoom.
 */
DragZoomControl.prototype.backButtonclick_ = function(){
  var G = this.globals;
  if (G.options.backButtonEnabled) {
    this.restoreBackContext_();
    // invoke the callback if provided
    if (G.callbacks['backbuttonclick'] != null) {
      G.callbacks.backbuttonclick(G.methodCall);
    }
  }
};

/**
 * Back Button functionality:
 * Saves the map context and pushes it on the backStack for later use by the back button
 */
DragZoomControl.prototype.saveBackContext_ = function(text,methodCall) {
  var G = this.globals;
  var backFrame = {};
  backFrame["center"] = G.map.getCenter();
  backFrame["zoom"] = G.map.getZoom();
  backFrame["maptype"] = G.map.getCurrentMapType();
  backFrame["text"] = G.backButtonDiv.innerHTML; // this saves the previous button text
  backFrame["methodCall"] = methodCall; //This determines if it was an internal or method call
  G.backStack.push(backFrame);
  G.backButtonDiv.innerHTML = text;
  // Back Button is turned on in resetDragZoom_()
};

/**
 * Back Button functionality:
 * Pops the previous map context off of the backStack and restores the map to that context
 */
DragZoomControl.prototype.restoreBackContext_ = function() {
  var G = this.globals;
  var backFrame = G.backStack.pop();
  G.map.setCenter(backFrame["center"],backFrame["zoom"],backFrame["maptype"]);
  G.backButtonDiv.innerHTML = backFrame["text"];
  G.methodCall = backFrame["methodCall"];
  if (G.backStack.length==0) G.backButtonDiv.style.display = 'none'; // if we're at the top of the stack, hide the back botton
};

/**
 * Shows the cover over the map
 */
DragZoomControl.prototype.initCover_ = function(){
  var G = this.globals;
  G.mapPosition = DragZoomUtil.getElementPosition(G.map.getContainer());
  this.setDimensions_();
  this.setButtonMode_('zooming');

  var mapSize = G.map.getSize();
  var h =  (mapSize.height -40)+ 'px';

//  DragZoomUtil.style([G.mapCover], {display: 'block', background: G.style.fillColor, top :'0px', height : h});
  DragZoomUtil.style([G.mapCover], {display: 'block', background: G.style.fillColor, top : '0px', position:'absolute', left:'0px'});
  DragZoomUtil.style([G.outlineDiv], {width: '0px', height: '0px'});

  //invoke callback if provided
  if(G.callbacks['buttonclick'] != null){
    G.callbacks.buttonclick();
  }

};

/**
 * Gets position of the mouse relative to the map
 * @param {Object} e
 */
DragZoomControl.prototype.getRelPos_ = function(e) {
  var pos = DragZoomUtil.getMousePosition(e);
  var G = this.globals;
  return {top: (pos.top - G.mapPosition.top),
          left: (pos.left - G.mapPosition.left)};
};

/**
 * Figures out the rectangle the user's trying to draw
 * @param {Number} startX
 * @param {Number} startY
 * @param {Object} pos
 * @param {Number} ratio
 * @return {Object} Describes the rectangle
 */
DragZoomControl.prototype.getRectangle_ = function(startX, startY, pos, ratio){
  var left = false;
  var top = false;
  var dX = pos.left - startX;
  var dY = pos.top - startY;
  if (dX < 0) {
    dX = dX * -1;
    left = true;
  }
  if (dY < 0) {
    dY = dY * -1;
    top = true;
  }
  delta = dX > dY ? dX : dY;

  return {
    startX: startX,
    startY: startY,
    endX:startX+dX,
    endY:startY+dY,
    width:dX,
    height: dY,

//    endX: startX + delta,
//    endY: startY + parseInt(delta * ratio),
//    width: delta,
//    height: parseInt(delta * ratio),
    left:left,
    top:top
  }
};

/**
 * Resets CSS and button display when drag zoom done
 */
DragZoomControl.prototype.resetDragZoom_ = function() {
  var G = this.globals;
  DragZoomUtil.style([G.mapCover, G.cornerTopDiv, G.cornerRightDiv, G.cornerBottomDiv, G.cornerLeftDiv],
    {display: 'none', opacity: G.style.opacity, filter: G.style.alphaIE});
  G.outlineDiv.style.display = 'none';
  this.setButtonMode_('normal');
  if (G.options.backButtonEnabled  && (G.backStack.length > 0)) G.backButtonDiv.style.display = 'block'; // show the back button
};



/* utility functions in DragZoomUtil.namespace */
var DragZoomUtil={};

/**
 * Alias function for getting element by id
 * @param {String} sId
 * @return {Object} DOM object with sId id
 */
DragZoomUtil.gE = function(sId) {
  return document.getElementById(sId);
}

/**
 * A general-purpose function to get the absolute position
 * of the mouse.
 * @param {Object} e  Mouse event
 * @return {Object} Describes position
 */
DragZoomUtil.getMousePosition = function(e) {
  var posX = 0;
  var posY = 0;
  if (!e) var e = window.event;
  if (e.pageX || e.pageY) {
    posX = e.pageX;
    posY = e.pageY;
  } else if (e.clientX || e.clientY){
    posX = e.clientX +
      (document.documentElement.scrollLeft ? document.documentElement.scrollLeft : document.body.scrollLeft);
    posY = e.clientY +
      (document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop);
  }
  return {left: posX, top: posY};
};

/**
 * Gets position of element
 * @param {Object} element
 * @return {Object} Describes position
 */
DragZoomUtil.getElementPosition = function(element) {
  var leftPos = element.offsetLeft;          // initialize var to store calculations
  var topPos = element.offsetTop;            // initialize var to store calculations
  var parElement = element.offsetParent;     // identify first offset parent element
  while (parElement != null ) {                // move up through element hierarchy
    leftPos += parElement.offsetLeft;      // appending left offset of each parent
    topPos += parElement.offsetTop;
    parElement = parElement.offsetParent;  // until no more offset parents exist
  }
  return {left: leftPos, top: topPos};
};

/**
 * Applies styles to DOM objects
 * @param {String/Object} elements Either comma-delimited list of ids
 *   or an array of DOM objects
 * @param {Object} styles Hash of styles to be applied
 */
DragZoomUtil.style = function(elements, styles){
  if (typeof(elements) == 'string') {
    elements = DragZoomUtil.getManyElements(elements);
  }
  for (var i = 0; i < elements.length; i++){
    for (var s in styles) {
      elements[i].style[s] = styles[s];
    }
  }
};

/**
 * Gets DOM elements array according to list of IDs
 * @param {String} elementsString Comma-delimited list of IDs
 * @return {Array} Array of DOM elements corresponding to s
 */
DragZoomUtil.getManyElements = function(idsString){
  var idsArray = idsString.split(',');
  var elements = [];
  for (var i = 0; i < idsArray.length; i++){
    elements[elements.length] = DragZoomUtil.gE(idsArray[i])
  };
  return elements;
};