// Profondeur de Zoom maximum qui affiche les points du trace du navire
    // Inférieur ou egal au chiffre défini ci dessous : les points s'affichent
    // Superieur : les points ne s'affichent pas
    var ZOOM_MAX = 4;
	
    // Profondeur de Zoom maximum qui affiche le dernier point de chaque navire
    // Inférieur ou egal au chiffre défini ci dessous : les points s'affichent
    // Superieur : les points ne s'affichent pas
    var ZOOM_MAX_ACCUEIL = 7;		
    
    // Tableau pour le trace du carroyage (utilisé pour createCarroyage et DeleteCarroyage)
    var tab_Polyline=[];
    var tab_LblLatLong=[];
           
    // Variable to keep a list of displayed markers
    var displayMarkers = new Array();
    
    // Référence globale sur la carte
    var mapRef;
    
    // Point centre de la carte lors d'un redimensionnement
    var myCenterPoint;
    
    
    // Largeur minimum de la carte et Largeur du bandeau entourant la carte
    var larg = 785;
    var bandeaularg = 210;
    
    // Hauteur minimum de la carte et Hauteur du bandeau entourant la carte
    var haut = 465;
    //var bandeauhaut = 165;
    var bandeauhaut = 200;
    
    
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                       Chargement d'une page                                                                            //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // typeMap         =>   Definit les parametres de la carte ( true : accueil / false : navire) 
    // latitudeSW     =>   Latitude du point Sud West de la carte
    // longitudeSW   =>   Longitude du point Sud West de la carte
    // latitudeNE      =>   Latitude du point Nord Est de la carte 
    // longitudeNE    =>   Longitude du point Nord Est de la carte
    // fileXML           =>   Fichier de donnees à telecharger sur le serveur 
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //   
    function LoadGMap(typeMap, latitudeSW, longitudeSW, latitudeNE, longitudeNE,  fileXML, intervalle)
    {
        if (GBrowserIsCompatible()) 
        {
                    if(!typeMap) ResizeMap();
                    
                    // Definition de la carte
                    this.map = new GMap2(document.getElementById("map"));
                    mapRef = this.map;

                    // Parametrage de la Map => centre, zoom
                    if (latitudeSW == null && longitudeSW == null && latitudeNE == null && longitudeNE == null && fileXML == "null")
                    { 
                        //Si aucun point n'est trouvé pour le(s) navire(s) et la date spécifiés
                        map.setCenter(new GLatLng(10,0));
                        map.setZoom(1);
                    } 
                    else
                    {
                            //Si des points sont trouvés pour le(s) navire(s) et la date spécifiés
                            // Calcul de l'amplitude et de la taille
                            latLngSW = new GLatLng(latitudeSW, longitudeSW);
                            latLngNE = new GLatLng(latitudeNE, longitudeNE);
                            amplitude = new GLatLngBounds(latLngSW, latLngNE);
                            
                            centerAmplitude = amplitude.getCenter();
                            map.setCenter(centerAmplitude); 
                            
                            //mapZoomLevel = map.getBoundsZoomLevel(amplitude, taille);
                            mapZoomLevel = map.getBoundsZoomLevel(amplitude);
                
                            // Verification du zoom en fonction du type de carte
                            map.setZoom(CheckLevelZoom(mapZoomLevel-1));
                             
                            delete mapZoomLevel;
                            mapZoomLevel = null;                                
                            delete taille;
                            taille =null;
                            delete centerAmplitude;
                            centerAmplitude = null;
                            delete latLngSW;
                            latLngSW = null;
                            delete latLngNE;
                            latLngNE = null;
                            delete amplitude;
                            amplitude = null;                
                   }

                    if (!typeMap)
                    {
                        // Si carte navire
                        SetMemorizedCenter(map); 
                        // Place le zoom si présent dans le champ caché
                        SetMemorizedZoom(map);
                    }

                    // Parametrage de la Map : mode, panel de chgt de vue, echelle
                    map.setMapType(G_HYBRID_MAP);        
                                        
                    gMapType = new GMapTypeControl();
                    map.addControl(gMapType);
                    delete gMapType;
                    
                    gScale = new GScaleControl();
                    map.addControl(gScale);
                    delete gScale;

                    // Affichage de la carte et actions possibles
                    DisplayMapOptions(map, typeMap, fileXML, intervalle);

                    // Useful for the "return to the last position"
                    map.savePosition();

                    // Creation du carroyage (uniquement pour les zooms supérieurs à 1)
                    if (map.getZoom() > 1) createCarroyage(map);

                    map = null;
            }
            else
            {
                alert("Désolé, l'API Google Maps n'est pas compatible avec votre navigateur.");
            }
    }; 

    function SetMemorizedCenter(mapRef)
    {
        //Positionnement du centre mémorisé si initialisé
        if (document.getElementById("uxTxtCenter").value != "")
        {
            var str_point = document.getElementById("uxTxtCenter").value.replace("(", "").replace(")","");
            point = new GLatLng(parseFloat(str_point.split(",")[0]),parseFloat(str_point.split(",")[1]));
            mapRef.setCenter(point);
            delete point;
            delete str_point;
        }
    } 

    function SetMemorizedZoom(mapRef)
    {
        // Positionnement du zoom mémorisé si initialisé
        if (document.getElementById("uxTxtZoom").value != "")
        {
            mapRef.setZoom(parseFloat(document.getElementById("uxTxtZoom").value));
        }
    }

    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                       Affichage des options de la carte                                                                //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // mapRef                       =>   La carte
    // mapTypeRef                =>   Definit les parametres de la carte ( true : accueil / false : navire) 
    // fileData                       =>   Fichier de donnees à telecharger sur le serveur e
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //       
    function DisplayMapOptions(mapRef, mapTypeRef, fileData, intervalle)
    {
        if(mapTypeRef)
        {        
            // Carte ACCUEIL => Pas de deplacement et de zoom
            mapRef.disableDragging();
            mapRef.disableDoubleClickZoom();
            
            if (fileData != "null")
            {
                // Affichage de la position actuelle des navires
                DisplayLastPointOfBoat(mapRef, fileData);
            } 
        }
        else
        {
            // Carte NAVIRE => Possibilite de deplacement et de Zoom 
            mapRef.enableDragging();
            mapRef.enableDoubleClickZoom();

            // Ajout du zoom et du deplacement
            mapRef.addControl(new GLargeMapControl());

            if (fileData != "null")
            {              
                // Affichage de la navigation des navires
                DisplayRoadMapOfBoat(mapRef, fileData, intervalle);
            }
            
            // Autorise l'utilisation de la roulette de la souris pour zoomer sur la carte
            mapRef.enableScrollWheelZoom();	                            

            // Definition de la minicarte
            ovcontrol = new GOverviewMapControl(new GSize(150, 150));
            
            mapRef.addControl(ovcontrol);
            
            // ======== get a reference to the GMap2 ===========
            ovmap = ovcontrol.getOverviewMap();

            // Position de la minicarte (OverView)
            setTimeout("positionOverview()", 1);
            
            //  ======== change the overview map type AFTER the overview finishes initializing =====
            setTimeout("ovmap.setMapType(G_HYBRID_MAP);delete ovmap;ovmap = null; ", 1);


            // On inscrit l'évenement "moveend" au gestionnaire d'evenement
            GEvent.addListener(mapRef, "zoomend", 
                function() 
                        {
                              document.getElementById("uxTxtZoom").value = mapRef.getZoom().toString(); 
                        }
            );
            
            // Mouvement de la carte : Retraçage du carroyage, mémorisation du centre de la carte
            GEvent.addListener(mapRef, "moveend", 
                function () 
                         {
                            // Blocage du zoom de 1 à 8
                            if (mapRef.getZoom() == 0)
                            {
                                mapRef.setZoom(1);
                            }
                            else
                            {
                                if (mapRef.getZoom() == 1)
                                {
                                    deleteCarroyage(mapRef);
                                }
                                else
                                {
                                    // Affichage du carroyage
                                    deleteCarroyage(mapRef);
                                    createCarroyage(mapRef);
                                }
                             }
                             //on affiche la valeur du centre dans un hiddenfield
                             document.getElementById("uxTxtCenter").value = mapRef.getCenter().toString();
                         }
            );                                                                            

            // Mouvement de la souris sur la carte : Affichage des coordonnées dans le textbox prévu
            GEvent.addListener(mapRef, "mousemove", 
                function (point) 
                                 {
                                     //on affiche la position du curseur de la souris en coordonnées angulaires
                                     document.getElementById("uxTxtLatitude").value = TransformDegreDecimalToDegreSexaDecimal(point.y.toString(),true);
                                     document.getElementById("uxTxtLongitude").value = TransformDegreDecimalToDegreSexaDecimal(point.x.toString(),false);
                                 }
            );
            
            GEvent.addListener(mapRef, "resize", 
                function()
                        {
                            // Blocage du zoom de 1 à 8
                            if (mapRef.getZoom() == 0)
                            {
                                mapRef.setZoom(1);
                            }
                            else
                            {
                                if (mapRef.getZoom() == 1)
                                {
                                    deleteCarroyage(mapRef);
                                }
                                else
                                {
                                    // Affichage du carroyage
                                    deleteCarroyage(mapRef);
                                    createCarroyage(mapRef);
                                }
                             }
                             //on affiche la valeur du centre dans un hiddenfield
                             document.getElementById("uxTxtCenter").value = mapRef.getCenter().toString();

                             // Repositionnement du centre de la nouvelle carte si celui de l'ancienne (avant redimensionnement)
                             mapRef.setCenter(myCenterPoint);

                            // Repositionnement de la minicarte
                             positionOverview();
                        }
            );

            delete ovcontrol;
        }
    };





    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                       A function to adjust the positioning of the overview                       //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // x  =>   position en X de la minicarte
    // y  =>   position en Y de la minicarte
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //     
    function positionOverview()
    {
        if(document.getElementById("map_overview") != null)
        {
            if(document.getElementById("map") != null)
            {
                document.getElementById("map_overview").style.left = parseInt(document.getElementById("map").style.width.replace("px","")) + 23 + "px";
                document.getElementById("map_overview").style.top = parseInt(document.getElementById("map").style.height.replace("px","")) - 151 + "px";
            }        
    
            // == restyling ==
            document.getElementById("map_overview").firstChild.style.border = "0px";
            document.getElementById("map_overview").firstChild.firstChild.style.left="0px";
            document.getElementById("map_overview").firstChild.firstChild.style.top="0px";
            document.getElementById("map_overview").firstChild.firstChild.style.width="170px";
            document.getElementById("map_overview").firstChild.firstChild.style.height="170px";
        }
    }


    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                Redimensionne la carte en fonction de la taille de la fenetre du navigateur                                       //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //   
    function ResizeMap()
    {
        if (mapRef != null) myCenterPoint = new GLatLng(mapRef.getCenter().y,mapRef.getCenter().x);
        if (document.getElementById("map") != null)
        {
            if(document.getElementById("map").style.width != AutoWidth()) document.getElementById("map").style.width = AutoWidth() + "px";
            if(document.getElementById("map").style.width != AutoHeight()) document.getElementById("map").style.height = AutoHeight() + "px";
        }
    }




    // ------------------------------------------------------------------------------------------//
    //      Récupère la largeur optimale à donner à la carte en fonction de la taille de         //
    //      la fenetre du navigateur                                                             //
    //-------------------------------------------------------------------------------------------//  
    function AutoWidth()
    {
        if((document.documentElement.clientWidth - bandeaularg) < larg) return larg;
        else return (document.documentElement.clientWidth - bandeaularg);
    }


    // ------------------------------------------------------------------------------------------//
    //      Récupère la hauteur optimale à donner à la carte en fonction de la taille de         //
    //      la fenetre du navigateur                                                             //
    //-------------------------------------------------------------------------------------------//  
    function AutoHeight()
    {
        if((document.documentElement.clientHeight - bandeauhaut) < haut) return haut;
        else return (document.documentElement.clientHeight - bandeauhaut);
    }


    // ------------------------------------------------------------------------------------------//
    //      Transformation d'une coordonnée décimale en coordonnée sexadécimale                  //
    // ------------------------------------------------------------------------------------------//
    // degEntier    =>     coordonnée latitudinale ou longitudinale                              //
    // BoolLgOuLt   =>     True : coordonnée latitudinale, False : coordonnée longitudinale      //
    //-------------------------------------------------------------------------------------------//  
    function TransformDegreDecimalToDegreSexaDecimal(degEntier,BoolLgOuLt)
    {
        var degSexa;
        var degDecimal;
        var tableau = degEntier.split(".");
        var ptCardinal;
        
        if (BoolLgOuLt){ //Cas d'une latitude
            if(parseFloat(tableau[0]) < 0) ptCardinal = "S ";
            else ptCardinal = "N ";
        }
        else //Cas d'une longitude
        {
            if(parseFloat(tableau[0]) < 0) ptCardinal = "W ";
            else ptCardinal = "E ";
        }
        
        if(tableau.length > 1) degDecimal = (parseFloat("0." + tableau[1]) * 60);
        else degDecimal = "0";
        
        degSexa = ptCardinal + Math.abs(tableau[0]).toString() + "° " + (Math.round(degDecimal*100)/100).toString();            
        
        delete degDecimal;
        delete tableau;
        delete ptCardinal;
        
        return degSexa;
    }        





      
    // ------------------------------------------------------------------------------------------//
    //                                  Gestion du zoom                                          //
    // ------------------------------------------------------------------------------------------//
    // zoomAuto    =>     Zoom calcule par l'API                                                 //
    //-------------------------------------------------------------------------------------------//  
    function CheckLevelZoom(zoom)
    {
        if (zoom < 1)
        {
            return 1;
        }
        else if (zoom > ZOOM_MAX_ACCUEIL)
        {
            return ZOOM_MAX_ACCUEIL;
        }
        else
        {
            return zoom;
        }
    };
    
    


    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                      Affichage de la derniere position des navires                                                //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // carte                      =>     Carte  
    // fileToDownload             =>     Chemin du fichier XML a telecharger
    //-------------------------------------------------------------------------------------------------------------------------------------------------// 
        function DisplayLastPointOfBoat(carte, fileToDownload)
        {
                // Donwloader le fichier XML correspondant
                GDownloadUrl(fileToDownload, function (data, responseCode) 
                                                 {
                                                        // Parser les fichiers
                                                        xml = GXml.parse(data);
                                                        var navires = xml.documentElement.getElementsByTagName("Navire");
                                                                        
                                                        for (var i=0; i < navires.length; i++) 
                                                        {
                                                                 var navireName = navires[i].getAttribute("nom");
                                                                 var latPosActuelle = parseFloat(navires[i].getAttribute("latitude"));
                                                                 var longPosActuelle = parseFloat(navires[i].getAttribute("longitude"));
                                                                 positionActuelle = new GLatLng(latPosActuelle, longPosActuelle);
                                                                 iconePosition = CreationImage("POS_ACTUEL", null);
                                                                 // Creation du label et de l'image representant le positionnement du navire
                                                                 navire = CreationMarqueAvecLabel(positionActuelle, iconePosition, carte, navireName);
                                                                 // Ajout sur la carte du navire
                                                                 carte.addOverlay(navire);
                                                                 
                                                                 navireName = null;
                                                                 delete navireName;
                                                                 latPosActuelle = null;
                                                                 delete latPosActuelle;
                                                                 longPosActuelle = null;
                                                                 delete longPosActuelle;
                                                                 positionActuelle = null;
                                                                 delete positionActuelle;
                                                                 iconePosition = null;
                                                                 delete iconePosition;
                                                                 navire = null;
                                                                 delete navire;
                                                        }
                                                        xml = null;
                                                        delete xml;
                                                        navires = null;
                                                        delete navires;
                                                 }
                );
        };
  
  
  
  
  
  
  



    //------------------------------------------------------------------------------------------------------------------------------------ //              
    //                                              Creation des icônes du navire                                                          //
    //------------------------------------------------------------------------------------------------------------------------------------ //         
    // imageType        =>   Type de l'image (POS_ACTUEL ou CLIGNOTANT)
    // couleurCampagne  =>   Couleur de la campagne à tracer
    //------------------------------------------------------------------------------------------------------------------------------------ //
    function CreationImage(imageType, couleurCampagne)
    {
            var icon = new GIcon();
            if (imageType == "POS_ACTUEL")
            {
                    icon.image = "../App_Themes/Ifremer/Images/mm_20_red.png";
                    icon.shadow = "../App_Themes/Ifremer/Images/mm_20_shadow.png";
                    icon.iconSize = new GSize(12, 20);
                    icon.shadowSize = new GSize(22, 20);
                    icon.iconAnchor = new GPoint(6, 20);
                    icon.infoWindowAnchor = new GPoint(6, 20);
            }
            else if(imageType == "CLIGNOTANT")
                   {
                        //si le point point est la dernière position de la campagne du navire sur la période spécifiée
                        icon.image = "../App_Themes/Ifremer/Images/repereclignotant.gif";
                        icon.shadow = "../App_Themes/Ifremer/Images/mm_20_shadow.png";
                        icon.iconSize = new GSize(12, 20);
                        icon.shadowSize = new GSize(22, 20);
                        icon.iconAnchor = new GPoint(6, 20);
                        icon.infoWindowAnchor = new GPoint(6, 20);
                   }
                   else
                   {
                        var fileName = couleurCampagne.split('#'); 
                        icon.image = "../App_Themes/Ifremer/TypeCampagneIcones/" + fileName[1] + ".gif";
                        gSizeD = new GSize(5, 5);
                        gPointD = new GPoint(3,3); 
                        icon.iconSize = gSizeD;
                        icon.iconAnchor = gPointD;
                        icon.infoWindowAnchor = gPointD;     
                       
                        delete gSizeD;
                        delete gPointD;
                   }
            return icon;
    };      






    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                      Affichage du trace des navires                                                                    //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // carte                       =>     Carte  
    // fileToDownload              =>     Chemin des fichiers de positions des navires
    //-------------------------------------------------------------------------------------------------------------------------------------------------// 
   function DisplayRoadMapOfBoat(carte, fileToDownload, intervalle)
    {  
        if (fileToDownload != "null")
        {
            var lblEtatSearch1 = document.getElementById("uxLblEtatSearch");
            lblEtatSearch1.innerHTML = "En cours de traitement...";
   
            GDownloadUrl(fileToDownload, 
                    function(data, responseCode) 
                    {  
                            var lblEtatSearch2 = document.getElementById("uxLblEtatSearch");
                            xmlDoc = GXml.parse(data);      
                            
                            var countPoint = 0;
                            
                            // Positionnement par navire
                            var navires = xmlDoc.documentElement.getElementsByTagName("navire");
                            for (var n = 0; n < navires.length; n++) 
                            {           
                                // Recuperation du nom du navire                                                            
                                var navireName = navires[n].getAttribute("nom");
                                
                                // Par campagne
                                var campagnes = navires[n].getElementsByTagName("campagne");              

                                // Tableaux utiles pour le relier les campagnes si temps < intervalle max
                                var pointscampagnes = [];
                                var datescampagnes = [];
                                var couleurscampagnes = [];

                                for (var c = 0; c < campagnes.length; c++) 
                                {  
                                    // Recuperation du nom de la campagne et de sa couleur                                                             
                                    var campagneName = campagnes[c].getAttribute("nom");                                                
                                    var campagneCouleur = campagnes[c].getAttribute("couleur"); 
                                    previousPoint = null;
                                             
                                    var points = campagnes[c].getElementsByTagName("point");
                                    
                                    // Boucle sur les points                                           
                                    for (var j = 0; j < points.length; j++) 
                                    {      
                                            // Recuperation du point 1 
                                            point1 = new GLatLng(parseFloat(points[j].getAttribute("lat")), parseFloat(points[j].getAttribute("lon")));

                                            /***** Relier deux missions si temps < intervalle max ***** DEBUT *****/

                                            // Si le nombre de campagnes est > 1 on peut les relier
                                            if (campagnes.length > 1)
                                            {
                                                // Si la campagne est la première, on ne mémorise que le dernier point
                                                if (c == 0){
                                                    // mémorisation du premier point à null
                                                    if (j == 0)
                                                    {
                                                        pointscampagnes[c] = null;
                                                        datescampagnes[c] = null;
                                                        couleurscampagnes[c] = campagneCouleur;
                                                    }
                                                    
                                                    // mémorisation du dernier point
                                                    if (j == (points.length - 1))
                                                    {
                                                        pointscampagnes[c+1] = point1;
                                                        var annee = points[j].getAttribute("date").split("/")[2];
                                                        var mois = points[j].getAttribute("date").split("/")[1];
                                                        var jour = points[j].getAttribute("date").split("/")[0];
                                                        var heure = points[j].getAttribute("heure").split(":")[0];
                                                        var minute = points[j].getAttribute("heure").split(":")[1];
                                                        var seconde = points[j].getAttribute("heure").split(":")[2];
                                                        datescampagnes[c+1] = new Date(annee,mois-1,jour,heure,minute,seconde);
                                                        couleurscampagnes[c+1] = campagneCouleur;
                                                    }                                                        
                                                    
                                                }
                                                // Si la campagne n'est pas la première, on mémorise le premier et le dernier point
                                                else
                                                {
                                                    // mémorisation du premier point
                                                    if (j == 0)
                                                    {
                                                        pointscampagnes[c*2] = point1;
                                                        var annee = points[j].getAttribute("date").split("/")[2];
                                                        var mois = points[j].getAttribute("date").split("/")[1];
                                                        var jour = points[j].getAttribute("date").split("/")[0];
                                                        var heure = points[j].getAttribute("heure").split(":")[0];
                                                        var minute = points[j].getAttribute("heure").split(":")[1];
                                                        var seconde = points[j].getAttribute("heure").split(":")[2];
                                                        datescampagnes[c*2] = new Date(annee,mois-1,jour,heure,minute,seconde);
                                                        couleurscampagnes[c*2] = campagneCouleur;
                                                    }
                                                    
                                                    // mémorisation du dernier point
                                                    if (j == (points.length - 1))
                                                    {
                                                        pointscampagnes[c*2+1] = point1;
                                                        var annee = points[j].getAttribute("date").split("/")[2];
                                                        var mois = points[j].getAttribute("date").split("/")[1];
                                                        var jour = points[j].getAttribute("date").split("/")[0];
                                                        var heure = points[j].getAttribute("heure").split(":")[0];
                                                        var minute = points[j].getAttribute("heure").split(":")[1];
                                                        var seconde = points[j].getAttribute("heure").split(":")[2];
                                                        datescampagnes[c*2+1] = new Date(annee,mois-1,jour,heure,minute,seconde);
                                                        couleurscampagnes[c*2+1] = campagneCouleur;
                                                    }
                                                }
                                            }
                                            /***** Relier deux missions si temps < intervalle max  *****  FIN *****/


                                            
                                            // Recuperation des informations pour ce point 
                                            var tabInformationsPoint = new Array();
                                            tabInformationsPoint["navire"] = navireName;
                                            tabInformationsPoint["campagne"] = campagneName;   
                                            tabInformationsPoint["date"] = points[j].getAttribute("date");
                                            tabInformationsPoint["heure"] = points[j].getAttribute("heure");                                                                                                    
                                            tabInformationsPoint["latitude"] = points[j].getAttribute("latD");                                                              
                                            tabInformationsPoint["longitude"] = points[j].getAttribute("lonD");                                                                                                                            
                                            tabInformationsPoint["sonde"] = points[j].getAttribute("sonde");       
                                            tabInformationsPoint["vitesseVent"] = points[j].getAttribute("vVent"); 
                                            tabInformationsPoint["directionVent"] = points[j].getAttribute("dVent");        
                                            tabInformationsPoint["tempMer"] = points[j].getAttribute("tMer");     
                                            tabInformationsPoint["tempAir"] = points[j].getAttribute("tAir");     
                                            tabInformationsPoint["pression"] = points[j].getAttribute("pAtmo"); 
                                                                                                     
                                           var LastPoint = "POINT";
                  
                                          // Si pas dernier point du fichier et Même navire et Même campagne
                                          if (previousPoint != null)
                                          { 
                                                    // Trace de la campagne 
                                                    polyline=new GPolyline([previousPoint, point1], campagneCouleur, 1, 1);  
                                                    carte.addOverlay(polyline);
                                                    
                                                    delete polyline;
                                                    polyline = null;
                                           }
                                           
                                           delete previousPoint;
                                           previousPoint = point1;
                                           
                                           //si le dernier point du navire, clignotant
									        if ((j == points.length - 1) && (c == campagnes.length - 1))
									        {
									            LastPoint = "CLIGNOTANT";
									            
									            // S'il y a plus d'un navire à afficher
									            if(document.getElementById("uxDropDownListNavires").value == "ALL")
									            {
									                // Affichage de son nom en dessous du dernier point
									                afficheNomNavire(previousPoint,carte,navireName);
									            }
									        }
    										
                                            // Creation d'une icone pour le point : point de route ou point final
                                            objGIcon_icone = CreationImage(LastPoint, campagneCouleur); 
                                           
                                            // Positionnement du navire avec l'info bulle d'information
                                            navire = CreationMarqueAvecInfoBulleOnglets(point1, objGIcon_icone, carte, tabInformationsPoint,LastPoint,navireName);
                                            // Ajout sur la carte de l'image
                                            carte.addOverlay(navire); 
                                            
                                            countPoint ++; 
                                            
                                            point1 = null;
                                            delete point1; 
                                            tabInformationsPoint = null;
                                            LastPoint = null;
                                            objGIcon_icone = null;
                                            delete objGIcon_icone;
                                            navire = null; 
                                            delete navire;
                                           
                                    } //fin des points
                                    points = null; 
                                    campagneName = null;
                                    campagneCouleur = null; 
                                    previousPoint = null;
                                    
                                }// fin des campagnes
                                campagnes = null;
                                navireName = null;


                                /***** Relier deux missions si temps < intervalle max ***** DEBUT *****/
                                //boucle sur les campagnes
                                for (var a = 0; a < (pointscampagnes.length/2); a++)
                                {
                                    // Si nous ne sommes pas sur la première campagne
                                    if ( a != 0 )
                                    {
                                        // Calcul de l'intervalle (en heures) entre le premier point de la campagne a et le dernier point de campagne a-1
                                        var intervalle_calc = getIntervalleDateInHours(datescampagnes[a*2-1],datescampagnes[a*2]);
                                        
                                        // Si cet intervalle est inférieur à celui fixé dans le Web.config
                                        if ( intervalle_calc < intervalle)
                                        {
                                            // Tracé de la ligne reliant deux campagnes
                                            polyline = new GPolyline([pointscampagnes[a*2-1], pointscampagnes[a*2]], couleurscampagnes[a*2-1], 1, 1);  
                                            carte.addOverlay(polyline);
                                            delete polyline;
                                        }
                                    }
                                }
                                /***** Relier deux missions si temps < intervalle max ***** FIN *****/


                            }// fin des navires
                            navires = null;
                            
                            lblEtatSearch2.innerHTML = countPoint + " positions transmises.";   
                            lblEtatSearch2 = null;
                            
                            countPoint = null;         
                            delete xmlDoc;                      
                            xmlDoc = null;

                    }
            );
           lblEtatSearch1 = null; 
        } 
    };


    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                 Retourne l'intervalle en centièmes d'heures entre deux dates                     //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // date_deb   =>  Date de début
    // date_fin   =>  Date de fin
    //-------------------------------------------------------------------------------------------------------------------------------------------------// 
    function getIntervalleDateInHours(date_deb,date_fin)
    {
        var div_hours = 1000 * 60 * 60;
        var dif = date_fin.getTime() - date_deb.getTime();
        var inter = dif / div_hours;
        delete div_hours;
        delete dif;
        return inter;
    }


 
 
 
    //------------------------------------------------------------------------------------------------------------------------------------ //               
    //                                  Positionnement d'une image sur la carte avec un label associe                                           //
    //------------------------------------------------------------------------------------------------------------------------------------ //  
    // objGLatLng_Point                          =>   Position (Lat, Long) de l'objet sur la carte
    // objGIcon_Icone                            =>   Icone representant l'objet sur la carte
    // objGMap2_Carte                            =>   Carte  
    // str_Navire                                =>   Nom de l'objet 
    //------------------------------------------------------------------------------------------------------------------------- // 
    function CreationMarqueAvecLabel(objGLatLng_Point, objGIcon_Icone, objGMap2_Carte, str_Navire) 
    {
            var objGMarker_marker = new GMarker(objGLatLng_Point, objGIcon_Icone, false, str_Navire, false, false, false, 1);
            var gSizeMarque =  new GSize(-25, 15);               
            var str_NomNavire = new ELabel(objGLatLng_Point, str_Navire, "navireLabel", gSizeMarque, 100, true);
            objGMap2_Carte.addOverlay(str_NomNavire);
           
            delete gSizeMarque;
            delete str_NomNavire;
            
            return objGMarker_marker;
    }
 
 
 
 
 
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                      Creation des points avec Info Bulles                                                            //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // point                          =>     Point (en LatLng) ou se positionne l'image  
    // icone                          =>     Image utilisee pour positionner le point
    // carte                          =>     Carte   
    // informations                   =>     tableau des informations 
    //-------------------------------------------------------------------------------------------------------------------------------------------------//     
        function CreationMarqueAvecInfoBulleOnglets(point, icone, carte, informations) 
        {
                
                var marker = new GMarker(point, icone, false, informations["navire"], false, false, false, 1);
          
                var boolIsMeteo = false;
           
                if (informations["sonde"] == ""){ 
                    informations["sonde"] = "Non transmis";
                }else{
                    informations["sonde"] = informations["sonde"] + "m";
                }
               
               if (informations["vitesseVent"] == ""){
                    informations["vitesseVent"] = "Non transmis";
               }else{
                    boolIsMeteo = true;
                    informations["vitesseVent"] = informations["vitesseVent"] + "noeuds";
               }
               
               if (informations["directionVent"] == ""){
                    informations["directionVent"] = "Non transmis";
               }else{
                    boolIsMeteo = true;
                    informations["directionVent"] = informations["directionVent"] + "°";         
               }  
               if (informations["tempMer"] == ""){
                    informations["tempMer"] = "Non transmis";
               }else{
                    boolIsMeteo = true;
                    informations["tempMer"] = informations["tempMer"] + "°C";           
               }
               if (informations["tempAir"] == ""){
                    informations["tempAir"] = "Non transmis";
               }else{
                    boolIsMeteo = true;
                    informations["tempAir"] = informations["tempAir"] + "°C";           
               }
               if (informations["pression"] == ""){
                    informations["pression"] = "Non transmis";
               }else{
                    boolIsMeteo = true;
                    informations["pression"] = informations["pression"] + "mbars";            
               }
                
              
               // Creation des onglets dans l'info bulle 
               var onglets = new Array();
               ongletPosition = new GInfoWindowTab("Position", "<table><tr><td class='infoBulleLabel'>Navire:</td><td class='infoBulleData'>" + informations["navire"] + "</td></tr><tr><td class='infoBulleLabel'>Campagne:</td><td class='infoBulleData'>" + informations["campagne"] + "</td></tr><tr><td class='infoBulleLabel'>Date:</td><td class='infoBulleData'>" + informations["date"] + " - " + informations["heure"]  + " (GMT)</td></tr><tr><td class='infoBulleLabel'>Latitude:</td><td class='infoBulleData'>" + informations["latitude"] + "</td></tr><tr><td class='infoBulleLabel'>Longitude:</td><td class='infoBulleData'>" +  informations["longitude"]  + "</td></tr><tr><td class='infoBulleLabel'>Sonde:</td><td class='infoBulleData'>" + informations["sonde"] + "</td></tr></table>");
	           onglets[0] = ongletPosition;   
	           
               if (boolIsMeteo == true){                      
	                ongletMeteo = new GInfoWindowTab("Météo", "<table><tr><td class='infoBulleLabel'>Vitesse du vent:</td><td class='infoBulleData'>" + informations["vitesseVent"] + "</td></tr><tr><td class='infoBulleLabel'>Direction du vent:</td><td class='infoBulleData'>" + informations["directionVent"] + "</td></tr><tr><td class='infoBulleLabel'>Température de la mer:</td><td class='infoBulleData'>" + informations["tempMer"] + "</td></tr><tr><td class='infoBulleLabel'>Température de l'air:</td><td class='infoBulleData'>" + informations["tempAir"] + "</td></tr><tr><td class='infoBulleLabel'>Pression atmosphérique:</td><td class='infoBulleData'>" +  informations["pression"]  + "</td></tr></table>");
                    onglets[1] = ongletMeteo;
                    
                    delete ongletMeteo;
                    ongletMeteo = null;
	           }
    	       
    	       // Listener sur l'info bulle
	           GEvent.addListener(marker, "click", function() 
                                                              {
                                                                marker.openInfoWindowTabsHtml(onglets);
                                                               }
                                    );     
				
	           displayMarkers.push(marker);  
	           delete ongletPosition;                                                  
               ongletPosition = null;
                                                             
		        return marker;
	} 



    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    //                                                                      Creation des points avec Info Bulles                                                            //
    // ------------------------------------------------------------------------------------------------------------------------------------------------ //
    // point                          =>     Point (en LatLng) ou se positionne l'image  
    // carte                          =>     Carte   
    // lastpoint                      =>     'CLIGNOTANT' ou 'POINT'
    // str_Navire                     =>     Nom bu bateau
    //-------------------------------------------------------------------------------------------------------------------------------------------------//     
    function afficheNomNavire(point, carte,str_Navire)
    {
        // Emplacement du label
        var gSizeMarque =  new GSize(-30, 15);  
        // Création du baleb
        var str_NomNavire = new ELabel(point, str_Navire, "navireLabel", gSizeMarque, 100, true);
        //Ajout du label sur la carte
        carte.addOverlay(str_NomNavire);
    }



   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   //                                                                       Creation du carroyage                                                                               //
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   // mapRef   =>   la carte
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //     
  function createCarroyage(mapRef)
  {  
        // Declaration des variables
        var pasMeridien = null;
        var meridienMin = null;
        var meridienMax = null;
              
        // Recuperation des coordonnees du rectangle representant la region de la carte visualisable
   		bounds = mapRef.getBounds();
   		// Recuperation du point sud ouest du rectangle
		southWest = bounds.getSouthWest();
		// Recuperation du point nord est du rectangle
		northEast = bounds.getNorthEast();
        // Recuperation des latitudes et longitudes des 2 points de la carte
        latitudeSW = southWest.lat();
        longitudeSW = southWest.lng();        
        latitudeNE = northEast.lat();
        longitudeNE = northEast.lng();
        // Compteur d'objet à tracer
        var compteur = 0;            

        
        // Debordement du planisphere => largeur
        if (longitudeSW > longitudeNE)
        {
            if (longitudeNE > 0)
            {
  	            pasMeridien = MakeTics((180-longitudeSW), (-180-longitudeNE), true);    
                meridienMin = pasMeridien*Math.floor((longitudeSW-360)/pasMeridien); 
                meridienMax = pasMeridien*Math.ceil(longitudeNE/pasMeridien);
            }
            if (longitudeNE < 0)
            {
                pasMeridien = MakeTics((180-longitudeSW), (-180-longitudeNE), true);  
                meridienMin = pasMeridien*Math.floor(longitudeSW/pasMeridien);
                meridienMax = pasMeridien*Math.ceil((longitudeNE+360)/pasMeridien);           
            }
        }
        else
        {
                pasMeridien = MakeTics(longitudeSW, longitudeNE, true);  
  	            meridienMin = pasMeridien*Math.floor(longitudeSW/pasMeridien);
  	            meridienMax = pasMeridien*Math.ceil(longitudeNE/pasMeridien);
        }
        
        // Valeurs de départ et de fin des paralleles
        var pasParallele = MakeTics(latitudeSW, latitudeNE, false);  	    
  	    var paralleleMin = pasParallele*Math.floor(latitudeSW/pasParallele);
  	    var paralleleMax = pasParallele*Math.ceil(latitudeNE/pasParallele);      
  	    
        // ---> Traçage des méridiens  <---
        for(j=meridienMin; j<=meridienMax; j=j+pasMeridien)
        {  
            // Debordement du planisphere (hauteur) => Ne pas tracer en dehors de la carte
            if (latitudeNE > 85)
                latitudeNE = 85; 
            if (latitudeSW < -85)
                latitudeSW = -85; 
                
            latLngSW =  new GLatLng(latitudeSW, j);
            latLngNE = new GLatLng(latitudeNE, j);
            
            // ---> Traçage des méridiens  <---
            gPoly = new GPolyline([latLngSW,latLngNE], "#A6879A", 0.5, 1);
            tab_Polyline[compteur] = gPoly;
            mapRef.addOverlay(tab_Polyline[compteur]);
            
            delete latLngSW;
            latLngSW = null;
            delete latLngNE;
            latLngNE = null;
            delete gPoly;
            gPoly = null;
            
            // Création du label des longitudes
            if (parseInt(j) < 0)
                longitude= "W&nbsp;" + RoundNumber(Math.abs(j), 2) + "°";
            if (parseInt(j) == -180)
                 longitude= RoundNumber(Math.abs(j), 2) + "°";                           
            if (parseInt(j) < -180)
                longitude= "E&nbsp;" + RoundNumber(Math.abs(360+j), 2) + "°";
            if (parseInt(j) > 0)
                longitude= "E&nbsp;" + RoundNumber(Math.abs(j), 2) + "°";
             if (parseInt(j) == 180)
                 longitude= RoundNumber(Math.abs(j), 2) + "°";                       
            if (parseInt(j) > 180)
                longitude= "W&nbsp;" + RoundNumber(Math.abs(360-j), 2) + "°";
            if(parseInt(j) == 0)
                longitude="0&nbsp;°";

            // Positionnement du label correspondant aux meridiens  		
            gLatNE = new GLatLng(latitudeNE, j) ; 
            gSizeMeridien = new GSize(-12, 11);
            eLabel = new ELabel(gLatNE, longitude, "meridien",  gSizeMeridien, 100, true);
            tab_LblLatLong[compteur] = eLabel
            mapRef.addOverlay(tab_LblLatLong[compteur]);	
            
            delete gSizeMeridien;
            gSizeMeridien = null;
            delete gLatNE;
            gLatNE = null;
            delete eLabel;
            eLabel = null;
            // Nombre d'objets à effacer ++
            compteur = compteur + 1;
        }
 	    
 	    // Tracage des paralleles (latitude)
        for(i = paralleleMin; i <= paralleleMax; i = i+pasParallele)
        {
            if (i < 85 && i > -85)
            {   
                gLatSW = new GLatLng(i, longitudeSW);
                parallele =  creationParallele();
                gMarkerLat = new GMarker(gLatSW, parallele);
                tab_Polyline[compteur] = gMarkerLat;
                mapRef.addOverlay(tab_Polyline[compteur]);
               
                delete gLatSW;
                gLatSW = null;
                delete parallele; 
                parallele = null;
                delete gMarkerLat; 
                gMarkerLat = null;
                
                compteur = compteur+1;  
                
	            // Création du label des paralleles (latitude)
                if ( i < 0 )
                    latitude= "S&nbsp;" + RoundNumber(Math.abs(i),2) + "°";
                if (i == 0)
                    latitude="0°";
                if ( i > 0)
                    latitude= "N&nbsp;" + RoundNumber(Math.abs(i),2) + "°";
	         	
	            // Positionnement du label correspondant aux paralleles
	            gSizeNE = new GSize(-40, 0);
	            gLatLngNE =  new GLatLng(i, longitudeNE);
	            eLabelNE = new ELabel(gLatLngNE, latitude, "meridien",  gSizeNE, 100, true);
                tab_LblLatLong[compteur] = eLabelNE;
                mapRef.addOverlay(tab_LblLatLong[compteur]);	
                
                delete gSizeNE;
                gSizeNE = null;
                delete gLatLngNE; 
                gLatLngNE = null; 
                delete eLabelNE; 
                eLabelNE = null;
                	
                compteur = compteur+1;
            } 
        }
        
        delete northEast;
        northEast = null;
        delete southWest;
        southWest = null;
        delete bounds;
        bounds = null;
        pasMeridien = null;
        meridienMin = null;
        meridienMax = null;
    }; 
    
   
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   //                                                                       Création des parallèles                                                    //
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   // mapRef   =>   la carte
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //         
   function creationParallele(){
        paralleleIcon = new GIcon();
	    paralleleIcon.image = "../App_Themes/Ifremer/Images/latitudecarroyage.jpg";
	    gPointPara = new GPoint(1,1);
        paralleleIcon.iconAnchor = gPointPara;
        paralleleIcon.infoWindowAnchor = gPointPara;	
        gSizePara = new GSize(1800, 1);
        paralleleIcon.iconSize = gSizePara;
        
        delete gPointPara;
        gPointPara = null;
        delete gSizePara;
        gSizePara = null;
        return paralleleIcon;
	}; 


    
        
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   //                                                                       Suppression du carroyage                                                                               //
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   // mapRef   =>   la carte
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //     
    function deleteCarroyage(mapRef){
    
        // Destruction du trace
        for (var k = 0; k <= tab_Polyline.length+1; k++)
	    {
	        if (tab_Polyline[k] != null) mapRef.removeOverlay(tab_Polyline[k]);
	    }
	    
	    // Destruction des labels
	    for (var k = 0; k<tab_LblLatLong.length+1; k++)
	    {
	        if (tab_LblLatLong[k] != null) mapRef.removeOverlay(tab_LblLatLong[k]);
	    }
    };



   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   //                                                                       Arrondi d'un nombre selon un nombre de décimal                             //
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   // NUMBER     =>   le nombre à arrondir
   // DECIMALS   =>   le nombre de décimales à garder après la virgule
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //     
    function RoundNumber(NUMBER, DECIMALS) {
    	NUMBER += '';	
    	var arNUMS = NUMBER.split('.');

        	if( arNUMS.length < 2 ) return NUMBER;
        	
        	var POWER = Math.pow(10, arNUMS[1].length);
        	var ROUNDED = NUMBER;

            	for( var i = 0; i <= arNUMS[1].length - DECIMALS; i++ ) {
            		ROUNDED = (Math.round((ROUNDED * POWER)) / POWER);
            		POWER = POWER / 10;
            	}
            	return ROUNDED;
        };
         
        
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   //                                                                       Calcul du pas en fonction de l'amplitude                                   //
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   // min           =>   minimum SW
   // max           =>   maximum NE
   // boolLongitude =>   false : latitude, true : longitude
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //     
        function MakeTics(min, max, boolLongitude) {     
                var tic;
                
                xr = Math.abs(min-max);

                if (boolLongitude){
                    xr = xr / 2;
                }
               
                if (xr > 150)
                {
                    tic = 100;
                }                                
                else if (xr > 60)
                {
                    tic = 30;
                }
                else if (xr > 30)
                {
                    tic = 10;
                }
                else if (xr > 5)
                {
                    tic = 5;
                }       
                else if (xr > 1)
                {
                    tic = 1;
                }      
                else if (xr > 0.5)
                {
                    tic = 0.5;
                } 
                else
                {
                    tic = 0.2;
                }       
                return tic;
        } ;



        
        
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //
   //                                                                       A function to clean objects from memory                                     //
   // ------------------------------------------------------------------------------------------------------------------------------------------------ //     
    function UnLoadMap()
    {
        // Cleanup old markers during refresh
        while ( displayMarkers.length > 0 ) {
                var marker = displayMarkers.pop();
                GEvent.clearListeners( marker, "click" );
                marker = null;
        }
        
        //Suppression des évenements inscrits
        GEvent.clearListeners( mapRef, "moveend" );
        GEvent.clearListeners( mapRef, "zoomend" );
        GEvent.clearListeners( mapRef, "mousemove" );
                    
        delete tab_Polyline;
        delete tab_LblLatLong;
        delete mapRef;
    }