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

Last change on this file since 107764 was 107764, checked in by brunobergot@…, 3 years ago

report de r107763 : filtre compacte inutile

File size: 22.9 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                maj_inputs = function (map, layer, data, action) {
53                        [(#GET{geocoder}|oui)
54                        if (action != 'geocoding') {
55                                var f = geocoder.geocode(data);
56                        }]
57                        if (data.lng <= -180) {
58                                data.lng = data.lng + 360;
59                        } else if (data.lng > 180) {
60                                data.lng = data.lng - 360;
61                        }[(#ENV{nomajinputs,non}|=={oui}|non)
62                        var zoom = map.getZoom();
63                        $('#champ_#ENV{champ_zoom,zoom}').val(zoom);]
64                        if (action === 'click') {[(#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                                marker.setLatLng(data);
69                                map.panTo(data);
70                        } else if (annuler_geocoder_[(#ENV{nom})] !== 1) {
71                                if (data.point === 'undefined') {
72                                        data.point = data;
73                                }
74                                [(#ENV{nomajinputs,non}|=={oui}|non)
75                                $('#champ_#ENV{champ_lat,lat}').val(data.point.lat);
76                                $('#champ_#ENV{champ_lon,lon}').val(data.point.lng);]
77                                map.panTo(data.point);
78                                marker.setLatLng(data.point);
79                                marker.options.editable = true;
80                                marker.off('dragend').on('dragend', function (e) {
81                                        marker_dragend(e);
82                                });
83                                $('#champ_#ENV{champ_type,type}').val('Point');
84                                $('#champ_#ENV{champ_geojson,geojson}').val(JSON.stringify(marker.toGeoJSON()));
85                        }
86                        if (!marker._map) {
87                                layer.addLayer(marker);
88                        }
89                },
90                marker_dragend = function (e) {
91                        var layer = e;
92                        if (e.target) {
93                                layer = e.target;
94                        }
95                        $('#champ_#ENV{champ_geojson,geojson}').val(JSON.stringify(layer.toGeoJSON()));
96                        maj_inputs(form_map_[(#ENV{nom})], editableLayers_[(#ENV{nom})], layer._latlng, 'click');
97                };
98
99        [(#GET{geocoder}|oui)
100        function geocode (query) {
101                if (!query.error) {
102                        [(#ENV{nomajinputs,non}|=={oui}|non)
103                        $('#champ_#ENV{champ_adresse,adresse}').val(query.street);
104                        $('#champ_#ENV{champ_code_postal,code_postal}').val(query.postcode);
105                        $('#champ_#ENV{champ_ville,ville}').val(query.locality);
106                        $('#champ_#ENV{champ_departement,departement}').val(query.departement);
107                        $('#champ_#ENV{champ_region,region}').val(query.region);
108                        $('#champ_#ENV{champ_pays,pays}').val(query.country);
109                        $('#champ_#ENV{champ_code_pays,code_pays}').val(query.country_code);]
110                        maj_inputs(form_map_[(#ENV{nom})], editableLayers_[(#ENV{nom})], query, 'geocoding');
111                        [(#REM)
112                                Ajouter un évènement (via Leaflet) si le geocoder retourne quelque chose
113                        ]
114                        form_map_[(#ENV{nom})].fire('geocoder_ok', {query : query});
115                } else {
116                        if (query.search == 'undefined') {
117                                alert('<:gis:erreur_geocoder:>\n'+query.search);
118                        } else {
119                                alert('<:gis:erreur_geocoder:>');
120                        }
121                        [(#REM)
122                                Ajouter un évènement (via Leaflet) si le geocoder retourne une erreur
123                        ]
124                        form_map_[(#ENV{nom})].fire('geocoder_fail', {query : query});
125                }
126                return query;
127        }]
128
129        var init_map = function (callback) {
130                [(#REM)
131
132                        creer la carte
133
134                ]var map_container = 'map_[(#ENV{nom})]';
135                form_map_[(#ENV{nom})] = new L.Map(map_container);
136                [(#REM)
137
138                        affecter sur l'objet du DOM
139
140                ]$("#" + map_container).get(0).map = form_map_[(#ENV{nom})];
141
142                var layer_edit = function (e) {
143                        var layer = e;
144                        if (e.target) {
145                                layer = e.target;
146                        }
147                        $('#champ_#ENV{champ_geojson,geojson}').val(JSON.stringify(layer.toGeoJSON()));
148                        [(#ENV{nomajinputs,non}|=={oui}|non)
149                        var center = layer.getBounds().getCenter();
150                        $('#champ_#ENV{champ_lat,lat}').val(center.lat);
151                        $('#champ_#ENV{champ_lon,lon}').val(center.lng);]
152                }[,(#ENV{nodraw}|non)
153                gisdraw_change_controls = function (options) {
154                        form_map_[(#ENV{nom})].removeControl(drawControl);
155                        drawControl = new L.Control.Draw(options);
156                        form_map_[(#ENV{nom})].addControl(drawControl);
157                        form_map_[(#ENV{nom})].drawControl = drawControl;
158                }];
159                [(#REM)
160
161                        appeler l'éventuelle fonction de callback
162
163                ]if (callback && typeof (callback) === "function") {
164                        form_map_[(#ENV{nom})].on('load', function (e) {
165                                callback(e.target);
166                        });
167                }
168
169                form_map_[(#ENV{nom})].attributionControl.setPrefix('');
170                marker = new L.Marker(new L.LatLng(#ENV{lat,0}, #ENV{lon,0}), {draggable: [(#ENV{nodraw}|?{true,false})]});
171                [(#REM)
172
173                        default layer
174
175                ]#SET{layer_defaut,#REM|gis_layer_defaut} #SET{layers,#EVAL{$GLOBALS['gis_layers']}}
176                var [(#GET{layer_defaut})] = [new (#GET{layers}|table_valeur{#GET{layer_defaut}/layer})];
177                form_map_[(#ENV{nom})].addLayer([(#GET{layer_defaut})]);
178                <B_layers>
179                var layers_control = new L.Control.Layers();
180                layers_control.addBaseLayer([(#GET{layer_defaut})],["(#GET{layers}|table_valeur{#GET{layer_defaut}/nom})"]);
181                <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}>[
182                (#CLE|!={#GET{layer_defaut}}|oui|et{#CLE|in_array{#CONFIG{gis/layers,#ARRAY}}|oui}|oui)
183                layers_control.addBaseLayer([new (#VALEUR|table_valeur{layer})],"[(#VALEUR|table_valeur{nom})]");]
184                </BOUCLE_layers>
185                form_map_[(#ENV{nom})].addControl(layers_control);
186                // ajouter l'objet du controle de layers à la carte pour permettre d'y accéder depuis le callback
187                form_map_[(#ENV{nom})].layersControl = layers_control;
188                // classe noajax sur le layer_control pour éviter l'ajout de hidden par SPIP
189                $(layers_control._form).addClass('noajax');
190                </B_layers>
191                [(#GET{utiliser_bb}|non)
192                form_map_[(#ENV{nom})].setView(new L.LatLng([(#GET{init_lat})], [(#GET{init_lon})]), [(#GET{init_zoom})]);]
193                [(#GET{utiliser_bb}|oui)
194                form_map_[(#ENV{nom})].fitBounds(
195                        new L.LatLngBounds(
196                                new L.LatLng([(#GET{init_sw_lat})], [(#GET{init_sw_lon})]),
197                                new L.LatLng([(#GET{init_ne_lat})], [(#GET{init_ne_lon})])
198                        )
199                );
200                [(#ENV{nomajinputs,non}|=={oui}|non)
201                [(#REM)
202                        mettre à jour les champs de latitude et longitude quand la carte est chargée
203                        a voir si on le fait dans tous les cas, pas seulement pour la boundingbox, comme pour le zoom
204                ]
205                form_map_[(#ENV{nom})].on('load', function(e) {
206                        $('#champ_#ENV{champ_lat,lat}').val(e.latlng.lat);
207                        $('#champ_#ENV{champ_lon,lon}').val(e.latlng.lon);
208                });]]
209
210                [(#REM)
211
212                        On ajoute notre point (ou tout autre élément) dans un FeatureGroup
213
214                ]editableLayers_[(#ENV{nom})] = new L.FeatureGroup();
215                form_map_[(#ENV{nom})].addLayer(editableLayers_[(#ENV{nom})]);
216
217                [(#GET{geocoder}|oui)
218                geocoder = new L.Geocoder(geocode,{acceptLanguage:'#ENV{lang}'});]
219
220                <BOUCLE_gis(GIS){id_gis}>
221                var data = {
222                        "type": "FeatureCollection",
223                        "features": [
224                                {"type": "Feature",
225                                        ["geometry": (#GEOMETRY|wkt_to_json),]
226                                        "id":"#ENV{id_gis,oui}",
227                                        "properties": {
228                                                "title":[(#ENV{titre,''}|html2unicode|extraire_multi|json_encode)],
229                                                "description":[(#ENV{descriptif,''}|html2unicode|propre|json_encode)][
230                                                (#LOGO_GIS|gis_icon_properties)]
231                                        }
232                                }]
233                }
234                var geojson = new L.geoJson('', {[
235                        style: (#ENV*{path_styles}|?{[(#ENV*{path_styles}|json_encode)],[(#GEOMETRY_STYLES|appliquer_filtre{geometry_styles_to_json})]}),
236                        ]onEachFeature: function (feature, layer) {
237                                editableLayers_[(#ENV{nom})].addLayer(layer);
238                                if (feature.geometry.type == 'Polygon' || feature.geometry.type == 'LineString') {
239                                        [(#REM)
240
241                                                centrer la carte sur les bounds de l'objet
242
243                                        ]form_map_[(#ENV{nom})].fitBounds(layer.getBounds());
244                                        [(#REM)
245
246                                                surveiller les changements sur les points de l'objet
247
248                                        ]layer.on('edit', function (e) {
249                                                layer_edit(e);
250                                        });
251                                } else if (feature.geometry.type == 'Point') {
252                                        marker = layer;
253                                        if (feature.properties) {
254                                                if(feature.properties.icon) {
255                                                        layer.setIcon(new L.Icon({
256                                                                iconUrl: feature.properties.icon,
257                                                                iconSize: new L.Point(feature.properties.icon_size\[0\], feature.properties.icon_size\[1\]),
258                                                                iconAnchor: new L.Point(feature.properties.icon_anchor\[0\], feature.properties.icon_anchor\[1\]),
259                                                                popupAnchor: new L.Point(feature.properties.popup_anchor\[0\], feature.properties.popup_anchor\[1\])
260                                                        }));
261                                                };
262                                                if (feature.properties.title) {
263                                                        layer.bindPopup(feature.properties.title);
264                                                };
265                                        };
266                                        [(#REM)
267
268                                                rendre le marker draggable
269
270                                        ]layer.options.draggable = true;
271                                        [(#REM)
272
273                                                surveiller les changements sur le point
274                                               
275                                        ]layer.off('dragend').on('dragend', function (e) {
276                                                marker_dragend(e);
277                                        });
278                                }
279                        }
280                }).addTo(form_map_[(#ENV{nom})]);
281                geojson.addData(data);
282                </BOUCLE_gis>
283                </B_gis>
284                <BOUCLE_si_geojson(CONDITION){si #ENV{geojson}}>
285                var geojson = new L.geoJson('', {[
286                        style: (#ENV*{path_styles}|json_encode),
287                        ]onEachFeature: function (feature, layer) {
288                                editableLayers_[(#ENV{nom})].addLayer(layer);
289                                form_map_[(#ENV{nom})].removeLayer(layer);
290                                if (feature.type === 'Polygon' || feature.type === 'MultiPolygon' || feature.type === 'LineString') {
291                                        [(#REM)
292
293                                                centrer la carte sur les bounds de l'objet
294
295                                        ]form_map_[(#ENV{nom})].fitBounds(layer.getBounds());
296                                        [(#REM)
297
298                                                surveiller les changements sur les points de l'objet
299
300                                        ]layer.on('edit', function (e) {
301                                                layer_edit(e);
302                                        });
303                                } else if (feature.geometry.type === 'Point') {
304                                        marker = layer;
305                                        if (feature.properties && feature.properties.icon) {
306                                                layer.setIcon(new L.Icon({
307                                                        iconUrl: feature.properties.icon,
308                                                        iconSize: new L.Point(feature.properties.icon_size\[0\], feature.properties.icon_size\[1\]),
309                                                        iconAnchor: new L.Point(feature.properties.icon_anchor\[0\], feature.properties.icon_anchor\[1\]),
310                                                        popupAnchor: new L.Point(feature.properties.popup_anchor\[0\], feature.properties.popup_anchor\[1\])
311                                                }));
312                                        }
313                                        if (feature.properties && feature.properties.title) {
314                                                layer.bindPopup(feature.properties.title);
315                                        }
316                                        [(#REM)
317
318                                                rendre le marker draggable
319
320                                        ]layer.options.draggable = true;
321                                        [(#REM)
322
323                                                surveiller les changements sur le point
324
325                                        ]layer.off('dragend').on('dragend', function (e) {
326                                                marker_dragend(e);
327                                        });
328                                }
329                        }
330                }).addTo(form_map_[(#ENV{nom})]);
331                geojson.addData([(#ENV**{geojson}|html_entity_decode)]);
332                </BOUCLE_si_geojson>
333                <//B_gis>
334                [(#REM) 
335               
336                        afficher les outils de dessin uniquement lors de la création d'objet
337
338                ][(#ENV{nodraw}|non)
339                [(#REM)
340
341                        i18n des chaines de Leaflet.draw
342
343                ]L.drawLocal.draw.toolbar.actions.title = '<:gis:toolbar_actions_title|texte_script:>';
344                L.drawLocal.draw.toolbar.actions.text = '<:bouton_annuler|texte_script:>';
345                L.drawLocal.draw.toolbar.buttons.polyline = '<:gis:toolbar_buttons_polyline|texte_script:>';
346                L.drawLocal.draw.toolbar.buttons.polygon = '<:gis:toolbar_buttons_polygon|texte_script:>';
347                L.drawLocal.draw.toolbar.buttons.rectangle = '<:gis:toolbar_buttons_rectangle|texte_script:>';
348                L.drawLocal.draw.toolbar.buttons.circle = '<:gis:toolbar_buttons_circle|texte_script:>';
349                L.drawLocal.draw.toolbar.buttons.marker = '<:gis:toolbar_buttons_marker|texte_script:>';
350                L.drawLocal.draw.toolbar.finish.text = '<:gis:toolbar_finish_text|texte_script:>';
351                L.drawLocal.draw.toolbar.finish.title = '<:gis:toolbar_finish_title|texte_script:>';
352                L.drawLocal.draw.toolbar.undo.title = '<:gis:toolbar_undo_title|texte_script:>';
353                L.drawLocal.draw.toolbar.undo.text = '<:gis:toolbar_undo_text|texte_script:>';
354                L.drawLocal.draw.handlers.marker.tooltip.start = '<:gis:toolbar_handlers_marker_tooltip_start|texte_script:>';
355                L.drawLocal.draw.handlers.polygon.tooltip.start = '<:gis:toolbar_handlers_polygon_tooltip_start|texte_script:>';
356                L.drawLocal.draw.handlers.polygon.tooltip.cont = '<:gis:toolbar_handlers_polygon_tooltip_cont|texte_script:>';
357                L.drawLocal.draw.handlers.polygon.tooltip.end = '<:gis:toolbar_handlers_polygon_tooltip_end|texte_script:>';
358                L.drawLocal.draw.handlers.polyline.tooltip.start = '<:gis:toolbar_handlers_polyline_tooltip_start|texte_script:>';
359                L.drawLocal.draw.handlers.polyline.tooltip.cont = '<:gis:toolbar_handlers_polyline_tooltip_cont|texte_script:>';
360                L.drawLocal.draw.handlers.polyline.tooltip.end = '<:gis:toolbar_handlers_polyline_tooltip_end|texte_script:>';
361                L.drawLocal.draw.handlers.rectangle.tooltip.start = '<:gis:toolbar_handlers_rectangle_tooltip_start|texte_script:>';
362                L.drawLocal.draw.handlers.simpleshape.tooltip.end = '<:gis:toolbar_handlers_simpleshape_tooltip_end|texte_script:>';
363                L.drawLocal.edit.toolbar.actions.save.text = '<:bouton_enregistrer|texte_script:>';
364                L.drawLocal.edit.toolbar.actions.save.title = '<:gis:bouton_enregistrer_title|texte_script:>';
365                L.drawLocal.edit.toolbar.actions.cancel.text = '<:bouton_annuler|texte_script:>';
366                L.drawLocal.edit.toolbar.actions.cancel.title = '<:gis:bouton_annuler_title|texte_script:>';
367                L.drawLocal.edit.toolbar.buttons.edit = '<:gis:toolbar_edit_buttons_edit|texte_script:>';
368                L.drawLocal.edit.toolbar.buttons.editDisabled = '<:gis:toolbar_edit_buttons_editdisabled|texte_script:>';
369                L.drawLocal.edit.toolbar.buttons.remove = '<:gis:toolbar_edit_buttons_remove|texte_script:>';
370                L.drawLocal.edit.toolbar.buttons.removeDisabled = '<:gis:toolbar_edit_buttons_removedisabled|texte_script:>';
371                L.drawLocal.edit.handlers.edit.tooltip.text = '<:gis:toolbar_edit_handlers_edit_tooltip_text|texte_script:>';
372                L.drawLocal.edit.handlers.edit.tooltip.subtext = '<:gis:toolbar_edit_handlers_edit_tooltip_subtext|texte_script:>';
373                L.drawLocal.edit.handlers.remove.tooltip.text = '<:gis:toolbar_edit_handlers_remove_tooltip_text|texte_script:>';
374
375                var drawOptions = {
376                        position: 'topleft',
377                        draw: {
378                                polyline:[(#ENV{boutons}|table_valeur{polyline}|=={non}|oui)false][
379                                (#ENV{boutons}|table_valeur{polyline}|=={non}|non){
380                                        shapeOptions: { color: '#0033ff' }
381                                }],
382                                polygon:[(#ENV{boutons}|table_valeur{polygon}|=={non}|oui)false][
383                                (#ENV{boutons}|table_valeur{polygon}|=={non}|non){
384                                        shapeOptions: { color: '#0033ff' }
385                                }],
386                                marker: [(#ENV{boutons}|table_valeur{marker}|=={non}|?{false,true})],
387                                circle: false,
388                                rectangle: [(#ENV{boutons}|table_valeur{rectangle}|=={non}|?{false,''})][
389                                (#ENV{boutons}|table_valeur{rectangle}|=={non}|non){
390                                        shapeOptions: { color: '#0033ff' }
391                                }]
392                        },
393                        edit: {
394                                featureGroup: editableLayers_[(#ENV{nom})]
395                        }
396                }, drawOptionsBlocked = {
397                        position: 'topleft',
398                        draw: false,
399                        edit: {
400                                featureGroup: editableLayers_[(#ENV{nom})]
401                        }
402                }, edited = false;
403
404                [(#REM)
405
406                        Si on a un objet, on limite l'usage de la toolbar,
407                        sinon on a accès aux outils de dessin
408
409                ]
410                var drawControl = new L.Control.Draw(drawOptions);
411                if (Object.keys(editableLayers_[(#ENV{nom})]._layers).length >= 1) {
412                        drawControl = new L.Control.Draw(drawOptionsBlocked);
413                }
414                [(#REM)
415
416                        Si on a un seul objet, on le rend éditable
417
418                ]
419
420                form_map_[(#ENV{nom})].addControl(drawControl);
421                form_map_[(#ENV{nom})].drawControl = drawControl;
422                form_map_[(#ENV{nom})].on('draw:created', function (e) {
423                        var type = e.layerType,
424                                layer = e.layer;
425                        if (type === 'marker') {
426                                marker.setLatLng(layer._latlng);
427                                form_map_[(#ENV{nom})].removeLayer(marker);
428                                editableLayers_[(#ENV{nom})].addLayer(marker);
429                                $('#champ_#ENV{champ_type,type}').val('Point');
430                                marker_dragend(layer);
431                                marker.off('dragend').on('dragend', function (e) {
432                                        marker_dragend(e);
433                                });
434                        } else {
435                                editableLayers_[(#ENV{nom})].addLayer(layer);
436                                if (type === 'polygon' || type === 'rectangle') {
437                                        $('#champ_#ENV{champ_type,type}').val('Polygon');
438                                } else if (type === 'polyline') {
439                                        $('#champ_#ENV{champ_type,type}').val('LineString');
440                                }
441                                layer_edit(layer);
442                                layer.on('edit', function (e) {
443                                        layer_edit(e);
444                                });
445                        }
446                        gisdraw_change_controls(drawOptionsBlocked);
447                });
448                form_map_[(#ENV{nom})].on('draw:deleted', function (e) {
449                        if (Object.keys(e.layers._layers).length >= 1) {
450                                [(#REM)
451
452                                        La forme est supprimée, donc on vide l'ensemble des champs
453
454                                ]
455                                [(#ENV{nomajinputs,non}|=={oui}|non)
456                                $('#champ_[(#ENV{champ_lat,lat})],#champ_[(#ENV{champ_lon,lon})],#champ_[(#ENV{champ_type,type})],#champ_[(#ENV{champ_geojson,geojson})]').val('');
457                                $('#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('');]
458                                [(#REM)
459
460                                        On passe par un settimeout ici pour laisser draw finir son action
461                                        https://github.com/Leaflet/Leaflet.draw/issues/369
462
463                                ]
464                                setTimeout(function () { gisdraw_change_controls(drawOptions); }, 200);
465                        }
466                });
467                /**
468                 * Au editstart, on met la variable edited à false
469                 */
470                form_map_[(#ENV{nom})].on('draw:editstart', function (e) {
471                        edited = false;
472                });
473                /**
474                 * Au edited, on met la variable edited à true (il y a eu edition)
475                 */
476                form_map_[(#ENV{nom})].on('draw:edited', function (e) {
477                        edited = true;
478                });
479                /**
480                 * Au editstop, on vérifie la variable edited, si true, il y a eu modif, donc on ne fait rien
481                 * si false, on remet les valeurs par défaut avant édition (bouton annuler)
482                 */
483                form_map_[(#ENV{nom})].on('draw:editstop', function (e) {
484                        if (!edited) {
485                                var type = $('#champ_#ENV{champ_type,type}').val();
486                                editableLayers_[(#ENV{nom})].eachLayer(function (layer) {
487                                        if (type === 'Point') {
488                                                marker_dragend(layer);
489                                        } else {
490                                                layer_edit(layer);
491                                        }
492                                });
493                        } else {
494                                edited = false;
495                        }
496                });
497                if (Object.keys(editableLayers_[(#ENV{nom})]._layers).length == 1) {
498                        editableLayers_[(#ENV{nom})].eachLayer(function (layer) {
499                                layer.editing.enable();
500                                drawControl._toolbars.edit._modes.edit.handler.enable();
501                        });
502                }
503                [(#REM)
504                       
505                        Si le geocoder renvoit quelque chose, on bloque la création de nouveaux éléments
506                       
507                ]form_map_[(#ENV{nom})].on('geocoder_ok', function(){
508                        if(drawControl._toolbars.draw) {
509                                gisdraw_change_controls(drawOptionsBlocked);
510                                marker.editing.enable();
511                                drawControl._toolbars.edit._modes.edit.handler.enable();
512                        }
513                });]
514                [(#ENV{nodraw}|oui)
515                [(#REM)
516
517                        option nodraw, l'objet est un point
518
519                ]$('#champ_#ENV{champ_type,type}').val('Point');
520                [(#REM)
521
522                        mettre a jour les coordonnees quand on clique la carte
523
524                ]form_map_[(#ENV{nom})].on('click', function (e) {
525                        annuler_geocoder_[(#ENV{nom})] = 0;
526                        maj_inputs(form_map_[(#ENV{nom})], editableLayers_[(#ENV{nom})], e.latlng, 'click');
527                });
528                [(#REM)
529
530                        mettre à jour le champ geosjon et le marker quand on change les valeur de lat ou lon
531
532                ][(#ENV{nomajinputs,non}|=={oui}|non)
533                $('#champ_#ENV{champ_lat,lat}, #champ_#ENV{champ_lon,lon}').on('change', function () {
534                        var new_lat = $('#champ_#ENV{champ_lat,lat}').val(),
535                                new_lon = $('#champ_#ENV{champ_lon,lon}').val(),
536                                new_center = new L.LatLng(new_lat, new_lon);
537                        marker.setLatLng(new_center);
538                        form_map_[(#ENV{nom})].panTo(new_center);
539                        $('#champ_#ENV{champ_geojson,geojson}').val('{"type":"Point","coordinates":\[' + new_lon + ',' + new_lat + '\]}');
540                });]]
541
542                [(#ENV{nodraw}|oui)
543                [(#REM)
544
545                        mettre à jour les coordonnées quand on déplace le marker
546
547                ]marker.off('dragend').on('dragend', function (e) {
548                        marker_dragend(e);
549                });]
550
551                [(#REM)
552               
553                        mettre à jour le zoom quand on le modifie
554
555                ][(#ENV{nomajinputs,non}|=={oui}|non)
556                form_map_[(#ENV{nom})].on('zoomend', function (e) {
557                        $('#champ_#ENV{champ_zoom,zoom}').val(e.target._zoom);
558                });]
559
560                [(#GET{geocoder}|oui)
561                [(#REM)
562
563                        geocoder si clic...
564
565                ]$('a##ENV{nom}_rechercher_geocodage').css("cursor","pointer").on('click',function(){
566                        var address = $("#champ_#ENV{nom}_geocoder").val();
567                        annuler_geocoder_[(#ENV{nom})] = 0;
568                        geocoder.geocode(address);
569                });
570
571                [(#REM)
572
573                        ne pas soumettre le formulaire si on presse Entree depuis le champ de recherche
574                       
575                ]$('#champ_#ENV{nom}_geocoder').on('keypress', function (e) {
576                        if (e.which == 13) {
577                                $('a##ENV{nom}_rechercher_geocodage').trigger("click");
578                                return false;
579                        }
580                });]
581
582                [(#ENV{id_gis}|non|ou{#ENV{id_gis}|=={oui}}|et{#CONFIG{gis/geolocaliser_user_html5}|=={on}}|oui)
583                form_map_[(#ENV{nom})].locate({setView: true, maxZoom: [(#GET{init_zoom})]});]
584        };
585
586        $(function () {
587                $.getScript('[(#PRODUIRE{fond=javascript/gis.js})]', function () {
588                        if (typeof (callback_form_map_[(#ENV{nom})]) === "function") {
589                                init_map(callback_form_map_[(#ENV{nom})]);
590                        } else if (typeof (callback_form_map) === "function") {
591                                init_map(callback_form_map);
592                        } else {
593                                init_map();
594                        }
595                });
596        });
597
598})(jQuery);
599/*]]>*/
600</script>
601#ENV*{inserer_fin}
602</[(#VAL{li}|saisie_balise_structure_formulaire)]>
603[(#GET{geocoder}|oui)
604<[(#VAL{li}|saisie_balise_structure_formulaire)] class="rechercher_adresse editer editer_[(#ENV{nom})]">
605        <label for="champ_#ENV{nom}_geocoder"><:gis:label_rechercher_address:></label>
606        <input type="text" class="text" name="champ_#ENV{nom}_geocoder" id="champ_#ENV{nom}_geocoder" placeholder="<:gis:placeholder_geocoder|attribut_html:>" value="" />
607        <a id="#ENV{nom}_rechercher_geocodage"><:info_rechercher:></a>
608</[(#VAL{li}|saisie_balise_structure_formulaire)]>]
609#FILTRE{trim}
610<!--extragis-->
Note: See TracBrowser for help on using the repository browser.