reindentation and style
[ikiwiki.git] / IkiWiki / Plugin / osm.pm
1 #!/usr/bin/perl
2 # Copyright 2011 Blars Blarson
3 # Released under GPL version 2
4
5 package IkiWiki::Plugin::osm;
6 use utf8;
7 use strict;
8 use warnings;
9 use IkiWiki 3.0;
10
11 sub import {
12         add_underlay("javascript");
13         hook(type => "getsetup", id => "osm", call => \&getsetup);
14         hook(type => "format", id => "osm", call => \&format);
15         hook(type => "preprocess", id => "osm", call => \&preprocess);
16         hook(type => "preprocess", id => "waypoint", call => \&process_waypoint);
17         hook(type => "savestate", id => "waypoint", call => \&savestate);
18         hook(type => "cgi", id => "osm", call => \&cgi);
19 }
20
21 sub getsetup () {
22         return
23                 plugin => {
24                         safe => 1,
25                         rebuild => 1,
26                         section => "special-purpose",
27                 },
28                 osm_default_zoom => {
29                         type => "integer",
30                         example => "15",
31                         description => "the default zoom when you click on the map link",
32                         safe => 1,
33                         rebuild => 1,
34                 },
35                 osm_default_icon => {
36                         type => "string",
37                         example => "img/osm.png",
38                         description => "the icon shon on links and on the main map",
39                         safe => 0,
40                         rebuild => 1,
41                 },
42                 osm_alt => {
43                         type => "string",
44                         example => "",
45                         description => "the alt tag of links, defaults to empty",
46                         safe => 0,
47                         rebuild => 1,
48                 },
49                 osm_format => {
50                         type => "string",
51                         example => "KML",
52                         description => "the output format for waypoints, can be KML, GeoJSON or CSV (one or many, comma-separated)",
53                         safe => 1,
54                         rebuild => 1,
55                 },
56                 osm_tag_default_icon => {
57                         type => "string",
58                         example => "icon.png",
59                         description => "the icon attached to a tag so that pages tagged with that tag will have that icon on the map",
60                         safe => 0,
61                         rebuild => 1,
62                 },
63                 osm_tag_icons => {
64                         type => "string",
65                         example => {
66                                 'test' => '/img/test.png',
67                                 'trailer' => '/img/trailer.png'
68                         },
69                         description => "tag to icon mapping, leading slash is important!",
70                         safe => 0,
71                         rebuild => 1,
72                 },
73 }
74
75 sub preprocess {
76         my %params=@_;
77         my $page = $params{'page'};
78         my $dest = $params{'destpage'};
79         my $loc = $params{'loc'}; # sanitized below
80         my $lat = $params{'lat'}; # sanitized below
81         my $lon = $params{'lon'}; # sanitized below
82         my $href = $params{'href'};
83
84         my $fullscreen = defined($params{'fullscreen'}); # sanitized here
85         my ($width, $height, $float);
86         if ($fullscreen) {
87                 $height = '100%';
88                 $width = '100%';
89                 $float = 0;
90         }
91         else {
92                 $height = scrub($params{'height'} || "300px", $page, $dest); # sanitized here
93                 $width = scrub($params{'width'} || "500px", $page, $dest); # sanitized here
94                 $float = (defined($params{'right'}) && 'right') || (defined($params{'left'}) && 'left'); # sanitized here
95         }
96         my $zoom = scrub($params{'zoom'} // $config{'osm_default_zoom'} // 15, $page, $dest); # sanitized below
97         my $map;
98         if ($fullscreen) {
99                 $map = $params{'map'} || $page;
100         }
101         else {
102                 $map = $params{'map'} || 'map';
103         }
104         $map = scrub($map, $page, $dest); # sanitized here
105         my $name = scrub($params{'name'} || $map, $page, $dest);
106
107         if (defined($lon) || defined($lat) || defined($loc)) {
108                 ($lon, $lat) = scrub_lonlat($loc, $lon, $lat);
109         }
110
111         if ($zoom !~ /^\d\d?$/ || $zoom < 2 || $zoom > 18) {
112                 error("Bad zoom");
113         }
114         $pagestate{$page}{'osm'}{$map}{'displays'}{$name} = {
115                 height => $height,
116                 width => $width,
117                 float => $float,
118                 zoom => $zoom,
119                 fullscreen => $fullscreen,
120                 editable => defined($params{'editable'}),
121                 lat => $lat,
122                 lon => $lon,
123                 href => $href,
124         };
125         return "<div id=\"mapdiv-$name\"></div>";
126 }
127
128 sub process_waypoint {
129         my %params=@_;
130         my $loc = $params{'loc'}; # sanitized below
131         my $lat = $params{'lat'}; # sanitized below
132         my $lon = $params{'lon'}; # sanitized below
133         my $page = $params{'page'}; # not sanitized?
134         my $dest = $params{'destpage'}; # not sanitized?
135         my $hidden = defined($params{'hidden'}); # sanitized here
136         my ($p) = $page =~ /(?:^|\/)([^\/]+)\/?$/; # shorter page name
137         my $name = scrub($params{'name'} || $p, $page, $dest); # sanitized here
138         my $desc = scrub($params{'desc'} || '', $page, $dest); # sanitized here
139         my $zoom = scrub($params{'zoom'} // $config{'osm_default_zoom'} // 15, $page, $dest); # sanitized below
140         my $icon = $config{'osm__default_icon'} || "img/osm.png"; # sanitized: we trust $config
141         my $map = scrub($params{'map'} || 'map', $page, $dest); # sanitized here
142         my $alt = $config{'osm_alt'} ? "alt=\"$config{'osm_alt'}\"" : ''; # sanitized: we trust $config
143         if ($zoom !~ /^\d\d?$/ || $zoom < 2 || $zoom > 18) {
144                 error("Bad zoom");
145         }
146
147         ($lon, $lat) = scrub_lonlat($loc, $lon, $lat);
148         if (!defined($lat) || !defined($lon)) {
149                 error("Must specify lat and lon");
150         }
151
152         my $tag = $params{'tag'};
153         if ($tag) {
154                 if (!defined($config{'osm_tag_icons'}->{$tag})) {
155                         error("invalid tag specified, see osm_tag_icons configuration or don't specify any");
156                 }
157                 $icon = $config{'osm_tag_icons'}->{$tag};
158         }
159         else {
160                 foreach my $t (keys %{$typedlinks{$page}{'tag'}}) {
161                         if ($icon = get_tag_icon($t)) {
162                                 $tag = $t;
163                                 last;
164                         }
165                         $t =~ s!/$config{'tagbase'}/!!;
166                         if ($icon = get_tag_icon($t)) {
167                                 $tag = $t;
168                                 last;
169                         }
170                 }
171         }
172         $icon = "/img/unknown.png" unless $icon;
173         $tag = '' unless $tag;
174         if ($page eq $dest) {
175                 if (!defined($config{'osm_format'}) || !$config{'osm_format'}) {
176                         $config{'osm_format'} = 'KML';
177                 }
178                 my %formats = map { $_ => 1 } split(/, */, $config{'osm_format'});
179                 if ($formats{'GeoJSON'}) {
180                         will_render($page,$config{destdir} . "/$map/pois.json");
181                 }
182                 if ($formats{'CSV'}) {
183                         will_render($page,$config{destdir} . "/$map/pois.txt");
184                 }
185                 if ($formats{'KML'}) {
186                         will_render($page,$config{destdir} . "/$map/pois.kml");
187                 }
188         }
189         my $href = "/ikiwiki.cgi?do=osm&map=$map&lat=$lat&lon=$lon&zoom=$zoom";
190         if (defined($destsources{htmlpage($map)})) {
191                 $href = urlto($map,$page) . "?lat=$lat&lon=$lon&zoom=$zoom";
192         }
193         $pagestate{$page}{'osm'}{$map}{'waypoints'}{$name} = {
194                 page => $page,
195                 desc => $desc,
196                 icon => $icon,
197                 tag => $tag,
198                 lat => $lat,
199                 lon => $lon,
200                 # how to link back to the page from the map, not to be
201                 # confused with the URL of the map itself sent to the
202                 # embeded map below
203                 href => urlto($page,$map),
204         };
205         my $output = '';
206         if (defined($params{'embed'})) {
207                 $params{'href'} = $href; # propagate down to embeded
208                 $output .= preprocess(%params);
209         }
210         if (!$hidden) {
211                 $href =~ s!&!&amp;!g;
212                 $output .= "<a href=\"$href\"><img class=\"img\" src=\"$icon\" $alt /></a>";
213         }
214         return $output;
215 }
216
217 # get the icon from the given tag
218 sub get_tag_icon($) {
219         my $tag = shift;
220         # look for an icon attached to the tag
221         my $attached = $tag . '/' . $config{'osm_tag_default_icon'};
222         if (srcfile($attached)) {
223                 return $attached;
224         }
225         # look for the old way: mappings
226         if ($config{'osm_tag_icons'}->{$tag}) {
227                 return $config{'osm_tag_icons'}->{$tag};
228         }
229         else {
230                 return undef;
231         }
232 }
233
234 sub scrub_lonlat($$$) {
235         my ($loc, $lon, $lat) = @_;
236         if ($loc) {
237                 if ($loc =~ /^\s*(\-?\d+(?:\.\d*°?|(?:°?|\s)\s*\d+(?:\.\d*\'?|(?:\'|\s)\s*\d+(?:\.\d*)?\"?|\'?)°?)[NS]?)\s*\,?\;?\s*(\-?\d+(?:\.\d*°?|(?:°?|\s)\s*\d+(?:\.\d*\'?|(?:\'|\s)\s*\d+(?:\.\d*)?\"?|\'?)°?)[EW]?)\s*$/) {
238                         $lat = $1;
239                         $lon = $2;
240                 }
241                 else {
242                         error("Bad loc");
243                 }
244         }
245         if (defined($lat)) {
246                 if ($lat =~ /^(\-?)(\d+)(?:(\.\d*)°?|(?:°|\s)\s*(\d+)(?:(\.\d*)\'?|(?:\'|\s)\s*(\d+(?:\.\d*)?\"?)|\'?)|°?)\s*([NS])?\s*$/) {
247                         $lat = $2 + ($3//0) + ((($4//0) + (($5//0) + (($6//0)/60.)))/60.);
248                         if (($1 eq '-') || (($7//'') eq 'S')) {
249                                 $lat = - $lat;
250                         }
251                 }
252                 else {
253                         error("Bad lat");
254                 }
255         }
256         if (defined($lon)) {
257                 if ($lon =~ /^(\-?)(\d+)(?:(\.\d*)°?|(?:°|\s)\s*(\d+)(?:(\.\d*)\'?|(?:\'|\s)\s*(\d+(?:\.\d*)?\"?)|\'?)|°?)\s*([EW])?$/) {
258                         $lon = $2 + ($3//0) + ((($4//0) + (($5//0) + (($6//0)/60.)))/60.);
259                         if (($1 eq '-') || (($7//'') eq 'W')) {
260                                 $lon = - $lon;
261                         }
262                 }
263                 else {
264                         error("Bad lon");
265                 }
266         }
267         if ($lat < -90 || $lat > 90 || $lon < -180 || $lon > 180) {
268                 error("Location out of range");
269         }
270         return ($lon, $lat);
271 }
272
273 sub savestate {
274         my %waypoints = ();
275         my %linestrings = ();
276
277         foreach my $page (keys %pagestate) {
278                 if (exists $pagestate{$page}{'osm'}) {
279                         foreach my $map (keys %{$pagestate{$page}{'osm'}}) {
280                                 foreach my $name (keys %{$pagestate{$page}{'osm'}{$map}{'waypoints'}}) {
281                                         debug("found waypoint $name");
282                                         $waypoints{$map}{$name} = $pagestate{$page}{'osm'}{$map}{'waypoints'}{$name};
283                                 }
284                         }
285                 }
286         }
287
288         foreach my $page (keys %pagestate) {
289                 if (exists $pagestate{$page}{'osm'}) {
290                         foreach my $map (keys %{$pagestate{$page}{'osm'}}) {
291                                 # examine the links on this page
292                                 foreach my $name (keys %{$pagestate{$page}{'osm'}{$map}{'waypoints'}}) {
293                                         if (exists $links{$page}) {
294                                                 foreach my $otherpage (@{$links{$page}}) {
295                                                         if (exists $waypoints{$map}{$otherpage}) {
296                                                                 push(@{$linestrings{$map}}, [
297                                                                         [ $waypoints{$map}{$name}{'lon'}, $waypoints{$map}{$name}{'lat'} ],
298                                                                         [ $waypoints{$map}{$otherpage}{'lon'}, $waypoints{$map}{$otherpage}{'lat'} ]
299                                                                 ]);
300                                                         }
301                                                 }
302                                         }
303                                 }
304                         }
305                         # clear the state, it will be regenerated on the next parse
306                         # the idea here is to clear up removed waypoints...
307                         $pagestate{$page}{'osm'} = ();
308                 }
309         }
310
311         if (!defined($config{'osm_format'}) || !$config{'osm_format'}) {
312                 $config{'osm_format'} = 'KML';
313         }
314         my %formats = map { $_ => 1 } split(/, */, $config{'osm_format'});
315         if ($formats{'GeoJSON'}) {
316                 writejson(\%waypoints, \%linestrings);
317         }
318         if ($formats{'CSV'}) {
319                 writecsvs(\%waypoints, \%linestrings);
320         }
321         if ($formats{'KML'}) {
322                 writekml(\%waypoints, \%linestrings);
323         }
324 }
325
326 sub writejson($;$) {
327         my %waypoints = %{$_[0]};
328         my %linestrings = %{$_[1]};
329         eval q{use JSON};
330         error $@ if $@;
331         foreach my $map (keys %waypoints) {
332                 my %geojson = ( "type" => "FeatureCollection", "features" => []);
333                 foreach my $name (keys %{$waypoints{$map}}) {
334                         my %marker = ( "type" => "Feature",
335                                 "geometry" => { "type" => "Point", "coordinates" => [ $waypoints{$map}{$name}{'lon'}, $waypoints{$map}{$name}{'lat'} ] },
336                                 "properties" => $waypoints{$map}{$name} );
337                         push @{$geojson{'features'}}, \%marker;
338                 }
339                 foreach my $linestring (@{$linestrings{$map}}) {
340                         my %json  = ( "type" => "Feature",
341                                 "geometry" => { "type" => "LineString", "coordinates" => $linestring });
342                         push @{$geojson{'features'}}, \%json;
343                 }
344                 debug('writing pois file pois.json in ' . $config{destdir} . "/$map");
345                 writefile("pois.json",$config{destdir} . "/$map",to_json(\%geojson));
346         }
347 }
348
349 sub writekml($;$) {
350         my %waypoints = %{$_[0]};
351         my %linestrings = %{$_[1]};
352         eval q{use XML::Writer};
353         error $@ if $@;
354         foreach my $map (keys %waypoints) {
355                 debug("writing pois file pois.kml in " . $config{destdir} . "/$map");
356
357 =pod
358 Sample placemark:
359
360 <?xml version="1.0" encoding="UTF-8"?>
361 <kml xmlns="http://www.opengis.net/kml/2.2">
362   <Placemark>
363     <name>Simple placemark</name>
364     <description>Attached to the ground. Intelligently places itself 
365        at the height of the underlying terrain.</description>
366     <Point>
367       <coordinates>-122.0822035425683,37.42228990140251,0</coordinates>
368     </Point>
369   </Placemark>
370 </kml>
371
372 Sample style:
373
374
375         <Style id="sh_sunny_copy69">
376                 <IconStyle>
377                         <scale>1.4</scale>
378                         <Icon>
379                                 <href>http://waypoints.google.com/mapfiles/kml/shapes/sunny.png</href>
380                         </Icon>
381                         <hotSpot x="0.5" y="0.5" xunits="fraction" yunits="fraction"/>
382                 </IconStyle>
383                 <LabelStyle>
384                         <color>ff00aaff</color>
385                 </LabelStyle>
386         </Style>
387
388
389 =cut
390
391                 use IO::File;
392                 my $output = IO::File->new(">".$config{destdir} . "/$map/pois.kml");
393
394                 my $writer = XML::Writer->new( OUTPUT => $output, DATA_MODE => 1, ENCODING => 'UTF-8');
395                 $writer->xmlDecl();
396                 $writer->startTag("kml", "xmlns" => "http://www.opengis.net/kml/2.2");
397
398                 # first pass: get the icons
399                 foreach my $name (keys %{$waypoints{$map}}) {
400                         my %options = %{$waypoints{$map}{$name}};
401                         $writer->startTag("Style", id => $options{tag});
402                         $writer->startTag("IconStyle");
403                         $writer->startTag("Icon");
404                         $writer->startTag("href");
405                         $writer->characters($options{icon});
406                         $writer->endTag();
407                         $writer->endTag();
408                         $writer->endTag();
409                         $writer->endTag();
410                 }
411         
412                 foreach my $name (keys %{$waypoints{$map}}) {
413                         my %options = %{$waypoints{$map}{$name}};
414                         $writer->startTag("Placemark");
415                         $writer->startTag("name");
416                         $writer->characters($name);
417                         $writer->endTag();
418                         $writer->startTag("styleUrl");
419                         $writer->characters('#' . $options{tag});
420                         $writer->endTag();
421                         #$writer->emptyTag('atom:link', href => $options{href});
422                         # to make it easier for us as the atom:link parameter is
423                         # hard to access from javascript
424                         $writer->startTag('href');
425                         $writer->characters($options{href});
426                         $writer->endTag();
427                         $writer->startTag("description");
428                         $writer->characters($options{desc});
429                         $writer->endTag();
430                         $writer->startTag("Point");
431                         $writer->startTag("coordinates");
432                         $writer->characters($options{lon} . "," . $options{lat});
433                         $writer->endTag();
434                         $writer->endTag();
435                         $writer->endTag();
436                 }
437                 
438                 my $i = 0;
439                 foreach my $linestring (@{$linestrings{$map}}) {
440                         $writer->startTag("Placemark");
441                         $writer->startTag("name");
442                         $writer->characters("linestring " . $i++);
443                         $writer->endTag();
444                         $writer->startTag("LineString");
445                         $writer->startTag("coordinates");
446                         my $str = '';
447                         foreach my $coord (@{$linestring}) {
448                                 $str .= join(',', @{$coord}) . " \n";
449                         }
450                         $writer->characters($str);
451                         $writer->endTag();
452                         $writer->endTag();
453                         $writer->endTag();
454                 }
455                 $writer->endTag();
456                 $writer->end();
457                 $output->close();
458         }
459 }
460
461 sub writecsvs($;$) {
462         my %waypoints = %{$_[0]};
463         foreach my $map (keys %waypoints) {
464                 my $poisf = "lat\tlon\ttitle\tdescription\ticon\ticonSize\ticonOffset\n";
465                 foreach my $name (keys %{$waypoints{$map}}) {
466                         my %options = %{$waypoints{$map}{$name}};
467                         my $line = 
468                                 $options{'lat'} . "\t" .
469                                 $options{'lon'} . "\t" .
470                                 $name . "\t" .
471                                 $options{'desc'} . '<br /><a href="' . $options{'page'} . '">' . $name . "</a>\t" .
472                                 $options{'icon'} . "\n";
473                         $poisf .= $line;
474                 }
475                 debug("writing pois file pois.txt in " . $config{destdir} . "/$map");
476                 writefile("pois.txt",$config{destdir} . "/$map",$poisf);
477         }
478 }
479
480 # pipe some data through the HTML scrubber
481 #
482 # code taken from the meta.pm plugin
483 sub scrub($$$) {
484         if (IkiWiki::Plugin::htmlscrubber->can("sanitize")) {
485                 return IkiWiki::Plugin::htmlscrubber::sanitize(
486                         content => shift, page => shift, destpage => shift);
487         }
488         else {
489                 return shift;
490         }
491 }
492
493 # taken from toggle.pm
494 sub format (@) {
495         my %params=@_;
496
497         if ($params{content}=~m!<div[^>]*id="mapdiv-[^"]*"[^>]*>!g) {
498                 if (! ($params{content}=~s!</body>!include_javascript($params{page})."</body>"!em)) {
499                         # no <body> tag, probably in preview mode
500                         $params{content}=$params{content} . include_javascript($params{page});
501                 }
502         }
503         return $params{content};
504 }
505
506 sub prefered_format() {
507         if (!defined($config{'osm_format'}) || !$config{'osm_format'}) {
508                 $config{'osm_format'} = 'KML';
509         }
510         my @spl = split(/, */, $config{'osm_format'});
511         return shift @spl;
512 }
513
514 sub include_javascript ($) {
515         my $page=shift;
516         my $loader;
517
518         eval q{use JSON};
519         error $@ if $@;
520         if (exists $pagestate{$page}{'osm'}) {
521                 foreach my $map (keys %{$pagestate{$page}{'osm'}}) {
522                         foreach my $name (keys %{$pagestate{$page}{'osm'}{$map}{'displays'}}) {
523                                 my %options = %{$pagestate{$page}{'osm'}{$map}{'displays'}{$name}};
524                                 $options{'map'} = $map;
525                                 $options{'format'} = prefered_format();
526                                 $loader .= "mapsetup(\"mapdiv-$name\", " . to_json(\%options) . ");\n";
527                         }
528                 }
529         }
530         if ($loader) {
531                 return embed_map_code() . "<script type=\"text/javascript\" charset=\"utf-8\">$loader</script>";
532         }
533         else {
534                 return '';
535         }
536 }
537
538 sub cgi($) {
539         my $cgi=shift;
540
541         return unless defined $cgi->param('do') &&
542                 $cgi->param("do") eq "osm";
543
544         IkiWiki::decode_cgi_utf8($cgi);
545
546         my $map = $cgi->param('map');
547         if (!defined $map || $map !~ /^[a-z]*$/) {
548                 error("invalid map parameter");
549         }
550
551         print "Content-Type: text/html\r\n";
552         print ("\r\n");
553         print "<html><body>";
554         print "<div id=\"mapdiv-$map\"></div>";
555         print embed_map_code($map);
556         print "<script type=\"text/javascript\" charset=\"utf-8\">mapsetup( 'mapdiv-$map', { 'map': '$map', 'lat': urlParams['lat'], 'lon': urlParams['lon'], 'zoom': urlParams['zoom'], 'fullscreen': 1, 'editable': 1, 'format': '" . prefered_format() . "'});</script>";
557         print "</body></html>";
558
559         exit 0;
560 }
561
562 sub embed_map_code() {
563         return <<EOF;
564 <script src="http://www.openlayers.org/api/OpenLayers.js"></script>
565 <script>
566 // taken from http://stackoverflow.com/questions/901115/get-query-string-values-in-javascript
567 var urlParams = {};
568 (function () {
569         var e,
570         a = /\\+/g,  // Regex for replacing addition symbol with a space
571         r = /([^&=]+)=?([^&]*)/g,
572         d = function (s) { return decodeURIComponent(s.replace(a, " ")); },
573         q = window.location.search.substring(1);
574
575         while (e = r.exec(q))
576         urlParams[d(e[1])] = d(e[2]);
577 })();
578
579 function mapsetup(divname, options) {
580         div = document.getElementById(divname);
581         if (options.fullscreen) {
582                 permalink = 'permalink';
583                 div.style.top = 0;
584                 div.style.left = 0;
585                 div.style.position = 'absolute';
586                 div.style.width = '100%';
587                 div.style.height = '100%';
588         }
589         else {
590                 div.style.height = options.height;
591                 div.style.width = options.width;
592                 div.style.float = options.float;
593                 permalink = {base: options.href, title: "View larger map"};
594         }
595         map = new OpenLayers.Map(divname, {
596                 controls: [
597                         new OpenLayers.Control.Navigation(),
598                         new OpenLayers.Control.ScaleLine(),
599                         new OpenLayers.Control.Permalink(permalink)
600                 ],
601                 displayProjection: new OpenLayers.Projection("EPSG:4326"),
602                 numZoomLevels: 18
603         });
604
605
606         map.addLayer(new OpenLayers.Layer.OSM());
607         if (options.format == 'CSV') {
608                 pois = new OpenLayers.Layer.Text( "CSV",
609                         { location:"/" + options.map + "/pois.txt",
610                           projection: map.displayProjection
611                         });
612         } else if (options.format == 'GeoJSON') {
613                 pois = new OpenLayers.Layer.Vector("GeoJSON", {
614                         protocol: new OpenLayers.Protocol.HTTP({
615                                 url: "/" + options.map + "/pois.json",
616                                 format: new OpenLayers.Format.GeoJSON()
617                         }),
618                         strategies: [new OpenLayers.Strategy.Fixed()]
619                 });
620         } else {
621                 pois = new OpenLayers.Layer.Vector("KML", {
622                         protocol: new OpenLayers.Protocol.HTTP({
623                                 url: "/" + options.map + "/pois.kml",
624                                 format: new OpenLayers.Format.KML({
625                                         extractStyles: true,
626                                         extractAttributes: true
627                                 })
628                         }),
629                 strategies: [new OpenLayers.Strategy.Fixed()]});
630         }
631         map.addLayer(pois);
632         select = new OpenLayers.Control.SelectFeature(pois);
633         map.addControl(select);
634         select.activate();
635
636         pois.events.on({
637                 "featureselected": function (event) {
638                         var feature = event.feature;
639                         var content = '<h2><a href="' + feature.attributes.href + '">' +feature.attributes.name + "</a></h2>" + feature.attributes.description;
640                         popup = new OpenLayers.Popup.FramedCloud("chicken",
641                                 feature.geometry.getBounds().getCenterLonLat(),
642                                 new OpenLayers.Size(100,100),
643                                 content,
644                                 null, true, function () {select.unselectAll()});
645                         feature.popup = popup;
646                         map.addPopup(popup);
647                 },
648                 "featureunselected": function (event) {
649                         var feature = event.feature;
650                         if (feature.popup) {
651                                 map.removePopup(feature.popup);
652                                 feature.popup.destroy();
653                                 delete feature.popup;
654                         }
655                 }
656         });
657
658         if (options.editable) {
659                 vlayer = new OpenLayers.Layer.Vector( "Editable" );
660                 map.addControl(new OpenLayers.Control.EditingToolbar(vlayer));
661                 map.addLayer(vlayer);
662         }
663
664         if (options.fullscreen) {
665                 map.addControl(new OpenLayers.Control.PanZoomBar());
666                 map.addControl(new OpenLayers.Control.LayerSwitcher({'ascending':false}));
667                 map.addControl(new OpenLayers.Control.MousePosition());
668                 map.addControl(new OpenLayers.Control.KeyboardDefaults());
669         } else {
670                 map.addControl(new OpenLayers.Control.ZoomPanel());
671         }
672
673         //Set start centrepoint and zoom    
674         if (!options.lat || !options.lon) {
675                 options.lat = urlParams['lat'];
676                 options.lon = urlParams['lon'];
677         }
678         if (!options.zoom) {
679                 options.zoom = urlParams['zoom'];
680         }
681         if (options.lat && options.lon) {
682                 var lat = options.lat;
683                 var lon = options.lon;
684                 var zoom= options.zoom || 10;
685                 center = new OpenLayers.LonLat( lon, lat ).transform(
686                         new OpenLayers.Projection("EPSG:4326"), // transform from WGS 1984
687                         map.getProjectionObject() // to Spherical Mercator Projection
688                 );
689                 map.setCenter (center, zoom);
690         } else {
691                 pois.events.register("loadend", this, function () { map.zoomToExtent(pois.getDataExtent()); });
692         }
693 }
694 </script>
695 EOF
696 }
697
698 1;