web/www/fixme.openlayers2.js

//
// Routino (extras) fixme web page Javascript
//
// Part of the Routino routing software.
//
// This file Copyright 2008-2014, 2019 Andrew M. Bishop
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//


////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// Initialisation /////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// Process the URL query string and extract the arguments

var legal={"^lon"  : "^[-0-9.]+$",
           "^lat"  : "^[-0-9.]+$",
           "^zoom" : "^[0-9]+$"};

var args={};

if(location.search.length>1)
  {
   var query,queries;

   query=location.search.replace(/^\?/,"");
   query=query.replace(/;/g,"&");
   queries=query.split("&");

   for(var i=0;i<queries.length;i++)
     {
      queries[i].match(/^([^=]+)(=(.*))?$/);

      var k=RegExp.$1;
      var v=decodeURIComponent(RegExp.$3);

      for(var l in legal)
        {
         if(k.match(RegExp(l)) && v.match(RegExp(legal[l])))
            args[k]=v;
        }
     }
  }


////////////////////////////////////////////////////////////////////////////////
///////////////////////////////// Map handling /////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

var map;
var layerMap=[], layerHighlights, layerVectors, layerBoxes;
var epsg4326, epsg900913;
var box;
var select;

//
// Initialise the 'map' object
//

function map_init()             // called from fixme.html
{
 // Create the map (Map URLs and limits are in mapprops.js)

 epsg4326=new OpenLayers.Projection("EPSG:4326");
 epsg900913=new OpenLayers.Projection("EPSG:900913");

 map = new OpenLayers.Map ("map",
                           {
                            controls:[
                                      new OpenLayers.Control.Navigation(),
                                      new OpenLayers.Control.PanZoomBar(),
                                      new OpenLayers.Control.ScaleLine(),
                                      new OpenLayers.Control.LayerSwitcher()
                                      ],

                            projection: epsg900913,
                            displayProjection: epsg4326,

                            minZoomLevel: mapprops.zoomout,
                            numZoomLevels: mapprops.zoomin-mapprops.zoomout+1,
                            maxResolution: 156543.03390625 / Math.pow(2,mapprops.zoomout),

                            restrictedExtent: new OpenLayers.Bounds(mapprops.westedge,mapprops.southedge,mapprops.eastedge,mapprops.northedge).transform(epsg4326,epsg900913)
                           });

 // Get a URL for the tile (mostly copied from OpenLayers/Layer/XYZ.js).

 function limitedUrl(bounds)
 {
  var res = this.map.getResolution();

  var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));
  var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));
  var z = this.map.getZoom() + this.map.minZoomLevel;

  var limit = Math.pow(2, z);
  x = ((x % limit) + limit) % limit;

  var xyz = {"x": x, "y": y, "z": z};
  var url = this.url;

  if (OpenLayers.Util.isArray(url))
    {
     var s = "" + xyz.x + xyz.y + xyz.z;
     url = this.selectUrl(s, url);
    }

  return OpenLayers.String.format(url, xyz);
 }

 // Add map tile layers

 for(var l=0; l<mapprops.mapdata.length; l++)
   {
    var urls;

    if(OpenLayers.Util.isArray(mapprops.mapdata[l].tiles.subdomains))
      {
       urls=[];

       for(var s=0; s<mapprops.mapdata[l].tiles.subdomains.length; s++)
          urls.push(mapprops.mapdata[l].tiles.url.replace(/\${s}/,mapprops.mapdata[l].tiles.subdomains[s]));
      }
    else
       urls=mapprops.mapdata[l].tiles.url;

    layerMap[l] = new OpenLayers.Layer.TMS(mapprops.mapdata[l].label,
                                           urls,
                                           {
                                            getURL: limitedUrl,
                                            displayOutsideMaxExtent: true,
                                            buffer: 1
                                           });
    map.addLayer(layerMap[l]);
   }

 // Update the attribution if the layer changes

 function change_attribution_event(event)
 {
  for(var l=0; l<mapprops.mapdata.length; l++)
     if(layerMap[l] == event.layer)
        change_attribution(l);
 }

 map.events.register("changelayer",layerMap,change_attribution_event);

 function change_attribution(l)
 {
  var data_url =mapprops.mapdata[l].attribution.data_url;
  var data_text=mapprops.mapdata[l].attribution.data_text;
  var tile_url =mapprops.mapdata[l].attribution.tile_url;
  var tile_text=mapprops.mapdata[l].attribution.tile_text;

  document.getElementById("attribution_data").innerHTML="<a href=\"" + data_url + "\" target=\"data_attribution\">" + data_text + "</a>";
  document.getElementById("attribution_tile").innerHTML="<a href=\"" + tile_url + "\" target=\"tile_attribution\">" + tile_text + "</a>";
 }

 change_attribution(0);

 // Add two vectors layers (one for highlights that display behind the vectors)

 layerHighlights = new OpenLayers.Layer.Vector("Highlights",{displayInLayerSwitcher: false});
 map.addLayer(layerHighlights);

 layerVectors = new OpenLayers.Layer.Vector("Markers",{displayInLayerSwitcher: false});
 map.addLayer(layerVectors);

 // Handle feature selection and popup

 select = new OpenLayers.Control.SelectFeature(layerVectors,
                                               {onSelect: selectFeature, onUnselect: unselectFeature});

 map.addControl(select);
 select.activate();

 createPopup();

 // Add a boxes layer

 layerBoxes = new OpenLayers.Layer.Boxes("Boundary",{displayInLayerSwitcher: false});
 map.addLayer(layerBoxes);

 box=null;

 // Move the map

 map.events.register("moveend", map, updateURLs);

 var lon =args["lon"];
 var lat =args["lat"];
 var zoom=args["zoom"];

 if(lon !== undefined && lat !== undefined && zoom !== undefined)
   {
    if(lon<mapprops.westedge) lon=mapprops.westedge;
    if(lon>mapprops.eastedge) lon=mapprops.eastedge;

    if(lat<mapprops.southedge) lat=mapprops.southedge;
    if(lat>mapprops.northedge) lat=mapprops.northedge;

    if(zoom<mapprops.zoomout) zoom=mapprops.zoomout;
    if(zoom>mapprops.zoomin)  zoom=mapprops.zoomin;

    var lonlat = new OpenLayers.LonLat(lon,lat);
    lonlat.transform(epsg4326,epsg900913);

    map.moveTo(lonlat,zoom-map.minZoomLevel);
   }
 else
   {
    map.setCenter(map.restrictedExtent.getCenterLonLat(), map.getZoomForExtent(map.restrictedExtent,true));
    map.maxResolution = map.getResolution();
   }

 // Unhide editing URL if variable set

 if(mapprops.editurl !== undefined && mapprops.editurl !== "")
   {
    var edit_url=document.getElementById("edit_url");

    edit_url.style.display="";
    edit_url.href=mapprops.editurl;
   }

 updateURLs();
}


//
// Format a number in printf("%.5f") format.
//

function format5f(number)
{
 var newnumber=Math.floor(number*100000+0.5);
 var delta=0;

 if(newnumber>=0 && newnumber<100000) delta= 100000;
 if(newnumber<0 && newnumber>-100000) delta=-100000;

 var string=String(newnumber+delta);

 var intpart =string.substring(0,string.length-5);
 var fracpart=string.substring(string.length-5,string.length);

 if(delta>0) intpart="0";
 if(delta<0) intpart="-0";

 return(intpart + "." + fracpart);
}


//
// Build a set of URL arguments for the map location
//

function buildMapArguments()
{
 var lonlat = map.getCenter().clone();
 lonlat.transform(epsg900913,epsg4326);

 var zoom = map.getZoom() + map.minZoomLevel;

 return "lat=" + format5f(lonlat.lat) + ";lon=" + format5f(lonlat.lon) + ";zoom=" + zoom;
}


//
// Update the URLs
//

function updateURLs()
{
 var mapargs=buildMapArguments();

 var links=document.getElementsByTagName("a");

 for(var i=0; i<links.length; i++)
   {
    var element=links[i];

    if(element.id == "permalink_url")
       element.href=location.pathname + "?" + mapargs;

    if(element.id == "edit_url")
       element.href=mapprops.editurl + "?" + mapargs;
   }
}


////////////////////////////////////////////////////////////////////////////////
///////////////////////// Popup and selection handling /////////////////////////
////////////////////////////////////////////////////////////////////////////////

var popup=null;

//
// Create a popup - independent of map because want it fixed on screen not fixed on map.
//

function createPopup()
{
 popup=document.createElement("div");

 popup.className = "popup";

 popup.innerHTML = "<span></span>";

 popup.style.display = "none";

 popup.style.position = "fixed";
 popup.style.top = "-4000px";
 popup.style.left = "-4000px";
 popup.style.zIndex = "100";

 popup.style.padding = "5px";

 popup.style.opacity=0.85;
 popup.style.backgroundColor="#C0C0C0";
 popup.style.border="4px solid #404040";

 document.body.appendChild(popup);
}


//
// Draw a popup - independent of map because want it fixed on screen not fixed on map.
//

function drawPopup(html)
{
 if(html===null)
   {
    popup.style.display="none";
    return;
   }

 if(popup.style.display=="none")
   {
    var map_div=document.getElementById("map");

    popup.style.left  =map_div.offsetParent.offsetLeft+map_div.offsetLeft+60 + "px";
    popup.style.top   =                                map_div.offsetTop +30 + "px";
    popup.style.width =map_div.clientWidth-120 + "px";

    popup.style.display="";
   }

 var close="<span style='float: right; cursor: pointer;' onclick='drawPopup(null)'>X</span>";

 popup.innerHTML=close+html;
}


//
// Select a feature
//

function selectFeature(feature)
{
 if(feature.attributes.dump)
    ajaxGET("fixme.cgi?dump=" + feature.attributes.dump, runDumpSuccess);

 layerHighlights.destroyFeatures();

 var highlight_style = new OpenLayers.Style({},{strokeColor: "#F0F000",strokeWidth: 8,
                                                fillColor: "#F0F000",pointRadius: 4});

 var highlight = new OpenLayers.Feature.Vector(feature.geometry.clone(),{},highlight_style);

 layerHighlights.addFeatures([highlight]);
}


//
// Un-select a feature
//

function unselectFeature(feature)
{
 layerHighlights.destroyFeatures();

 drawPopup(null);
}


//
// Display the dump data
//

function runDumpSuccess(response)
{
 var string=response.responseText;

 if(mapprops.editurl !== undefined && mapprops.editurl !== "")
   {
    var types=["node", "way", "relation"];

    for(var t in types)
      {
       var type=types[t];

       var regexp=RegExp(type + " id=&#39;([0-9]+)&#39;");

       var match=string.match(regexp);

       if(match !== null)
         {
          var id=match[1];

          string=string.replace(regexp,type + " id=&#39;<a href='" + mapprops.browseurl + "/" + type + "/" + id + "' target='" + type + id + "'>" + id + "</a>&#39;");
         }
      }
   }

 drawPopup(string.split("&gt;&lt;").join("&gt;<br>&lt;").split("<br>&lt;tag").join("<br>&nbsp;&nbsp;&lt;tag"));
}


////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// Server handling ////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

//
// Define an AJAX request object
//

function ajaxGET(url,success,failure,state)
{
 var ajaxRequest=new XMLHttpRequest();

 function ajaxGOT(options) {
  if(this.readyState==4)
     if(this.status==200)
       { if(typeof(options.success)=="function") options.success(this,options.state); }
     else
       { if(typeof(options.failure)=="function") options.failure(this,options.state); }
 }

 ajaxRequest.onreadystatechange = function(){ ajaxGOT.call(ajaxRequest,{success: success, failure: failure, state: state}); };
 ajaxRequest.open("GET", url, true);
 ajaxRequest.send(null);
}


//
// Display the status
//

function displayStatus(type,subtype,content)
{
 var child=document.getElementById("result_status").firstChild;

 do
   {
    if(child.id !== undefined)
       child.style.display="none";

    child=child.nextSibling;
   }
 while(child !== null);

 var chosen_status=document.getElementById("result_status_" + type);

 chosen_status.style.display="";

 if(subtype !== undefined)
   {
    var format_status=document.getElementById("result_status_" + subtype).innerHTML;

    chosen_status.innerHTML=format_status.replace("#",String(content));
   }
}


//
// Display data statistics
//

function displayStatistics()
{
 // Use AJAX to get the statistics

 ajaxGET("fixme.cgi?statistics=yes", runStatisticsSuccess);
}


//
// Success in running data statistics generation.
//

function runStatisticsSuccess(response)
{
 document.getElementById("statistics_data").innerHTML="<pre>" + response.responseText + "</pre>";
 document.getElementById("statistics_link").style.display="none";
}


//
// Get the requested data
//

function displayData(datatype)  // called from fixme.html
{
 // Delete the old data

 unselectFeature();

 select.deactivate();

 layerVectors.destroyFeatures();
 layerHighlights.destroyFeatures();

 if(box !== null)
    layerBoxes.removeMarker(box);
 box=null;

 // Print the status

 displayStatus("no_data");

 // Return if just here to clear the data

 if(datatype === "")
    return;

 // Get the new data

 var mapbounds=map.getExtent().clone();
 mapbounds.transform(epsg900913,epsg4326);

 var url="fixme.cgi";

 url=url + "?lonmin=" + format5f(mapbounds.left);
 url=url + ";latmin=" + format5f(mapbounds.bottom);
 url=url + ";lonmax=" + format5f(mapbounds.right);
 url=url + ";latmax=" + format5f(mapbounds.top);
 url=url + ";data=" + datatype;

 // Use AJAX to get the data

 ajaxGET(url, runFixmeSuccess, runFailure);
}


//
// Add a bounding box
//

function addBox(words)
{
 var lat1=words[0];
 var lon1=words[1];
 var lat2=words[2];
 var lon2=words[3];

 var bounds = new OpenLayers.Bounds(lon1,lat1,lon2,lat2).transform(epsg4326,epsg900913);

 box = new OpenLayers.Marker.Box(bounds);

 layerBoxes.addMarker(box);
}


//
// Success in getting the error log data
//

function runFixmeSuccess(response)
{
 var lines=response.responseText.split("\n");

 var style = new OpenLayers.Style({},{stroke: false,
                                      pointRadius: 3,fillColor: "#FF0000",
                                      cursor: "pointer"});

 var features=[];

 for(var line=0;line<lines.length;line++)
   {
    var words=lines[line].split(" ");

    if(line === 0)
       addBox(words);
    else if(words[0] !== "")
      {
       var dump=words[0];
       var lat=words[1];
       var lon=words[2];

       var lonlat = new OpenLayers.LonLat(lon,lat).transform(epsg4326,epsg900913);

       var point = new OpenLayers.Geometry.Point(lonlat.lon,lonlat.lat);

       features.push(new OpenLayers.Feature.Vector(point,{dump: dump},style));
      }
   }

 select.activate();

 layerVectors.addFeatures(features);

 displayStatus("data","fixme",lines.length-2);
}


//
// Failure in getting data.
//

function runFailure(response)
{
 displayStatus("failed");
}
1	//
2	// Routino (extras) fixme web page Javascript
3	//
4	// Part of the Routino routing software.
5	//
6	// This file Copyright 2008-2014, 2019 Andrew M. Bishop
7	//
8	// This program is free software: you can redistribute it and/or modify
9	// it under the terms of the GNU Affero General Public License as published by
10	// the Free Software Foundation, either version 3 of the License, or
11	// (at your option) any later version.
12	//
13	// This program is distributed in the hope that it will be useful,
14	// but WITHOUT ANY WARRANTY; without even the implied warranty of
15	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	// GNU Affero General Public License for more details.
17	//
18	// You should have received a copy of the GNU Affero General Public License
19	// along with this program. If not, see <http://www.gnu.org/licenses/>.
20	//
21
22
23	////////////////////////////////////////////////////////////////////////////////
24	/////////////////////////////// Initialisation /////////////////////////////////
25	////////////////////////////////////////////////////////////////////////////////
26
27	// Process the URL query string and extract the arguments
28
29	var legal={"^lon" : "^[-0-9.]+$",
30	"^lat" : "^[-0-9.]+$",
31	"^zoom" : "^[0-9]+$"};
32
33	var args={};
34
35	if(location.search.length>1)
36	{
37	var query,queries;
38
39	query=location.search.replace(/^\?/,"");
40	query=query.replace(/;/g,"&");
41	queries=query.split("&");
42
43	for(var i=0;i<queries.length;i++)
44	{
45	queries[i].match(/^([^=]+)(=(.*))?$/);
46
47	var k=RegExp.$1;
48	var v=decodeURIComponent(RegExp.$3);
49
50	for(var l in legal)
51	{
52	if(k.match(RegExp(l)) && v.match(RegExp(legal[l])))
53	args[k]=v;
54	}
55	}
56	}
57
58
59	////////////////////////////////////////////////////////////////////////////////
60	///////////////////////////////// Map handling /////////////////////////////////
61	////////////////////////////////////////////////////////////////////////////////
62
63	var map;
64	var layerMap=[], layerHighlights, layerVectors, layerBoxes;
65	var epsg4326, epsg900913;
66	var box;
67	var select;
68
69	//
70	// Initialise the 'map' object
71	//
72
73	function map_init() // called from fixme.html
74	{
75	// Create the map (Map URLs and limits are in mapprops.js)
76
77	epsg4326=new OpenLayers.Projection("EPSG:4326");
78	epsg900913=new OpenLayers.Projection("EPSG:900913");
79
80	map = new OpenLayers.Map ("map",
81	{
82	controls:[
83	new OpenLayers.Control.Navigation(),
84	new OpenLayers.Control.PanZoomBar(),
85	new OpenLayers.Control.ScaleLine(),
86	new OpenLayers.Control.LayerSwitcher()
87	],
88
89	projection: epsg900913,
90	displayProjection: epsg4326,
91
92	minZoomLevel: mapprops.zoomout,
93	numZoomLevels: mapprops.zoomin-mapprops.zoomout+1,
94	maxResolution: 156543.03390625 / Math.pow(2,mapprops.zoomout),
95
96	restrictedExtent: new OpenLayers.Bounds(mapprops.westedge,mapprops.southedge,mapprops.eastedge,mapprops.northedge).transform(epsg4326,epsg900913)
97	});
98
99	// Get a URL for the tile (mostly copied from OpenLayers/Layer/XYZ.js).
100
101	function limitedUrl(bounds)
102	{
103	var res = this.map.getResolution();
104
105	var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));
106	var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));
107	var z = this.map.getZoom() + this.map.minZoomLevel;
108
109	var limit = Math.pow(2, z);
110	x = ((x % limit) + limit) % limit;
111
112	var xyz = {"x": x, "y": y, "z": z};
113	var url = this.url;
114
115	if (OpenLayers.Util.isArray(url))
116	{
117	var s = "" + xyz.x + xyz.y + xyz.z;
118	url = this.selectUrl(s, url);
119	}
120
121	return OpenLayers.String.format(url, xyz);
122	}
123
124	// Add map tile layers
125
126	for(var l=0; l<mapprops.mapdata.length; l++)
127	{
128	var urls;
129
130	if(OpenLayers.Util.isArray(mapprops.mapdata[l].tiles.subdomains))
131	{
132	urls=[];
133
134	for(var s=0; s<mapprops.mapdata[l].tiles.subdomains.length; s++)
135	urls.push(mapprops.mapdata[l].tiles.url.replace(/\${s}/,mapprops.mapdata[l].tiles.subdomains[s]));
136	}
137	else
138	urls=mapprops.mapdata[l].tiles.url;
139
140	layerMap[l] = new OpenLayers.Layer.TMS(mapprops.mapdata[l].label,
141	urls,
142	{
143	getURL: limitedUrl,
144	displayOutsideMaxExtent: true,
145	buffer: 1
146	});
147	map.addLayer(layerMap[l]);
148	}
149
150	// Update the attribution if the layer changes
151
152	function change_attribution_event(event)
153	{
154	for(var l=0; l<mapprops.mapdata.length; l++)
155	if(layerMap[l] == event.layer)
156	change_attribution(l);
157	}
158
159	map.events.register("changelayer",layerMap,change_attribution_event);
160
161	function change_attribution(l)
162	{
163	var data_url =mapprops.mapdata[l].attribution.data_url;
164	var data_text=mapprops.mapdata[l].attribution.data_text;
165	var tile_url =mapprops.mapdata[l].attribution.tile_url;
166	var tile_text=mapprops.mapdata[l].attribution.tile_text;
167
168	document.getElementById("attribution_data").innerHTML="<a href=\"" + data_url + "\" target=\"data_attribution\">" + data_text + "</a>";
169	document.getElementById("attribution_tile").innerHTML="<a href=\"" + tile_url + "\" target=\"tile_attribution\">" + tile_text + "</a>";
170	}
171
172	change_attribution(0);
173
174	// Add two vectors layers (one for highlights that display behind the vectors)
175
176	layerHighlights = new OpenLayers.Layer.Vector("Highlights",{displayInLayerSwitcher: false});
177	map.addLayer(layerHighlights);
178
179	layerVectors = new OpenLayers.Layer.Vector("Markers",{displayInLayerSwitcher: false});
180	map.addLayer(layerVectors);
181
182	// Handle feature selection and popup
183
184	select = new OpenLayers.Control.SelectFeature(layerVectors,
185	{onSelect: selectFeature, onUnselect: unselectFeature});
186
187	map.addControl(select);
188	select.activate();
189
190	createPopup();
191
192	// Add a boxes layer
193
194	layerBoxes = new OpenLayers.Layer.Boxes("Boundary",{displayInLayerSwitcher: false});
195	map.addLayer(layerBoxes);
196
197	box=null;
198
199	// Move the map
200
201	map.events.register("moveend", map, updateURLs);
202
203	var lon =args["lon"];
204	var lat =args["lat"];
205	var zoom=args["zoom"];
206
207	if(lon !== undefined && lat !== undefined && zoom !== undefined)
208	{
209	if(lon<mapprops.westedge) lon=mapprops.westedge;
210	if(lon>mapprops.eastedge) lon=mapprops.eastedge;
211
212	if(lat<mapprops.southedge) lat=mapprops.southedge;
213	if(lat>mapprops.northedge) lat=mapprops.northedge;
214
215	if(zoom<mapprops.zoomout) zoom=mapprops.zoomout;
216	if(zoom>mapprops.zoomin) zoom=mapprops.zoomin;
217
218	var lonlat = new OpenLayers.LonLat(lon,lat);
219	lonlat.transform(epsg4326,epsg900913);
220
221	map.moveTo(lonlat,zoom-map.minZoomLevel);
222	}
223	else
224	{
225	map.setCenter(map.restrictedExtent.getCenterLonLat(), map.getZoomForExtent(map.restrictedExtent,true));
226	map.maxResolution = map.getResolution();
227	}
228
229	// Unhide editing URL if variable set
230
231	if(mapprops.editurl !== undefined && mapprops.editurl !== "")
232	{
233	var edit_url=document.getElementById("edit_url");
234
235	edit_url.style.display="";
236	edit_url.href=mapprops.editurl;
237	}
238
239	updateURLs();
240	}
241
242
243	//
244	// Format a number in printf("%.5f") format.
245	//
246
247	function format5f(number)
248	{
249	var newnumber=Math.floor(number*100000+0.5);
250	var delta=0;
251
252	if(newnumber>=0 && newnumber<100000) delta= 100000;
253	if(newnumber<0 && newnumber>-100000) delta=-100000;
254
255	var string=String(newnumber+delta);
256
257	var intpart =string.substring(0,string.length-5);
258	var fracpart=string.substring(string.length-5,string.length);
259
260	if(delta>0) intpart="0";
261	if(delta<0) intpart="-0";
262
263	return(intpart + "." + fracpart);
264	}
265
266
267	//
268	// Build a set of URL arguments for the map location
269	//
270
271	function buildMapArguments()
272	{
273	var lonlat = map.getCenter().clone();
274	lonlat.transform(epsg900913,epsg4326);
275
276	var zoom = map.getZoom() + map.minZoomLevel;
277
278	return "lat=" + format5f(lonlat.lat) + ";lon=" + format5f(lonlat.lon) + ";zoom=" + zoom;
279	}
280
281
282	//
283	// Update the URLs
284	//
285
286	function updateURLs()
287	{
288	var mapargs=buildMapArguments();
289
290	var links=document.getElementsByTagName("a");
291
292	for(var i=0; i<links.length; i++)
293	{
294	var element=links[i];
295
296	if(element.id == "permalink_url")
297	element.href=location.pathname + "?" + mapargs;
298
299	if(element.id == "edit_url")
300	element.href=mapprops.editurl + "?" + mapargs;
301	}
302	}
303
304
305	////////////////////////////////////////////////////////////////////////////////
306	///////////////////////// Popup and selection handling /////////////////////////
307	////////////////////////////////////////////////////////////////////////////////
308
309	var popup=null;
310
311	//
312	// Create a popup - independent of map because want it fixed on screen not fixed on map.
313	//
314
315	function createPopup()
316	{
317	popup=document.createElement("div");
318
319	popup.className = "popup";
320
321	popup.innerHTML = "<span></span>";
322
323	popup.style.display = "none";
324
325	popup.style.position = "fixed";
326	popup.style.top = "-4000px";
327	popup.style.left = "-4000px";
328	popup.style.zIndex = "100";
329
330	popup.style.padding = "5px";
331
332	popup.style.opacity=0.85;
333	popup.style.backgroundColor="#C0C0C0";
334	popup.style.border="4px solid #404040";
335
336	document.body.appendChild(popup);
337	}
338
339
340	//
341	// Draw a popup - independent of map because want it fixed on screen not fixed on map.
342	//
343
344	function drawPopup(html)
345	{
346	if(html===null)
347	{
348	popup.style.display="none";
349	return;
350	}
351
352	if(popup.style.display=="none")
353	{
354	var map_div=document.getElementById("map");
355
356	popup.style.left =map_div.offsetParent.offsetLeft+map_div.offsetLeft+60 + "px";
357	popup.style.top = map_div.offsetTop +30 + "px";
358	popup.style.width =map_div.clientWidth-120 + "px";
359
360	popup.style.display="";
361	}
362
363	var close="<span style='float: right; cursor: pointer;' onclick='drawPopup(null)'>X</span>";
364
365	popup.innerHTML=close+html;
366	}
367
368
369	//
370	// Select a feature
371	//
372
373	function selectFeature(feature)
374	{
375	if(feature.attributes.dump)
376	ajaxGET("fixme.cgi?dump=" + feature.attributes.dump, runDumpSuccess);
377
378	layerHighlights.destroyFeatures();
379
380	var highlight_style = new OpenLayers.Style({},{strokeColor: "#F0F000",strokeWidth: 8,
381	fillColor: "#F0F000",pointRadius: 4});
382
383	var highlight = new OpenLayers.Feature.Vector(feature.geometry.clone(),{},highlight_style);
384
385	layerHighlights.addFeatures([highlight]);
386	}
387
388
389	//
390	// Un-select a feature
391	//
392
393	function unselectFeature(feature)
394	{
395	layerHighlights.destroyFeatures();
396
397	drawPopup(null);
398	}
399
400
401	//
402	// Display the dump data
403	//
404
405	function runDumpSuccess(response)
406	{
407	var string=response.responseText;
408
409	if(mapprops.editurl !== undefined && mapprops.editurl !== "")
410	{
411	var types=["node", "way", "relation"];
412
413	for(var t in types)
414	{
415	var type=types[t];
416
417	var regexp=RegExp(type + " id='([0-9]+)'");
418
419	var match=string.match(regexp);
420
421	if(match !== null)
422	{
423	var id=match[1];
424
425	string=string.replace(regexp,type + " id='<a href='" + mapprops.browseurl + "/" + type + "/" + id + "' target='" + type + id + "'>" + id + "</a>'");
426	}
427	}
428	}
429
430	drawPopup(string.split("><").join("><br><").split("<br><tag").join("<br>  <tag"));
431	}
432
433
434	////////////////////////////////////////////////////////////////////////////////
435	/////////////////////////////// Server handling ////////////////////////////////
436	////////////////////////////////////////////////////////////////////////////////
437
438	//
439	// Define an AJAX request object
440	//
441
442	function ajaxGET(url,success,failure,state)
443	{
444	var ajaxRequest=new XMLHttpRequest();
445
446	function ajaxGOT(options) {
447	if(this.readyState==4)
448	if(this.status==200)
449	{ if(typeof(options.success)=="function") options.success(this,options.state); }
450	else
451	{ if(typeof(options.failure)=="function") options.failure(this,options.state); }
452	}
453
454	ajaxRequest.onreadystatechange = function(){ ajaxGOT.call(ajaxRequest,{success: success, failure: failure, state: state}); };
455	ajaxRequest.open("GET", url, true);
456	ajaxRequest.send(null);
457	}
458
459
460	//
461	// Display the status
462	//
463
464	function displayStatus(type,subtype,content)
465	{
466	var child=document.getElementById("result_status").firstChild;
467
468	do
469	{
470	if(child.id !== undefined)
471	child.style.display="none";
472
473	child=child.nextSibling;
474	}
475	while(child !== null);
476
477	var chosen_status=document.getElementById("result_status_" + type);
478
479	chosen_status.style.display="";
480
481	if(subtype !== undefined)
482	{
483	var format_status=document.getElementById("result_status_" + subtype).innerHTML;
484
485	chosen_status.innerHTML=format_status.replace("#",String(content));
486	}
487	}
488
489
490	//
491	// Display data statistics
492	//
493
494	function displayStatistics()
495	{
496	// Use AJAX to get the statistics
497
498	ajaxGET("fixme.cgi?statistics=yes", runStatisticsSuccess);
499	}
500
501
502	//
503	// Success in running data statistics generation.
504	//
505
506	function runStatisticsSuccess(response)
507	{
508	document.getElementById("statistics_data").innerHTML="<pre>" + response.responseText + "</pre>";
509	document.getElementById("statistics_link").style.display="none";
510	}
511
512
513	//
514	// Get the requested data
515	//
516
517	function displayData(datatype) // called from fixme.html
518	{
519	// Delete the old data
520
521	unselectFeature();
522
523	select.deactivate();
524
525	layerVectors.destroyFeatures();
526	layerHighlights.destroyFeatures();
527
528	if(box !== null)
529	layerBoxes.removeMarker(box);
530	box=null;
531
532	// Print the status
533
534	displayStatus("no_data");
535
536	// Return if just here to clear the data
537
538	if(datatype === "")
539	return;
540
541	// Get the new data
542
543	var mapbounds=map.getExtent().clone();
544	mapbounds.transform(epsg900913,epsg4326);
545
546	var url="fixme.cgi";
547
548	url=url + "?lonmin=" + format5f(mapbounds.left);
549	url=url + ";latmin=" + format5f(mapbounds.bottom);
550	url=url + ";lonmax=" + format5f(mapbounds.right);
551	url=url + ";latmax=" + format5f(mapbounds.top);
552	url=url + ";data=" + datatype;
553
554	// Use AJAX to get the data
555
556	ajaxGET(url, runFixmeSuccess, runFailure);
557	}
558
559
560	//
561	// Add a bounding box
562	//
563
564	function addBox(words)
565	{
566	var lat1=words[0];
567	var lon1=words[1];
568	var lat2=words[2];
569	var lon2=words[3];
570
571	var bounds = new OpenLayers.Bounds(lon1,lat1,lon2,lat2).transform(epsg4326,epsg900913);
572
573	box = new OpenLayers.Marker.Box(bounds);
574
575	layerBoxes.addMarker(box);
576	}
577
578
579	//
580	// Success in getting the error log data
581	//
582
583	function runFixmeSuccess(response)
584	{
585	var lines=response.responseText.split("\n");
586
587	var style = new OpenLayers.Style({},{stroke: false,
588	pointRadius: 3,fillColor: "#FF0000",
589	cursor: "pointer"});
590
591	var features=[];
592
593	for(var line=0;line<lines.length;line++)
594	{
595	var words=lines[line].split(" ");
596
597	if(line === 0)
598	addBox(words);
599	else if(words[0] !== "")
600	{
601	var dump=words[0];
602	var lat=words[1];
603	var lon=words[2];
604
605	var lonlat = new OpenLayers.LonLat(lon,lat).transform(epsg4326,epsg900913);
606
607	var point = new OpenLayers.Geometry.Point(lonlat.lon,lonlat.lat);
608
609	features.push(new OpenLayers.Feature.Vector(point,{dump: dump},style));
610	}
611	}
612
613	select.activate();
614
615	layerVectors.addFeatures(features);
616
617	displayStatus("data","fixme",lines.length-2);
618	}
619
620
621	//
622	// Failure in getting data.
623	//
624
625	function runFailure(response)
626	{
627	displayStatus("failed");
628	}