Changeset 70457 in spip-zone


Ignore:
Timestamp:
Mar 6, 2013, 10:30:19 AM (6 years ago)
Author:
cedric@…
Message:

Refactoring du js du modele carte_gis :
Plutot que generer plein de JS specifique a la carte, on rend tout le js generique et on lui passe simplement un tableau de configuration contenant toutes les specificites de la carte a afficher
par compatibilite l'objet map construit reste attache a la globale map#ENV{id} mais il est aussi attache a l'objet du DOM qui porte la carte.
On peut donc toujours le retrouver par $('#maptruc').get(0).map ce qui est plus generique
Les methodes AddJSON et removeAllMarkers compatibilite GIS 3 y sont attaches
Les methodes setGeoJsonFeatureIcon, setGeoJsonFeaturePopup et parseGeoJson y sont egalement attachees (on peut donc avoir une map avec cluster et une map sans cluster dans la meme page sans risque de conflit de fonction)

La lib leafclusterer.js est inclue par gis.js a la demande (via argument de #PRODUIRE_FOND) ce qui evite de charger les libs en 2 hits quand on utilise les clusters

Location:
_plugins_/gis/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/gis/trunk/gis_fonctions.php

    r70198 r70457  
    259259}
    260260
     261/**
     262 * Recuperer les cles primaires du env pour l'appel a l'url json des points
     263 * @param $env
     264 * @return array
     265 */
     266function gis_modele_url_json_env($env){
     267        $contexte = array();
     268        if (is_string($env))
     269                $env = unserialize($env);
     270        if ($env){
     271                // d'abord toutes les cles primaires connues
     272                $tables_sql = lister_tables_objets_sql();
     273                foreach (array_keys($tables_sql) as $table){
     274                        $primary = id_table_objet($table);
     275                        if (isset($env[$primary]))
     276                                $contexte[$primary] = $env[$primary];
     277                }
     278                // puis cas particuliers
     279                $keys = array("id_objet","id_secteur","id_parent","media","recherche","mots");
     280                foreach ($keys as $key){
     281                        if (isset($env[$key]))
     282                                $contexte[$key] = $env[$key];
     283                }
     284        }
     285        return $contexte;
     286}
     287
     288/**
     289 * Transformer le tableau de kml en tableau d'urls :
     290 *   si numerique c'est un id de document
     291 *   si chaine c'est une url qu'on rapatrie en local
     292 * @param array $kml
     293 * @return array
     294 */
     295function gis_kml_to_urls($kml){
     296        if ($kml AND count($kml)){
     297                include_spip("inc/filtres_mini");
     298                include_spip("inc/distant");
     299                foreach($kml as $k=>$v){
     300                        if (is_numeric($v)){
     301                                $kml[$k] = url_absolue(generer_url_entite($v,"document"));
     302                        }
     303                        else
     304                                $kml[$k] = _DIR_RACINE.copie_locale($kml[$k]);
     305                }
     306        }
     307        return $kml;
     308}
    261309?>
  • _plugins_/gis/trunk/javascript/gis.js.html

    r70194 r70457  
    3333[(#INCLURE{[(#VAL{[(#EVAL{_DIR_LIB_GIS})plugins/layer/tile/Bing.js]})]})]
    3434]
     35
     36[(#REM)
     37Lib clustering si besoin
     38]
     39[(#ENV{cluster}|=={oui}|oui)
     40#INCLURE{javascript/leafclusterer.js}
     41]
     42
     43[(#CONFIG{auto_compress_js}|=={oui})
     44#FILTRE{compacte}
     45]
  • _plugins_/gis/trunk/modeles/carte_gis.html

    r70438 r70457  
    7575
    7676<script type="text/javascript">/*<!\[CDATA\[*/
    77 
    7877var map[(#GET{id})];
     78var map_cfg = {
     79"mapid":"map[(#GET{id})]",
     80"scrollWheelZoom": [(#ENV{zoom_molette,#ENV{zoom_wheel}}|=={non}|?{false,true})],
     81"zoomControl": [(#ENV{no_control,#ENV{aucun_controle}}|!={oui}|?{true,false})][,
     82"maxZoom": (#ENV{maxZoom})],
     83"utiliser_bb":[(#GET{utiliser_bb}|?{true,false})],
     84"lat":[(#GET{lat})][,
     85"sw_lat":(#GET{sw_lat})][,
     86"ne_lat":(#GET{ne_lat})],
     87"lon":[(#GET{lon})][,
     88"sw_lon":(#GET{sw_lon})][,
     89"ne_lon":(#GET{ne_lon})],
     90"zoom":[(#ENV{zoom,#CONFIG{gis/zoom,0}})],
     91"default_layer":"[(#REM|gis_layer_defaut)]",
     92"layers":#EVAL{json_encode($GLOBALS['gis_layers'])},
     93"affiche_layers":[(#CONFIG{gis/layers,#ARRAY}|json_encode)],
     94"control_type":[(#ENV{control_type,#ENV{controle_type}}|=={non}|?{false,true})],
     95"no_control":[(#ENV{no_control,#ENV{aucun_controle}}|=={oui}|?{true,false})],
     96"scale":[(#ENV{scale}|=={oui}|?{true,false})],
     97"fullscreen":[(#ENV{fullscreen}|=={oui}|?{true,false})],
     98"cluster":[(#ENV{cluster}|=={oui}|?{true,false})],
     99"clusterMaxZoom":[(#ENV{clusterMaxZoom, #ENV{maxZoom}|?{#ENV{maxZoom}|moins{2},0}})],
     100"path_styles":[(#ENV*{path_styles}|json_encode)],
     101"autocenterandzoom":[(#ENV{autocenterandzoom,#ENV{centrer_auto}}|?{true,false})],
     102"open_id":"[(#ENV{id_a_ouvrir,''})]",
     103"clusterStyles":[(#ENV*{clusterStyles,#ARRAY}|json_encode)],
     104"affiche_points":[(#ENV{point,''}|=={non}|?{false,true})],
     105"json_points":{
     106        "url":"[(#URL_PAGE{gis_json}|url_absolue)]",
     107        "objets":"(#ENV{objets,#ENV{class}}|trim)",
     108        "limit":[(#ENV{limit,#ENV{limite,500}}|trim)],
     109        "env":[(#ENV{args,#ENV}|gis_modele_url_json_env|json_encode)][,
     110        "titre" : (#ENV{titre}|json_encode)][,
     111        "description" : (#ENV{description}|json_encode)][,
     112        "icone" : (#ENV{icone}|json_encode)]
     113        },
     114"localize_visitor":[(#ENV{localize_visitor,#ENV{localiser_visiteur}}|?{true,false})],
     115"kml":[(#ENV{kml,''}|?{[(#ENV{kml}|is_array|?{#ENV{kml},#LISTE{#ENV{kml}}}|gis_kml_to_urls|json_encode)],false})],
     116"gpx":[(#ENV{gpx,''}|?{[(#ENV{gpx}|is_array|?{#ENV{gpx},#LISTE{#ENV{gpx}}}|gis_kml_to_urls|json_encode)],false})]
     117};
     118if (typeof(callback_map[(#GET{id})]) === "function") {
     119        map_cfg['callback']=callback_map[(#GET{id})];
     120}
    79121
    80122(function($){
    81123
    82         var init_map[(#GET{id})] = function(callback) {
    83                 var map_container = 'map[(#GET{id})]';
     124        var gis_init_map = function(mapcfg) {
     125                var map_container = mapcfg["mapid"];
    84126
    85127                // Création de la carte Leafleat
    86                 map[(#GET{id})] = new L.Map(map_container,{
    87                         scrollWheelZoom: [(#ENV{zoom_molette,#ENV{zoom_wheel}}|=={non}|?{false,true})],
    88                         zoomControl: [(#ENV{no_control,#ENV{aucun_controle}}|!={oui}|?{true,false})][,
    89                         maxZoom: (#ENV{maxZoom})]
     128                var map = new L.Map(map_container,{
     129                        scrollWheelZoom: mapcfg["scrollWheelZoom"],
     130                        zoomControl: mapcfg["zoomControl"],
     131                        maxZoom: mapcfg["maxZoom"]
    90132                });
     133                // affecter sur la globale homonyme a mapid/map_container (compat ascendante)
     134                eval(map_container+"=map;");
     135                // affecter sur l'objet du DOM
     136                $("#"+map_container).get(0).map=map;
    91137
    92138                // Appeler l'éventuelle fonction de callback et trigger "load"
    93                 map[(#GET{id})].on('load',function(e){
    94                         if (callback && typeof(callback) === "function") {callback(e.target);}
    95                         $("#map[(#GET{id})]").trigger('load',e.target);
     139                map.on('load',function(e){
     140                        if (mapcfg["callback"] && typeof(mapcfg["callback"]) === "function") {
     141                                var callback = mapcfg["callback"];
     142                                callback(e.target);
     143                        }
     144                        $("#"+map_container).trigger('load',e.target);
    96145                });
    97146
    98147                // Déterminer la position initiale de la carte
    99                 [(#GET{utiliser_bb}|non)
    100                 map[(#GET{id})].setView(new L.LatLng([(#GET{lat})], [(#GET{lon})]), [(#ENV{zoom,#CONFIG{gis/zoom,0}})]);]
    101 
    102                 [(#GET{utiliser_bb}|oui)
    103                 map[(#GET{id})].fitBounds(
    104                         new L.LatLngBounds(
    105                                 new L.LatLng([(#GET{sw_lat})], [(#GET{sw_lon})]),
    106                                 new L.LatLng([(#GET{ne_lat})], [(#GET{ne_lon})])
    107                         )
    108                 );]
     148                if (!mapcfg['utiliser_bb']){
     149                        map.setView(new L.LatLng(mapcfg['lat'], mapcfg['lon']), mapcfg['zoom']);
     150                }
     151                else {
     152                        map.fitBounds(
     153                                new L.LatLngBounds(
     154                                        new L.LatLng(mapcfg['sw_lat'], mapcfg['sw_lon']),
     155                                        new L.LatLng(mapcfg['ne_lat'], mapcfg['ne_lon'])
     156                                )
     157                        );
     158                }
     159
     160                var get_layer=function(name){
     161                        var layer;
     162                        if (typeof mapcfg['layers'][name]!=="undefined")
     163                        eval("layer=new "+ mapcfg['layers'][name]["layer"]+";");
     164                        return layer;
     165                }
    109166
    110167                // Fond de carte par défaut (layer)
    111                 #SET{layer_defaut,#REM|gis_layer_defaut} #SET{layers,#EVAL{$GLOBALS['gis_layers']}}
    112                 var [(#GET{layer_defaut})] = [new (#GET{layers/#GET{layer_defaut}/layer})];
    113                 map[(#GET{id})].addLayer([(#GET{layer_defaut})]);
    114 
    115                 <B_layers>
    116                 // liste des fonds de carte possibles
    117                 var layers_control = new L.Control.Layers();
    118                 layers_control.addBaseLayer([(#GET{layer_defaut})],["(#GET{layers/#GET{layer_defaut}/nom})"]);
    119                 <BOUCLE_layers(DATA){source table, #GET{layers}}
    120                         {si #ENV{control_type,#ENV{controle_type}}|!={non}}
    121                         {si #ENV{no_control,#ENV{aucun_controle}}|!={oui}}
    122                         {si #CONFIG{gis/layers,#ARRAY}|count|>{1}}>[
    123                 (#CLE|!={#GET{layer_defaut}}|et{#CLE|in_any{#CONFIG{gis/layers}}|oui})
    124                 layers_control.addBaseLayer([new (#LAYER)],"#NOM");]
    125                 </BOUCLE_layers>
    126                 map[(#GET{id})].addControl(layers_control);
    127                 // ajouter l'objet du controle de layers à la carte pour permettre d'y accéder depuis le callback
    128                 map[(#GET{id})].layersControl = layers_control;
    129                 // classe noajax sur le layer_control pour éviter l'ajout de hidden par SPIP
    130                 $(layers_control._form).addClass('noajax');
    131                 </B_layers>
    132 
    133                 map[(#GET{id})].setView(new L.LatLng(#GET{lat},#GET{lon}),#ENV{zoom,#CONFIG{gis/zoom,0}});
    134 
    135                 map[(#GET{id})].attributionControl.setPrefix('');
     168                var default_layer = get_layer(mapcfg['default_layer']);
     169                map.addLayer(default_layer);
     170
     171                if (mapcfg['control_type'] && !mapcfg['no_control'] && mapcfg['affiche_layers'].length>1){
     172                        var layers_control = new L.Control.Layers();
     173                        layers_control.addBaseLayer(default_layer,mapcfg['layers'][mapcfg['default_layer']]["nom"]);
     174                        for(var l in mapcfg['affiche_layers']){
     175                                if (mapcfg['affiche_layers'][l]!==mapcfg['default_layer']){
     176                                        var layer = get_layer(mapcfg['affiche_layers'][l]);
     177                                        if (typeof layer!=="undefined")
     178                                                layers_control.addBaseLayer(layer,mapcfg['layers'][mapcfg['affiche_layers'][l]]["nom"]);
     179                                }
     180                        }
     181                        map.addControl(layers_control);
     182                        // ajouter l'objet du controle de layers à la carte pour permettre d'y accéder depuis le callback
     183                        map.layersControl = layers_control;
     184                        // classe noajax sur le layer_control pour éviter l'ajout de hidden par SPIP
     185                        $(layers_control._form).addClass('noajax');
     186                }
     187
     188                map.setView(new L.LatLng(mapcfg['lat'],mapcfg['lon']),mapcfg['zoom']);
     189                map.attributionControl.setPrefix('');
    136190
    137191                // Ajout des contrôles de la carte
    138                 [(#ENV{scale}|et{#ENV{no_control,#ENV{aucun_controle}}|!={oui}}|oui)
    139                 map[(#GET{id})].addControl(new L.Control.Scale());
    140                 ][(#ENV{fullscreen}|et{#ENV{no_control,#ENV{aucun_controle}}|!={oui}}|oui)
    141                 map[(#GET{id})].addControl(new L.Control.FullScreen());
    142                 ][(#ENV{overview}|et{#ENV{no_control,#ENV{aucun_controle}}|!={oui}}|oui)
    143                 var minimap_layer = [new (#GET{layers/#GET{layer_defaut}/layer})];
    144                 var miniMap = new L.Control.MiniMap(minimap_layer,{width: 100,height: 100}).addTo(map[(#GET{id})]);
    145                 ]
    146 
    147                 // Pour Ajouter l'icone d'un point (feature = item d'un GeoJson)
    148                 var setGeoJsonFeatureIcon = function (feature, layer) {
     192                if (!mapcfg['no_control']){
     193                        if (mapcfg['scale'])
     194                                map.addControl(new L.Control.Scale());
     195                        if (mapcfg['fullscreen'])
     196                                map.addControl(new L.Control.FullScreen());
     197                        if (mapcfg['overview']){
     198                                var minimap_layer = get_layer(mapcfg['default_layer']);
     199                                var miniMap = new L.Control.MiniMap(minimap_layer,{width: 100,height: 100}).addTo(map);
     200                        }
     201                }
     202
     203                // API setGeoJsonFeatureIcon : Pour Ajouter l'icone d'un point (feature = item d'un GeoJson)
     204                map.setGeoJsonFeatureIcon = function (feature, layer) {
    149205                        // Déclarer l'icone du points, si défini
    150206                        if (feature.properties && feature.properties.icon){
    151207                                layer.setIcon(new L.Icon({
    152208                                        iconUrl: feature.properties.icon,
    153                                         iconSize: new L.Point( feature.properties.icon_size\[0\], feature.properties.icon_size\[1\] ),
    154                                         iconAnchor: new L.Point( feature.properties.icon_anchor\[0\], feature.properties.icon_anchor\[1\] ),
    155                                         popupAnchor: new L.Point( feature.properties.popup_anchor\[0\], feature.properties.popup_anchor\[1\] )
     209                                        iconSize: new L.Point( feature.properties.icon_size[0], feature.properties.icon_size[1] ),
     210                                        iconAnchor: new L.Point( feature.properties.icon_anchor[0], feature.properties.icon_anchor[1] ),
     211                                        popupAnchor: new L.Point( feature.properties.popup_anchor[0], feature.properties.popup_anchor[1] )
    156212                                }));
    157213                        }
    158214                }
    159215
    160                 // Pour Ajouter le texte de popup d'un point (feature = item d'un GeoJson)
    161                 var setGeoJsonFeaturePopup = function (feature, layer) {
     216                // API setGeoJsonFeaturePopup : Pour Ajouter le texte de popup d'un point (feature = item d'un GeoJson)
     217                map.setGeoJsonFeaturePopup = function (feature, layer) {
    162218                        // Déclarer le contenu de la popup s'il y en a
    163219                        if (feature.properties && (feature.properties.title || feature.properties.description)){
     
    171227                }
    172228
    173                 [(#REM)
     229                /*
    174230                        Il y a pour le moment 2 façons d'analyser le GeoJson calculé
    175231                        en fonction de si on veut faire du clustering (regrouper les points proches)
     
    177233                        la plupart du code, en se passant du js L.geoJson même hors clustering.
    178234                        À réfléchir.
    179                 ]
    180                 <BOUCLE_fonction_analyse_json(CONDITION){si #ENV{cluster}|!={oui}}>
    181                 // Analyse des points et déclaration (sans regroupement des points en cluster)
    182                 var parseGeoJson = function(data, map) {
    183                         var geojson = new L.geoJson('', {[
    184                                 style: (#ENV*{path_styles}|json_encode),
    185                                 ]onEachFeature: function (feature, layer) {
    186                                         // Déclarer l'icone du point
    187                                         setGeoJsonFeatureIcon(feature, layer);
    188                                         // Déclarer le contenu de la popup s'il y en a
    189                                         setGeoJsonFeaturePopup(feature, layer);
    190                                 }
    191                         }).addTo(map);
    192                         geojson.addData(data);
    193                         [(#ENV{autocenterandzoom,#ENV{centrer_auto}}|oui)
    194                         map.fitBounds(geojson.getBounds());]
    195                         [gis_focus_marker((#ENV{id_a_ouvrir}),['(#GET{id})']);]
    196                 }
    197 
    198                 </BOUCLE_fonction_analyse_json>
    199 
    200                 // Analyse des points et déclaration (en regroupant les points en cluster)
    201                 var parseGeoJson = function(data,map) {
    202                         markers = \[\];
    203                         /* Pour chaque points présents, on crée un marqueur */
    204                         $.each(data.features, function(i, feature) {
    205                                 if (feature.geometry.coordinates\[0\]) {
    206                                         var latlng = new L.LatLng(feature.geometry.coordinates\[1\], feature.geometry.coordinates\[0\]);
    207                                         var marker = new L.Marker(latlng);
    208                                         // Déclarer l'icone du point
    209                                         setGeoJsonFeatureIcon(feature, marker);
    210                                         // Déclarer le contenu de la popup s'il y en a
    211                                         setGeoJsonFeaturePopup(feature, marker);
    212 
    213                                         marker.id = feature.id;
    214                                         markers.push(marker);
    215                                 }
    216                         });
    217 
    218                         /* Ajout des marqueurs dans un clustering JS client */
    219                         markerCluster = new L.Marker.Clusterer(map, markers, {[
    220                                 maxZoom: (#ENV{clusterMaxZoom, #ENV{maxZoom}|?{#ENV{maxZoom}|moins{2},''}}),][
    221                                 styles: \[[(#ENV*{clusterStyles}|json_encode)]\](#ENV*{clusterStyles}|oui)]
    222                         });
    223                 }
    224                 <//B_fonction_analyse_json>
    225 
    226                 // ajouter la fonction pour le monde exterieur (compat GIS 3)
    227                 map[(#GET{id})].addJSON = function(data){parseGeoJson(data,mapagenda);}
    228                 map[(#GET{id})].removeAllMarkers = function(){
     235                */
     236                // API parseGeoJson
     237                if (!mapcfg['cluster']){
     238                        // Analyse des points et déclaration (sans regroupement des points en cluster)
     239                        map.parseGeoJson = function(data) {
     240                                var geojson = new L.geoJson('', {
     241                                        style: mapcfg['path_styles'],
     242                                        onEachFeature: function (feature, layer) {
     243                                                // Déclarer l'icone du point
     244                                                map.setGeoJsonFeatureIcon(feature, layer);
     245                                                // Déclarer le contenu de la popup s'il y en a
     246                                                map.setGeoJsonFeaturePopup(feature, layer);
     247                                        }
     248                                }).addTo(map);
     249                                geojson.addData(data);
     250                                if (mapcfg['autocenterandzoom'])
     251                                        map.fitBounds(geojson.getBounds());
     252                                if (mapcfg['open_id'].length)
     253                                        gis_focus_marker(mapcfg['open_id'],map_container);
     254                        }
     255                }
     256                else {
     257                        // Analyse des points et déclaration (en regroupant les points en cluster)
     258                        map.parseGeoJson = function(data) {
     259                                map.markers = [];
     260                                /* Pour chaque points présents, on crée un marqueur */
     261                                $.each(data.features, function(i, feature) {
     262                                        if (feature.geometry.coordinates[0]) {
     263                                                var latlng = new L.LatLng(feature.geometry.coordinates[1], feature.geometry.coordinates[0]);
     264                                                var marker = new L.Marker(latlng);
     265                                                // Déclarer l'icone du point
     266                                                map.setGeoJsonFeatureIcon(feature, marker);
     267                                                // Déclarer le contenu de la popup s'il y en a
     268                                                map.setGeoJsonFeaturePopup(feature, marker);
     269
     270                                                marker.id = feature.id;
     271                                                map.markers.push(marker);
     272                                        }
     273                                });
     274                                /* Ajout des marqueurs dans un clustering JS client */
     275                                var options = {};
     276                                if (mapcfg["clusterMaxZoom"])
     277                                        options["maxZoom"] = mapcfg["clusterMaxZoom"];
     278                                if (mapcfg["clusterStyles"].length)
     279                                        options["styles"] = mapcfg["clusterStyles"];
     280                                map.markerCluster = new L.Marker.Clusterer(map, markers, options);
     281                        }
     282                }
     283
     284                // API Compat Gis3 : addJSON et removeAllMarkers
     285                map.addJSON = map.parseGeoJson
     286                map.removeAllMarkers = function(){
    229287                        for(l in this._layers)
    230288                        if (this._layers[l]._layers){
     
    233291                }
    234292
    235 
    236                 <BOUCLE_definir_les_points_de_la_carte(CONDITION){si #ENV{point}|!={non}}>
    237                 [(#REM)
    238                         \#ENV{args} est présent uniquement lors de l'appel d'un modèle <carte_gis|...>
    239                         dans un texte et contient alors les paramètres passés au modèle manuellement.
    240                         On considère dans ce cas que seuls ces paramètres doivent calculer le json,
    241                         et non pas aussi l'environnement automatique ajouté au modèle (comme objet, id_objet)
    242                         dans lequel le modèle est appelé.
    243                 ]
    244                 // Récupération des points à mettre sur la carte, via json externe
    245                 jQuery.getJSON("[(#URL_PAGE{gis_json}|url_absolue)]",
    246                         {[
    247                                 objets       : "(#ENV{objets,#ENV{class}}|trim)",]
    248                                 <BOUCLE_modeles_args_prioritaires(DATA){source table,#LISTE{
    249                                         id_objet, id_rubrique, id_secteur, id_parent,
    250                                         id_article, id_breve, id_document, id_mot,
    251                                         id_groupe, id_auteur, id_syndic, id_forum,
    252                                         id_gis, id_evenement
    253                                 }}>[#VALEUR : (#ENV{args}|?{#ENV{args/#VALEUR},#ENV{#VALEUR}}|trim),
    254                                 ]</BOUCLE_modeles_args_prioritaires>[
    255                                 media        : "(#ENV{args}|?{#ENV{args/media},#ENV{media}}|trim)",][
    256                                 recherche    : "(#ENV{args}|?{#ENV{args/recherche},#ENV{recherche}})",][
    257                                 mots  : (#ENV{mots}|?{[(#ENV{mots}|json_encode)],''}),][
    258                                 limit : (#ENV{limit,#ENV{limite,500}}|trim)][
    259                                 (#ENV{objets}|=={point_libre}|oui)
    260                                         [,lat : (#GET{lat}|trim)]
    261                                         [,lon : (#GET{lon}|trim)]
    262                                         [,titre : (#ENV{titre}|json_encode)]
    263                                         [,description : (#ENV{description}|json_encode)]
    264                                         [,icone : (#ENV{icone}|json_encode)]
    265                                 ]
    266                         },
    267                         function(data) {
    268                                 if (data){
    269                                         // Charger le json (data) et déclarer les points
    270                                         parseGeoJson(data, map[(#GET{id})]);
     293                if (mapcfg['affiche_points'] && mapcfg['json_points'].length){
     294                        // Récupération des points à mettre sur la carte, via json externe
     295                        var args = mapcfg['json_points']['env'];
     296                        args["objets"] = mapcfg['json_points']['objets'];
     297                        args["limit"] = mapcfg['json_points']['limit'];
     298                        if (args["objets"]=="point_libre"){
     299                                args["lat"]=mapcfg['lat'];
     300                                args["lon"]=mapcfg['lon'];
     301                                args["titre"]=mapcfg['json_points']['titre'];
     302                                args["description"]=mapcfg['json_points']['description'];
     303                                args["icone"]=mapcfg['json_points']['icone'];
     304                        }
     305                        jQuery.getJSON(mapcfg['json_points']['url'],args,
     306                                function(data) {
     307                                        if (data){
     308                                                // Charger le json (data) et déclarer les points
     309                                                map.parseGeoJson(data);
     310                                                $("#"+map_container).trigger('ready',map);
     311                                        }
    271312                                }
    272                         }
    273                 );
    274                 </BOUCLE_definir_les_points_de_la_carte>
    275 
    276 
    277                 <BOUCLE_test_kml(CONDITION){si (#ENV{kml}|oui)}>
    278                         // Définir les couches KML ajoutées à la carte
    279                         #SET{kml, #ENV{kml}}
    280                         [(#GET{kml}|is_array|non) #SET{kml, #ARRAY{0,#GET{kml}}} ]
    281                         <BOUCLE_kml(POUR){tableau #GET{kml}}>
    282                                 [(#VALEUR|intval|oui)
    283                                 var kml_#COMPTEUR_BOUCLE = new L.KML(['(#VALEUR|generer_url_entite{document}|url_absolue)'], {async: true}); ]
    284                                 [(#VALEUR|intval|non)
    285                                 var kml_#COMPTEUR_BOUCLE = new L.KML(['(#VALEUR|copie_locale)'], {async: true}); ]
    286                                 [(#ENV{centrer_fichier}|!={non}|et{#TOTAL_BOUCLE|>{1}|non})
    287                                 kml_#COMPTEUR_BOUCLE.on("loaded", function(e) { map[(#GET{id})].fitBounds(e.target.getBounds()); });]
    288                                 map[(#GET{id})].addLayer(kml_#COMPTEUR_BOUCLE);
    289                         </BOUCLE_kml>
    290                 </BOUCLE_test_kml>
    291 
    292                 <BOUCLE_test_gpx(CONDITION){si (#ENV{gpx}|oui)}>
    293                         // Définir les couches GPX ajoutées à la carte
    294                         #SET{gpx, #ENV{gpx}}
    295                         [(#GET{gpx}|is_array|non) #SET{gpx, #ARRAY{0,#GET{gpx}}} ]
    296                         <BOUCLE_gpx(POUR){tableau #GET{gpx}}>
    297                                 [(#VALEUR|intval|oui)
    298                                 var gpx_#COMPTEUR_BOUCLE = new L.GPX(['(#VALEUR|generer_url_entite{document}|url_absolue)'], {async: true}); ]
    299                                 [(#VALEUR|intval|non)
    300                                 var gpx_#COMPTEUR_BOUCLE = new L.GPX(['(#VALEUR|copie_locale)'], {async: true}); ]
    301                                 [(#ENV{centrer_fichier}|!={non}|et{#TOTAL_BOUCLE|>{1}|non})
    302                                 gpx_#COMPTEUR_BOUCLE.on("loaded", function(e) { map[(#GET{id})].fitBounds(e.target.getBounds()); });]
    303                                 map[(#GET{id})].addLayer(gpx_#COMPTEUR_BOUCLE);
    304                         </BOUCLE_gpx>
    305                 </BOUCLE_test_gpx>
    306 
    307                 [(#ENV{localize_visitor,#ENV{localiser_visiteur}}|oui)
    308                 map[(#GET{id})].locate({setView: true, maxZoom: [(#ENV{zoom,#CONFIG{gis/zoom,0}})]});]
    309 
    310                 $("#map[(#GET{id})]").trigger('ready',map[(#GET{id})]);
     313                        );
     314                }
     315
     316                if (mapcfg['kml'] && mapcfg['kml'].length){
     317                        map.kml = {};
     318                        for(var i in mapcfg['kml']){
     319                                map.kml[i] = new L.KML(mapcfg['kml'][i], {async: true});
     320                                map.kml[i].on("loaded", function(e) { map.fitBounds(e.target.getBounds()); });
     321                                map.addLayer(map.kml[i]);
     322                        }
     323                }
     324                if (mapcfg['gpx'] && mapcfg['gpx'].length){
     325                        map.gpx = {};
     326                        for(var i in mapcfg['gpx']){
     327                                map.gpx[i] = new L.GPX(mapcfg['gpx'][i], {async: true});
     328                                map.gpx[i].on("loaded", function(e) { map.fitBounds(e.target.getBounds()); });
     329                                map.addLayer(map.gpx[i]);
     330                        }
     331                }
     332
     333                if (mapcfg['localize_visitor'])
     334                        map.locate({setView: true, maxZoom: mapcfg['zoom']});
     335
     336                // si pas de points trigger ici
     337                if (!mapcfg['affiche_points'] || !mapcfg['json_points'].length)
     338                        $("#"+map_container).trigger('ready',map);
    311339        }
    312340
     
    314342        // Charger le javascript de GIS et initialiser la carte
    315343        $(function(){
    316                 jQuery.getScript(['(#CONFIG{auto_compress_js}|=={oui}|?{[(#PRODUIRE{fond=javascript/gis.js}|compacte)],[(#PRODUIRE{fond=javascript/gis.js})]})'],function(){
    317                         [(#ENV{cluster}|=={oui}|oui)
    318                                 jQuery.getScript('[(#CHEMIN{javascript/leafclusterer.js}|compacte)]',function(){
    319                         ]
    320                                 if (typeof(callback_map[(#GET{id})]) === "function") {
    321                                         init_map[(#GET{id})](callback_map[(#GET{id})]);
    322                                 } else {
    323                                         init_map[(#GET{id})]();
    324                                 }
    325                         [(#ENV{cluster}|=={oui}|oui)
    326                                 });
    327                         ]
     344                jQuery.getScript('[(#PRODUIRE{fond=javascript/gis.js,cluster=#ENV{cluster,non}})]',function(){
     345                        gis_init_map(map_cfg);
    328346                });
    329347        });
Note: See TracChangeset for help on using the changeset viewer.