source: spip-zone/_plugins_/gis_geometries/saisies/carte.html @ 96540

Last change on this file since 96540 was 96540, checked in by kent1@…, 5 years ago

Un placeholder sur le champ de recherche

File size: 21.4 KB
Line 
1[(#REM)
2
3        Saisie carte
4
5        Parametres optionnels:
6
7        - lat = 48.3                            latitude du centre de la carte
8        - lon = -4.7                            longitude du centre de la carte
9        - zoom = 5                              zoom de la carte
10        - sw_lat = lat - 10°                    latitude du sud-ouest de la bounding box
11        - sw_lon = lon - 10°                    longitude du sud-ouest de la bounding box
12        - ne_lat = lat + 10°                    latitude du nord-est de la bounding box
13        - ne_lon = lon + 10°                    longitude du nord-est de la bounding box
14        - largeur = 100%
15        - hauteur = 350px
16        - nodraw = oui                                          permet de désactiver la barre d'édition pour revenir au comportement par défaut
17        - noimport = oui                                        permet de masquer le champ d'import de fichier GPX/KML
18        - nomajinputs = oui                                     permet de ne pas mettre à jour les inputs de lat / lon / zoom et adresse
19        - boutons = #ARRAY{marker,non}          permet de spécifier les boutons à ne pas afficher dans la barre d'édition (clés possibles : marker, polyline, polygon, rectangle)
20        - path_styles=#ARRAY{color,#fff}        options de style des éléments de la couche GeoJSON (voir http://leafletjs.com/reference.html#path-options)
21
22]
23
24[(#SET{init_lat,#ENV{lat,#CONFIG{gis/lat,0}}})]
25[(#SET{init_lon,#ENV{lon,#CONFIG{gis/lon,0}}})]
26[(#SET{init_zoom,#ENV{zoom,#CONFIG{gis/zoom,0}}})]
27[(#REM) On utilise la bounding box seulement si le centre n'a pas été donné et si les quatre valeurs de la bounding box sont renseignées
28        Les valeurs par defaut sont "centre +/- 10°", ce qui est naze, mais c'est un cas normalement impossible
29]
30[(#ENV{lat}|ou{#ENV{lon}}|non|et{#ENV{sw_lat}}|et{#ENV{sw_lon}}|et{#ENV{ne_lat}}|et{#ENV{ne_lon}})
31        #SET{utiliser_bb, oui}
32        #SET{init_sw_lat,#ENV{sw_lat,#GET{lat}|moins{10}}}
33        #SET{init_sw_lon,#ENV{sw_lon,#GET{lon}|moins{10}}}
34        #SET{init_ne_lat,#ENV{ne_lat,#GET{lat}|plus{10}}}
35        #SET{init_ne_lon,#ENV{ne_lon,#GET{lon}|plus{10}}}
36]
37
38<[(#VAL{li}|saisie_balise_structure_formulaire)] class="pleine_largeur editer editer_[(#ENV{nom})][ (#ENV{li_class})][ saisie_(#ENV{type_saisie})]"[ data-id="(#ENV{id_saisie})"]>
39#ENV*{inserer_debut}
40<div id="map_[(#ENV{nom})]" name="formMap_[(#ENV{nom})]" class="formMap" style="width: #ENV{largeur,100%}; height: #ENV{hauteur,350px}"></div>
41<script type="text/javascript">
42/*<![CDATA[*/
43var form_map_[(#ENV{nom})],
44        editableLayers_[(#ENV{nom})],
45        annuler_geocoder_[(#ENV{nom})] = 0;
46[(#ENV{recherche}|!={non}|oui|et{#CONFIG{gis/geocoder}|oui})
47[(#SET{geocoder,oui})]
48var geocoder;]
49
50(function($){
51        var marker;
52       
53        var maj_inputs = function(map,layer,data,action) {
54                [(#GET{geocoder}|oui)
55                if (action != 'geocoding') {
56                        var f = geocoder.geocode(data);
57                }]
58                var zoom = map.getZoom();
59                if(data.lng <= -180) data.lng = data.lng+360
60                else if(data.lng > 180) data.lng = data.lng-360;
61                [(#ENV{nomajinputs,non}|=={oui}|non)
62                $('#champ_#ENV{champ_zoom,zoom}').val(zoom);]
63                if(action == 'click'){
64                        [(#ENV{nomajinputs,non}|=={oui}|non)
65                        $('#champ_#ENV{champ_lat,lat}').val(data.lat);
66                        $('#champ_#ENV{champ_lon,lon}').val(data.lng);]
67                        annuler_geocoder_[(#ENV{nom})] = 1;
68                        map.panTo(data);
69                        marker.setLatLng(data);
70                }
71                else if(annuler_geocoder_[(#ENV{nom})] != 1){
72                        if(data.point == 'undefined'){
73                                [(#ENV{nomajinputs,non}|=={oui}|non)
74                                $('#champ_#ENV{champ_lat,lat}').val(data.lat);
75                                $('#champ_#ENV{champ_lon,lon}').val(data.lng);]
76                                map.panTo(data);
77                                marker.setLatLng(data);
78                        }else{
79                                [(#ENV{nomajinputs,non}|=={oui}|non)
80                                $('#champ_#ENV{champ_lat,lat}').val(data.point.lat);
81                                $('#champ_#ENV{champ_lon,lon}').val(data.point.lng);]
82                                map.panTo(data.point);
83                                marker.setLatLng(data.point);
84                        }
85                        $('#champ_#ENV{champ_type,type}').val('Point');
86                        $('#champ_#ENV{champ_geojson,geojson}').val(JSON.stringify(marker.toGeoJSON()));
87                }
88                if (!marker._map)
89                        layer.addLayer(marker);
90        }
91       
92        [(#GET{geocoder}|oui)
93        function geocode(query) {
94                if(! query.error){
95                        [(#ENV{nomajinputs,non}|=={oui}|non)
96                        $('#champ_#ENV{champ_adresse,adresse}').val(query.street);
97                        $('#champ_#ENV{champ_code_postal,code_postal}').val(query.postcode);
98                        $('#champ_#ENV{champ_ville,ville}').val(query.locality);
99                        $('#champ_#ENV{champ_departement,departement}').val(query.departement);
100                        $('#champ_#ENV{champ_region,region}').val(query.region);
101                        $('#champ_#ENV{champ_pays,pays}').val(query.country);
102                        $('#champ_#ENV{champ_code_pays,code_pays}').val(query.country_code);]
103                        maj_inputs(form_map_[(#ENV{nom})],editableLayers_[(#ENV{nom})],query,'geocoding');
104                }else{
105                        if(query.search == 'undefined'){
106                                alert('<:gis:erreur_geocoder:>\n'+query.search);
107                        }else{
108                                alert('<:gis:erreur_geocoder:>');
109                        }
110                }
111        }]
112       
113        var init_map = function(callback) {
114                var marker_dragend = function(e){
115                        if(e.target){
116                                layer = e.target;
117                        }
118                        else{
119                                layer = e;
120                        }
121                        $('#champ_#ENV{champ_geojson,geojson}').val(JSON.stringify(layer.toGeoJSON()));
122                        maj_inputs(form_map_[(#ENV{nom})],editableLayers_[(#ENV{nom})],layer._latlng,'click');
123                }
124                var layer_edit = function(e){
125                        if(e.target)
126                                layer = e.target;
127                        else
128                                layer = e;
129                        $('#champ_#ENV{champ_geojson,geojson}').val(JSON.stringify(layer.toGeoJSON()));
130                        var center = layer.getBounds().getCenter();
131                        [(#ENV{nomajinputs,non}|=={oui}|non)
132                        $('#champ_#ENV{champ_lat,lat}').val(center.lat);
133                        $('#champ_#ENV{champ_lon,lon}').val(center.lng);]
134                }
135                var gisdraw_change_controls = function(options){
136                        form_map_[(#ENV{nom})].removeControl(drawControl);
137                        drawControl = new L.Control.Draw(options)
138                        form_map_[(#ENV{nom})].addControl(drawControl);
139                        form_map_[(#ENV{nom})].drawControl = drawControl;
140                }
141                // creer la carte
142                var map_container = 'map_[(#ENV{nom})]';
143                form_map_[(#ENV{nom})] = new L.Map(map_container);
144               
145                // affecter sur l'objet du DOM
146                jQuery("#"+map_container).get(0).map=form_map_[(#ENV{nom})];
147
148                // appeler l'éventuelle fonction de callback
149                if (callback && typeof(callback) === "function") {
150                        form_map_[(#ENV{nom})].on('load',function(e){
151                                callback(e.target);
152                        });
153                }
154               
155                form_map_[(#ENV{nom})].attributionControl.setPrefix('');
156               
157                marker = new L.Marker(new L.LatLng(#ENV{lat,0}, #ENV{lon,0}), {draggable: [(#ENV{nodraw}|?{true,false})]});
158               
159                //default layer
160                #SET{layer_defaut,#REM|gis_layer_defaut} #SET{layers,#EVAL{$GLOBALS['gis_layers']}}
161                var [(#GET{layer_defaut})] = [new (#GET{layers}|table_valeur{#GET{layer_defaut}/layer})];
162                form_map_[(#ENV{nom})].addLayer([(#GET{layer_defaut})]);
163               
164                <B_layers>
165                var layers_control = new L.Control.Layers();
166                layers_control.addBaseLayer([(#GET{layer_defaut})],["(#GET{layers}|table_valeur{#GET{layer_defaut}/nom})"]);
167                <BOUCLE_layers(DATA){source table, #GET{layers}}{si #ENV{control_type,#ENV{controle_type}}|!={non}|et{#ENV{no_control,#ENV{aucun_controle}}|!={oui}}|et{#CONFIG{gis/layers,#ARRAY}|count|>{1}|oui}|oui}>[
168                (#CLE|!={#GET{layer_defaut}}|oui|et{#CLE|in_array{#CONFIG{gis/layers,#ARRAY}}|oui}|oui)
169                layers_control.addBaseLayer([new (#VALEUR|table_valeur{layer})],"[(#VALEUR|table_valeur{nom})]");]
170                </BOUCLE_layers>
171                form_map_[(#ENV{nom})].addControl(layers_control);
172                // ajouter l'objet du controle de layers à la carte pour permettre d'y accéder depuis le callback
173                form_map_[(#ENV{nom})].layersControl = layers_control;
174                // classe noajax sur le layer_control pour éviter l'ajout de hidden par SPIP
175                $(layers_control._form).addClass('noajax');
176                </B_layers>
177               
178                [(#GET{utiliser_bb}|non)
179                form_map_[(#ENV{nom})].setView(new L.LatLng([(#GET{init_lat})], [(#GET{init_lon})]), [(#GET{init_zoom})]);]
180
181                [(#GET{utiliser_bb}|oui)
182                form_map_[(#ENV{nom})].fitBounds(
183                        new L.LatLngBounds(
184                                new L.LatLng([(#GET{init_sw_lat})], [(#GET{init_sw_lon})]),
185                                new L.LatLng([(#GET{init_ne_lat})], [(#GET{init_ne_lon})])
186                        )
187                );
188                // mettre à jour les champs de latitude et longitude quand la carte est chargée
189                // a voir si on le fait dans tous les cas, pas seulement pour la boundingbox, comme pour le zoom
190                [(#ENV{nomajinputs,non}|=={oui}|non)
191                form_map_[(#ENV{nom})].on('load', function(e) {
192                        $('#champ_#ENV{champ_lat,lat}').val(e.latlng.lat);
193                        $('#champ_#ENV{champ_lon,lon}').val(e.latlng.lon);
194                });]]
195
196                [(#REM)
197                       
198                        On ajoute notre point (ou tout autre élément) dans un FeatureGroup
199                       
200                ]editableLayers_[(#ENV{nom})] = new L.FeatureGroup();
201                form_map_[(#ENV{nom})].addLayer(editableLayers_[(#ENV{nom})]);
202
203                [(#GET{geocoder}|oui)
204                geocoder = new L.Geocoder(geocode,{acceptLanguage:'#ENV{lang}'});]
205               
206                <BOUCLE_gis(GIS){id_gis}>
207                var data = {
208                        "type": "FeatureCollection",
209                        "features": [
210                                {"type": "Feature",
211                                        ["geometry": (#GEOMETRY|wkt_to_json),]
212                                        "id":"#ENV{id_gis,oui}",
213                                        "properties": {
214                                                "title":[(#ENV{titre,''}|supprimer_numero|json_encode)],
215                                                "description":[(#ENV{descriptif,''}|json_encode)][
216                                                (#LOGO_GIS|gis_icon_properties)]
217                                        }
218                                }]
219                }
220                var geojson = new L.geoJson('', {[
221                        style: (#ENV*{path_styles}|?{[(#ENV*{path_styles}|json_encode)],[(#GEOMETRY_STYLES|appliquer_filtre{geometry_styles_to_json})]}),
222                        ]onEachFeature: function (feature, layer) {
223                                editableLayers_[(#ENV{nom})].addLayer(layer);
224                                if (feature.geometry.type == 'Polygon' || feature.geometry.type == 'LineString') {
225                                        // centrer la carte sur les bounds de l'objet
226                                        form_map_[(#ENV{nom})].fitBounds(layer.getBounds());
227                                        // surveiller les changements sur les points de l'objet
228                                        layer.on("edit", function(e){
229                                                layer_edit(e);
230                                        });
231                                } else if (feature.geometry.type == 'Point') {
232                                        marker = layer;
233                                        if (feature.properties && feature.properties.icon){
234                                                layer.setIcon(new L.Icon({
235                                                        iconUrl: feature.properties.icon,
236                                                        iconSize: new L.Point( feature.properties.icon_size\[0\], feature.properties.icon_size\[1\] ),
237                                                        iconAnchor: new L.Point( feature.properties.icon_anchor\[0\], feature.properties.icon_anchor\[1\] ),
238                                                        popupAnchor: new L.Point( feature.properties.popup_anchor\[0\], feature.properties.popup_anchor\[1\] )
239                                                }));
240                                        }
241                                        if (feature.properties && feature.properties.title){
242                                                layer.bindPopup(feature.properties.title);
243                                        }
244                                        // rendre le marker draggable
245                                        layer.options.draggable = true;
246                                        // surveiller les changements sur le point
247                                        layer.on("dragend", function(e){
248                                                marker_dragend(e);
249                                        });
250                                }
251                        }
252                }).addTo(form_map_[(#ENV{nom})]);
253                geojson.addData(data);
254                </BOUCLE_gis>
255                </B_gis>
256                <BOUCLE_si_geojson(CONDITION){si #ENV{geojson}}>
257                var geojson = new L.geoJson('', {[
258                        style: (#ENV*{path_styles}|json_encode),
259                        ]onEachFeature: function (feature, layer) {
260                                editableLayers_[(#ENV{nom})].addLayer(layer);
261                                form_map_[(#ENV{nom})].removeLayer(layer);
262                                if (feature.type == 'Polygon' || feature.type == 'MultiPolygon' || feature.type == 'LineString') {
263                                        // centrer la carte sur les bounds de l'objet
264                                        form_map_[(#ENV{nom})].fitBounds(layer.getBounds());
265                                        // surveiller les changements sur les points de l'objet
266                                        layer.on("edit", function(e){
267                                                layer_edit(e);
268                                        });
269                                } else if (feature.geometry.type == 'Point') {
270                                        marker = layer;
271                                        if (feature.properties && feature.properties.icon){
272                                                layer.setIcon(new L.Icon({
273                                                        iconUrl: feature.properties.icon,
274                                                        iconSize: new L.Point( feature.properties.icon_size\[0\], feature.properties.icon_size\[1\] ),
275                                                        iconAnchor: new L.Point( feature.properties.icon_anchor\[0\], feature.properties.icon_anchor\[1\] ),
276                                                        popupAnchor: new L.Point( feature.properties.popup_anchor\[0\], feature.properties.popup_anchor\[1\] )
277                                                }));
278                                        }
279                                        if (feature.properties && feature.properties.title){
280                                                layer.bindPopup(feature.properties.title);
281                                        }
282                                        // rendre le marker draggable
283                                        layer.options.draggable = true;
284                                        // surveiller les changements sur le point
285                                        layer.on("dragend", function(e){
286                                                marker_dragend(e);
287                                        });
288                                }
289                        }
290                }).addTo(form_map_[(#ENV{nom})]);
291                geojson.addData([(#ENV**{geojson}|html_entity_decode)]);
292               
293                </BOUCLE_si_geojson>
294                <//B_gis>
295                [(#REM) 
296               
297                        afficher les outils de dessin uniquement lors de la création d'objet
298                       
299                ][(#ENV{nodraw}|non)
300                // i18n des chaines de Leaflet.draw
301                L.drawLocal.draw.toolbar.actions.title = '<:gis:toolbar_actions_title|texte_script:>';
302                L.drawLocal.draw.toolbar.actions.text = '<:bouton_annuler|texte_script:>';
303                L.drawLocal.draw.toolbar.buttons.polyline = '<:gis:toolbar_buttons_polyline|texte_script:>';
304                L.drawLocal.draw.toolbar.buttons.polygon = '<:gis:toolbar_buttons_polygon|texte_script:>';
305                L.drawLocal.draw.toolbar.buttons.rectangle = '<:gis:toolbar_buttons_rectangle|texte_script:>';
306                L.drawLocal.draw.toolbar.buttons.circle = '<:gis:toolbar_buttons_circle|texte_script:>';
307                L.drawLocal.draw.toolbar.buttons.marker = '<:gis:toolbar_buttons_marker|texte_script:>';
308                L.drawLocal.draw.toolbar.undo.title = '<:gis:toolbar_undo_title|texte_script:>';
309                L.drawLocal.draw.toolbar.undo.text = '<:gis:toolbar_undo_text|texte_script:>';
310                L.drawLocal.draw.handlers.marker.tooltip.start = '<:gis:toolbar_handlers_marker_tooltip_start|texte_script:>';
311                L.drawLocal.draw.handlers.polygon.tooltip.start = '<:gis:toolbar_handlers_polygon_tooltip_start|texte_script:>';
312                L.drawLocal.draw.handlers.polygon.tooltip.cont = '<:gis:toolbar_handlers_polygon_tooltip_cont|texte_script:>';
313                L.drawLocal.draw.handlers.polygon.tooltip.end = '<:gis:toolbar_handlers_polygon_tooltip_end|texte_script:>';
314                L.drawLocal.draw.handlers.polyline.tooltip.start = '<:gis:toolbar_handlers_polyline_tooltip_start|texte_script:>';
315                L.drawLocal.draw.handlers.polyline.tooltip.cont = '<:gis:toolbar_handlers_polyline_tooltip_cont|texte_script:>';
316                L.drawLocal.draw.handlers.polyline.tooltip.end = '<:gis:toolbar_handlers_polyline_tooltip_end|texte_script:>';
317                L.drawLocal.draw.handlers.rectangle.tooltip.start = '<:gis:toolbar_handlers_rectangle_tooltip_start|texte_script:>';
318                L.drawLocal.draw.handlers.simpleshape.tooltip.end = '<:gis:toolbar_handlers_simpleshape_tooltip_end|texte_script:>';
319                L.drawLocal.edit.toolbar.actions.save.text = '<:bouton_enregistrer|texte_script:>';
320                L.drawLocal.edit.toolbar.actions.save.title = '<:gis:bouton_enregistrer_title|texte_script:>';
321                L.drawLocal.edit.toolbar.actions.cancel.text = '<:bouton_annuler|texte_script:>';
322                L.drawLocal.edit.toolbar.actions.cancel.title = '<:gis:bouton_annuler_title|texte_script:>';
323                L.drawLocal.edit.toolbar.buttons.edit = '<:gis:toolbar_edit_buttons_edit|texte_script:>';
324                L.drawLocal.edit.toolbar.buttons.editDisabled = '<:gis:toolbar_edit_buttons_editdisabled|texte_script:>';
325                L.drawLocal.edit.toolbar.buttons.remove = '<:gis:toolbar_edit_buttons_remove|texte_script:>';
326                L.drawLocal.edit.toolbar.buttons.removeDisabled = '<:gis:toolbar_edit_buttons_removedisabled|texte_script:>';
327                L.drawLocal.edit.handlers.edit.tooltip.text = '<:gis:toolbar_edit_handlers_edit_tooltip_text|texte_script:>';
328                L.drawLocal.edit.handlers.edit.tooltip.subtext = '<:gis:toolbar_edit_handlers_edit_tooltip_subtext|texte_script:>';
329                L.drawLocal.edit.handlers.remove.tooltip.text = '<:gis:toolbar_edit_handlers_remove_tooltip_text|texte_script:>';
330
331                var drawOptions = {
332                        position: 'topleft',
333                        draw: {
334                                polyline: [(#ENV{boutons}|table_valeur{polyline}|=={non}|oui)false][
335                                (#ENV{boutons}|table_valeur{polyline}|=={non}|non){
336                                        shapeOptions: { color: '#0033ff' }
337                                }],
338                                polygon: [(#ENV{boutons}|table_valeur{polygon}|=={non}|oui)false][
339                                (#ENV{boutons}|table_valeur{polygon}|=={non}|non){
340                                        shapeOptions: { color: '#0033ff' }
341                                }],
342                                marker: [(#ENV{boutons}|table_valeur{marker}|=={non}|?{false,true})],
343                                circle: false,
344                                rectangle: [(#ENV{boutons}|table_valeur{rectangle}|=={non}|oui)false][
345                                (#ENV{boutons}|table_valeur{rectangle}|=={non}|non){
346                                        shapeOptions: { color: '#0033ff' }
347                                }]
348                        },
349                        edit: {
350                                featureGroup: editableLayers_[(#ENV{nom})]
351                        }
352                }, drawOptionsBlocked = {
353                        position: 'topleft',
354                        draw: false,
355                        edit: {
356                                featureGroup: editableLayers_[(#ENV{nom})]
357                        }
358                }, edited = false;
359               
360                [(#REM)
361               
362                        Si on a un objet, on limite l'usage de la toolbar,
363                        sinon on a accès aux outils de dessin
364                ]
365                if(Object.keys(editableLayers_[(#ENV{nom})]._layers).length >= 1){
366                        var drawControl = new L.Control.Draw(drawOptionsBlocked);
367                }
368                else{
369                        var drawControl = new L.Control.Draw(drawOptions);
370                }
371                form_map_[(#ENV{nom})].addControl(drawControl);
372                form_map_[(#ENV{nom})].drawControl = drawControl;
373                form_map_[(#ENV{nom})].on('draw:created', function(e) {
374                        var type = e.layerType,
375                                layer = e.layer;
376                        if (type === 'marker') {
377                                marker.setLatLng(layer._latlng);
378                                form_map_[(#ENV{nom})].removeLayer(marker);
379                                editableLayers_[(#ENV{nom})].addLayer(marker);
380                                $('#champ_#ENV{champ_type,type}').val('Point');
381                                marker_dragend(layer);
382                                marker.on("dragend", function(e){
383                                        marker_dragend(e);
384                                });
385                        } else {
386                                editableLayers_[(#ENV{nom})].addLayer(layer);
387                                if (type === 'polygon' || type === 'rectangle'){
388                                        $('#champ_#ENV{champ_type,type}').val('Polygon');
389                                }else if (type === 'polyline'){
390                                        $('#champ_#ENV{champ_type,type}').val('LineString');
391                                }
392                                layer_edit(layer);
393                                layer.on("edit", function(e){
394                                        layer_edit(e);
395                                });
396                        }
397                        gisdraw_change_controls(drawOptionsBlocked);
398                });
399                form_map_[(#ENV{nom})].on('draw:deleted', function(e) {
400                        if(Object.keys(e.layers._layers).length >= 1){
401                                [(#REM)
402                                       
403                                        La forme est supprimée, donc on vide l'ensemble des champs
404                                       
405                                ]
406                                [(#ENV{nomajinputs,non}|=={oui}|non)
407                                $('#champ_[(#ENV{champ_lat,lat})],#champ_[(#ENV{champ_lon,lon})],#champ_[(#ENV{champ_type,type})],#champ_[(#ENV{champ_geojson,geojson})]').val('');
408                                $('#champ_[(#ENV{champ_adresse,adresse})],#champ_[(#ENV{champ_code_postal,code_postal})],#champ_[(#ENV{champ_ville,ville})],#champ_[(#ENV{champ_departement,departement})],#champ_[(#ENV{champ_region,region})],#champ_[(#ENV{champ_pays,pays})],#champ_[(#ENV{champ_code_pays,code_pays})]').val('');]
409                                [(#REM)
410
411                                        On passe par un settimeout ici pour laisser draw finir son action
412                                        https://github.com/Leaflet/Leaflet.draw/issues/369
413                                       
414                                ]
415                                setTimeout(function(){gisdraw_change_controls(drawOptions)},200);
416                        }
417                });
418                /**
419                 * Au editstart, on met la variable edited à false
420                 */
421                form_map_[(#ENV{nom})].on('draw:editstart', function(e) {
422                        edited = false;
423                });
424                /**
425                 * Au edited, on met la variable edited à true (il y a eu edition)
426                 */
427                form_map_[(#ENV{nom})].on('draw:edited', function(e) {
428                        edited = true;
429                });
430                /**
431                 * Au editstop, on vérifie la variable edited, si true, il y a eu modif, donc on ne fait rien
432                 * si false, on remet les valeurs par défaut avant édition (bouton annuler)
433                 */
434                form_map_[(#ENV{nom})].on('draw:editstop', function(e) {
435                        if(!edited){
436                                var type = $('#champ_#ENV{champ_type,type}').val();
437                                editableLayers_[(#ENV{nom})].eachLayer(function (layer) {
438                                        if (type === 'Point') {
439                                                marker_dragend(layer);
440                                        } else {
441                                                layer_edit(layer);
442                                        }
443                                });
444                        }else{
445                                edited = false;
446                        }
447                });]
448                [(#ENV{nodraw}|oui)
449                // option nodraw, l'objet est un point
450                $('#champ_#ENV{champ_type,type}').val('Point');
451                // mettre a jour les coordonnees quand on clique la carte
452                form_map_[(#ENV{nom})].on('click', function(e) {
453                        annuler_geocoder_[(#ENV{nom})] = 0;
454                        maj_inputs(form_map_[(#ENV{nom})],editableLayers_[(#ENV{nom})],e.latlng,'click');
455                });
456                // mettre à jour le champ geosjon et le marker quand on change les valeur de lat ou lon
457                [(#ENV{nomajinputs,non}|=={oui}|non)
458                $('#champ_#ENV{champ_lat,lat}, #champ_#ENV{champ_lon,lon}').change(function(){
459                        var new_lat = $('#champ_#ENV{champ_lat,lat}').val();
460                        var new_lon = $('#champ_#ENV{champ_lon,lon}').val();
461                        var new_center = new L.LatLng(new_lat, new_lon);
462                        marker.setLatLng(new_center);
463                        form_map_[(#ENV{nom})].panTo(new_center);
464                        $('#champ_#ENV{champ_geojson,geojson}').val('{"type":"Point","coordinates":\['+ new_lon +','+ new_lat +'\]}');
465                });]]
466               
467                [(#ENV{nodraw}|oui)
468                // mettre à jour les coordonnées quand on déplace le marker
469                marker.on('dragend', function(e){
470                        marker_dragend(e);
471                });]
472               
473                // mettre à jour le zoom quand on le modifie
474                [(#ENV{nomajinputs,non}|=={oui}|non)
475                form_map_[(#ENV{nom})].on('zoomend', function(e) {
476                        $('#champ_#ENV{champ_zoom,zoom}').val(e.target._zoom);
477                });]
478               
479                [(#GET{geocoder}|oui)
480                // geocoder si clic...
481                $('a##ENV{nom}_rechercher_geocodage').css("cursor","pointer").click(function(){
482                        var address = $("#champ_#ENV{nom}_geocoder").val();
483                        annuler_geocoder_[(#ENV{nom})] = 0;
484                        geocoder.geocode(address);
485                });
486
487                // ne pas soumettre le formulaire si on presse Entree depuis le champ de recherche
488                $('#champ_#ENV{nom}_geocoder').keypress(function(e){
489                        if (e.which == 13) {
490                                $('a##ENV{nom}_rechercher_geocodage').trigger("click");
491                                return false;
492                        }
493                });]
494               
495                [(#ENV{id_gis}|non|ou{#ENV{id_gis}|=={oui}}|et{#CONFIG{gis/geolocaliser_user_html5}|=={on}}|oui)
496                form_map_[(#ENV{nom})].locate({setView: true, maxZoom: [(#GET{init_zoom})]});]
497               
498        };
499
500        $(function(){
501                jQuery.getScript('[(#PRODUIRE{fond=javascript/gis.js}|compacte)]',function(){
502                        if(typeof(callback_form_map_[(#ENV{nom})]) === "function"){
503                                init_map(callback_form_map_[(#ENV{nom})]);
504                        }
505                        else if (typeof(callback_form_map) === "function") {
506                                init_map(callback_form_map);
507                        } else {
508                                init_map();
509                        }
510                });
511        });
512       
513})(jQuery);
514/*]]>*/
515</script>
516#ENV*{inserer_fin}
517</[(#VAL{li}|saisie_balise_structure_formulaire)]>
518[(#GET{geocoder}|oui)
519<[(#VAL{li}|saisie_balise_structure_formulaire)] class="rechercher_adresse editer editer_[(#ENV{nom})]">
520        <label for="champ_#ENV{nom}_geocoder"><:gis:label_rechercher_address:></label>
521        <input type="text" class="text" name="champ_#ENV{nom}_geocoder" id="champ_#ENV{nom}_geocoder" placeholder="<:gis:placeholder_geocoder|attribut_html:>" value="" />
522        <a id="#ENV{nom}_rechercher_geocodage"><:info_rechercher:></a>
523</[(#VAL{li}|saisie_balise_structure_formulaire)]>]
524#FILTRE{trim}
525<!--extragis-->
Note: See TracBrowser for help on using the repository browser.