Mercurial > hg > extraction-interface

comparison geotemco/js/Map/MapWidget.js @ 0:b12c99b7c3f0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
commit for previous development
author Zoe Hong <zhong@mpiwg-berlin.mpg.de>
date Mon, 19 Jan 2015 17:13:49 +0100
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:b12c99b7c3f0
1 /*
2 * MapWidget.js
3 *
4 * Copyright (c) 2012, Stefan Jänicke. All rights reserved.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 3 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 * MA 02110-1301 USA
20 */
21
22 /**
23 * @class MapWidget
24 * MapWidget Implementation
25 * @author Stefan Jänicke (stjaenicke@informatik.uni-leipzig.de)
26 * @release 1.0
27 * @release date: 2012-07-27
28 * @version date: 2012-07-27
29 *
30 * @param {MapWrapper} core wrapper for interaction to other widgets
31 * @param {HTML object} div parent div to append the map widget div
32 * @param {JSON} options user specified configuration that overwrites options in MapConfig.js
33 */
34 MapWidget = function(core, div, options) {
35
36 this.core = core;
37 this.core.setWidget(this);
38 this.openlayersMap
39 this.baseLayers
40 this.objectLayer
41
42 this.drawPolygon
43 this.drawCircle
44 this.selectCountry
45 this.dragArea
46 this.selectFeature
47 this.navigation
48
49 this.div = div;
50
51 this.iid = GeoTemConfig.getIndependentId('map');
52 this.config = new MapConfig(options);
53 this.options = this.config.options;
54 this.formerCP = this.options.circlePackings;
55 this.gui = new MapGui(this, this.div, this.options, this.iid);
56
57 this.initialize();
58
59 }
60
61 MapWidget.prototype = {
62
63 /**
64 * initializes the map for the Spatio Temporal Interface.
65 * it includes setting up all layers of the map and defines all map specific interaction possibilities
66 */
67 initialize : function() {
68
69 var map = this;
70
71 //OpenLayers.ProxyHost = "/cgi-bin/proxy.cgi?url=";
72 if (map.options.proxyHost) {
73 OpenLayers.ProxyHost = map.options.proxyHost;
74 }
75
76 this.polygons = [];
77 this.connections = [];
78 this.selection = new Selection();
79 this.wmsOverlays = [];
80
81 this.layerZIndex = 1;
82 this.zIndices = [];
83
84 var activateDrag = function() {
85 map.dragArea.activate();
86 }
87 var deactivateDrag = function() {
88 map.dragArea.deactivate();
89 }
90 this.dragControl = new MapControl(this, null, 'drag', activateDrag, deactivateDrag);
91
92 /*
93 this.editPolygon = document.createElement("div");
94 this.editPolygon.title = GeoTemConfig.getString('editPolygon');
95 this.editPolygon.setAttribute('class','editMapPolygon');
96 this.toolbar.appendChild(this.editPolygon);
97 this.drag.onclick = function(evt){
98 if( map.activeControl == "drag" ){
99 map.deactivate("drag");
100 if( GeoTemConfig.navigate ){
101 map.activate("navigate");
102 }
103 }
104 else {
105 map.deactivate(map.activControl);
106 map.activate("drag");
107 }
108 }
109 map.addEditingMode(new OpenLayers.Control.EditingMode.PointArraySnapping());
110 */
111
112 this.filterBar = new FilterBar(this, this.gui.filterOptions);
113
114 this.objectLayer = new OpenLayers.Layer.Vector("Data Objects", {
115 projection : "EPSG:4326",
116 'displayInLayerSwitcher' : false,
117 rendererOptions : {
118 zIndexing : true
119 }
120 });
121
122 this.markerLayer = new OpenLayers.Layer.Markers("Markers");
123
124 this.navigation = new OpenLayers.Control.Navigation({
125 zoomWheelEnabled : GeoTemConfig.mouseWheelZoom
126 });
127 this.navigation.defaultDblClick = function(evt) {
128 var newCenter = this.map.getLonLatFromViewPortPx(evt.xy);
129 this.map.setCenter(newCenter, this.map.zoom + 1);
130 map.drawObjectLayer(false);
131 if (map.zoomSlider) {
132 map.zoomSlider.setValue(map.getZoom());
133 }
134 }
135 this.navigation.wheelUp = function(evt) {
136 this.wheelChange(evt, 1);
137 }
138 this.navigation.wheelDown = function(evt) {
139 this.wheelChange(evt, -1);
140 }
141
142 this.resolutions = [78271.516953125, 39135.7584765625, 19567.87923828125, 9783.939619140625, 4891.9698095703125, 2445.9849047851562, 1222.9924523925781, 611.4962261962891, 305.74811309814453, 152.87405654907226, 76.43702827453613, 38.218514137268066, 19.109257068634033, 9.554628534317017, 4.777314267158508, 2.388657133579254, 1.194328566789627, 0.5971642833948135, 0.29858214169740677];
143
144 var options = {
145 controls : [this.navigation],
146 projection : new OpenLayers.Projection("EPSG:900913"),
147 displayProjection : new OpenLayers.Projection("EPSG:4326"),
148 resolutions : this.resolutions,
149 units : 'meters',
150 maxExtent : new OpenLayers.Bounds(-20037508.34, -20037508.34, 20037508.34, 20037508.34)
151 };
152 this.openlayersMap = new OpenLayers.Map("mapContainer"+this.iid, options);
153 if (map.options.navigate) {
154 this.activeControl = "navigate";
155 }
156 //add attribution control
157 this.openlayersMap.addControl(new OpenLayers.Control.Attribution());
158 this.mds = new MapDataSource(this, this.options);
159
160 //on zoomend, redraw objects and set slider (if it exists) accordingly (zoom by mouse wheel)
161 this.openlayersMap.events.register("zoomend", map, function(){
162 map.drawObjectLayer(false);
163 if (map.zoomSlider) {
164 map.zoomSlider.setValue(map.getZoom());
165 }
166 map.core.triggerHighlight([]);
167 });
168
169 if (map.options.olNavigation) {
170 var zoomPanel = new OpenLayers.Control.PanZoom();
171 zoomPanel.onButtonClick = function(evt) {
172 var btn = evt.buttonElement;
173 switch (btn.action) {
174 case "panup":
175 this.map.pan(0, -this.getSlideFactor("h"));
176 break;
177 case "pandown":
178 this.map.pan(0, this.getSlideFactor("h"));
179 break;
180 case "panleft":
181 this.map.pan(-this.getSlideFactor("w"), 0);
182 break;
183 case "panright":
184 this.map.pan(this.getSlideFactor("w"), 0);
185 break;
186 case "zoomin":
187 map.zoom(1);
188 break;
189 case "zoomout":
190 map.zoom(-1);
191 break;
192 case "zoomworld":
193 if (this.map) {
194 map.zoom(this.map.zoom * -1);
195 }
196 break;
197 }
198 };
199 this.openlayersMap.addControl(zoomPanel);
200 }
201
202 if (map.options.popups) {
203 var panMap = function() {
204 if (map.selectedGlyph) {
205 var lonlat = new OpenLayers.LonLat(map.selectedGlyph.lon, map.selectedGlyph.lat);
206 var pixel = map.openlayersMap.getPixelFromLonLat(lonlat);
207 if (map.popup) {
208 map.popup.shift(pixel.x, pixel.y);
209 }
210 }
211 }
212 this.openlayersMap.events.register("move", this.openlayersMap, panMap);
213 }
214
215 if (map.options.olMapOverview) {
216 this.openlayersMap.addControl(new OpenLayers.Control.OverviewMap());
217 }
218 if (map.options.olKeyboardDefaults) {
219 var keyboardControl = new OpenLayers.Control.KeyboardDefaults();
220 keyboardControl.defaultKeyPress = function(evt) {
221 switch(evt.keyCode) {
222 case OpenLayers.Event.KEY_LEFT:
223 this.map.pan(-this.slideFactor, 0);
224 break;
225 case OpenLayers.Event.KEY_RIGHT:
226 this.map.pan(this.slideFactor, 0);
227 break;
228 case OpenLayers.Event.KEY_UP:
229 this.map.pan(0, -this.slideFactor);
230 break;
231 case OpenLayers.Event.KEY_DOWN:
232 this.map.pan(0, this.slideFactor);
233 break;
234
235 case 33:
236 // Page Up. Same in all browsers.
237 var size = this.map.getSize();
238 this.map.pan(0, -0.75 * size.h);
239 break;
240 case 34:
241 // Page Down. Same in all browsers.
242 var size = this.map.getSize();
243 this.map.pan(0, 0.75 * size.h);
244 break;
245 case 35:
246 // End. Same in all browsers.
247 var size = this.map.getSize();
248 this.map.pan(0.75 * size.w, 0);
249 break;
250 case 36:
251 // Home. Same in all browsers.
252 var size = this.map.getSize();
253 this.map.pan(-0.75 * size.w, 0);
254 break;
255
256 case 43:
257 // +/= (ASCII), keypad + (ASCII, Opera)
258 case 61:
259 // +/= (Mozilla, Opera, some ASCII)
260 case 187:
261 // +/= (IE)
262 case 107:
263 // keypad + (IE, Mozilla)
264 map.zoom(1);
265 break;
266 case 45:
267 // -/_ (ASCII, Opera), keypad - (ASCII, Opera)
268 case 109:
269 // -/_ (Mozilla), keypad - (Mozilla, IE)
270 case 189:
271 // -/_ (IE)
272 case 95:
273 // -/_ (some ASCII)
274 map.zoom(-1);
275 break;
276 }
277 };
278 this.openlayersMap.addControl(keyboardControl);
279 }
280 if (map.options.olLayerSwitcher) {
281 this.openlayersMap.addControl(new OpenLayers.Control.LayerSwitcher());
282 }
283 if (map.options.olScaleLine) {
284 this.openlayersMap.addControl(new OpenLayers.Control.ScaleLine());
285 }
286 this.gui.resize();
287 this.setBaseLayers();
288 this.gui.setMapsDropdown();
289 this.gui.setMap();
290 this.openlayersMap.addLayers([this.objectLayer, this.markerLayer]);
291
292 if (map.options.boundaries) {
293 var boundaries = map.options.boundaries;
294 var bounds = new OpenLayers.Bounds(boundaries.minLon, boundaries.minLat, boundaries.maxLon, boundaries.maxLat);
295 var projectionBounds = bounds.transform(this.openlayersMap.displayProjection, this.openlayersMap.projection);
296 this.openlayersMap.zoomToExtent(projectionBounds);
297 } else {
298 this.openlayersMap.zoomToMaxExtent();
299 }
300
301 // manages selection of elements if a polygon was drawn
302 this.drawnPolygonHandler = function(polygon) {
303 if (map.mds.getAllObjects() == null) {
304 return;
305 }
306 var polygonFeature;
307 if ( polygon instanceof OpenLayers.Geometry.Polygon) {
308 polygonFeature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.MultiPolygon([polygon]));
309 } else if ( polygon instanceof OpenLayers.Geometry.MultiPolygon) {
310 polygonFeature = new OpenLayers.Feature.Vector(polygon);
311 }
312 map.polygons.push(polygonFeature);
313 var style = $.extend(true, {}, OpenLayers.Feature.Vector.style['default']);
314 style.graphicZIndex = 0;
315 polygonFeature.style = style;
316 map.objectLayer.addFeatures([polygonFeature]);
317 try {
318 map.activeControl.deactivate();
319 } catch(e) {
320 }
321 var circles = map.mds.getObjectsByZoom();
322 for (var i = 0; i < circles.length; i++) {
323 for (var j = 0; j < circles[i].length; j++) {
324 var c = circles[i][j];
325 if (map.inPolygon(c)) {
326 if ( typeof c.fatherBin != 'undefined') {
327 for (var k = 0; k < c.fatherBin.circles.length; k++) {
328 if (c.fatherBin.circles[k]) {
329 c.fatherBin.circles[k].setSelection(true);
330 }
331 }
332 } else {
333 c.setSelection(true);
334 }
335 }
336 }
337 }
338 map.mapSelection();
339 }
340
341 this.polygonDeselection = function() {
342 var circles = map.mds.getObjectsByZoom();
343 for (var i = 0; i < circles.length; i++) {
344 for (var j = 0; j < circles[i].length; j++) {
345 var c = circles[i][j];
346 if (map.inPolygon(c)) {
347 c.setSelection(false);
348 }
349 }
350 }
351 }
352 this.snapper = function() {
353 if (map.polygons.length == 0 || !map.options.multiSelection) {
354 map.deselection();
355 }
356 }
357 if (map.options.polygonSelect) {
358 this.drawPolygon = new OpenLayers.Control.DrawFeature(map.objectLayer, OpenLayers.Handler.Polygon, {
359 displayClass : "olControlDrawFeaturePolygon",
360 callbacks : {
361 "done" : map.drawnPolygonHandler,
362 "create" : map.snapper
363 }
364 });
365 this.openlayersMap.addControl(this.drawPolygon);
366 }
367
368 if (map.options.circleSelect) {
369 this.drawCircle = new OpenLayers.Control.DrawFeature(map.objectLayer, OpenLayers.Handler.RegularPolygon, {
370 displayClass : "olControlDrawFeaturePolygon",
371 handlerOptions : {
372 sides : 40
373 },
374 callbacks : {
375 "done" : map.drawnPolygonHandler,
376 "create" : map.snapper
377 }
378 });
379 this.openlayersMap.addControl(this.drawCircle);
380 }
381
382 if (map.options.squareSelect) {
383 this.drawSquare = new OpenLayers.Control.DrawFeature(map.objectLayer, OpenLayers.Handler.RegularPolygon, {
384 displayClass : "olControlDrawFeaturePolygon",
385 handlerOptions : {
386 sides : 4,
387 irregular: true
388 },
389 callbacks : {
390 "done" : map.drawnPolygonHandler,
391 "create" : map.snapper
392 }
393 });
394 this.openlayersMap.addControl(this.drawSquare);
395 }
396
397 if (map.options.polygonSelect || map.options.circleSelect || map.options.squareSelect) {
398 this.dragArea = new OpenLayers.Control.DragFeature(map.objectLayer, {
399 onStart : function(feature) {
400 feature.style.graphicZIndex = 10000;
401 map.polygonDeselection();
402 },
403 onComplete : function(feature) {
404 feature.style.graphicZIndex = 0;
405 map.drawnPolygonHandler(feature.geometry);
406 }
407 });
408 this.openlayersMap.addControl(this.dragArea);
409
410 this.modifyArea = new OpenLayers.Control.ModifyFeature(map.objectLayer, {
411 onStart : function(feature) {
412 feature.style.graphicZIndex = 10000;
413 map.polygonDeselection();
414 },
415 onComplete : function(feature) {
416 feature.style.graphicZIndex = 0;
417 map.drawnPolygonHandler(feature.geometry);
418 }
419 });
420 this.openlayersMap.addControl(this.modifyArea);
421 this.modifyArea.mode = OpenLayers.Control.ModifyFeature.RESHAPE;
422
423 }
424
425 // calculates the tag cloud
426 // manages hover selection of point objects
427 var hoverSelect = function(event) {
428 var object = event.feature;
429 if (object.geometry instanceof OpenLayers.Geometry.Point) {
430 if ( typeof map.placenameTags != 'undefined') {
431 map.placenameTags.remove();
432 }
433 var circle = event.feature.parent;
434 if ( circle instanceof CircleObject) {
435 circle.placenameTags = new PlacenameTags(circle, map);
436 map.placenameTags = circle.placenameTags;
437 } else {
438 return;
439 /*
440 event.feature.style.fillOpacity = 0.2;
441 event.feature.style.strokeOpacity = 1;
442 map.objectLayer.drawFeature(event.feature);
443 circle.placenameTags = new PackPlacenameTags(circle,map);
444 */
445 }
446 circle.placenameTags.calculate();
447 map.mapCircleHighlight(object.parent, false);
448 if ( typeof map.featureInfo != 'undefined') {
449 map.featureInfo.deactivate();
450 }
451 } else {
452 map.dragControl.checkStatus();
453 }
454 };
455 var hoverUnselect = function(event) {
456 var object = event.feature;
457 if (object.geometry instanceof OpenLayers.Geometry.Point) {
458 var circle = event.feature.parent;
459 if (!( circle instanceof CircleObject )) {
460 return;
461 /*
462 event.feature.style.fillOpacity = 0;
463 event.feature.style.strokeOpacity = 0;
464 map.objectLayer.drawFeature(event.feature);
465 */
466 }
467 circle.placenameTags.remove();
468 map.mapCircleHighlight(object.parent, true);
469 if ( typeof map.featureInfo != 'undefined') {
470 map.featureInfo.activate();
471 }
472 } else {
473 map.dragControl.deactivate();
474 }
475 };
476 var highlightCtrl = new OpenLayers.Control.SelectFeature(this.objectLayer, {
477 hover : true,
478 highlightOnly : true,
479 renderIntent : "temporary",
480 eventListeners : {
481 featurehighlighted : hoverSelect,
482 featureunhighlighted : hoverUnselect
483 }
484 });
485 this.openlayersMap.addControl(highlightCtrl);
486 highlightCtrl.activate();
487
488 this.selectFeature = new OpenLayers.Control.SelectFeature(this.objectLayer);
489
490 document.onkeydown = function(e) {
491 if (e.ctrlKey) {
492 map.ctrlKey = true;
493 }
494 }
495 document.onkeyup = function(e) {
496 map.ctrlKey = false;
497 }
498 // manages click selection of point objects
499 var onFeatureSelect = function(event, evt) {
500 if (!(event.feature.geometry instanceof OpenLayers.Geometry.Point)) {
501 return;
502 }
503 var circle = event.feature.parent;
504 if (map.options.multiSelection && map.ctrlKey) {
505 if (map.popup) {
506 map.popup.reset();
507 map.selectedGlyph = false;
508 }
509 circle.toggleSelection();
510 map.mapSelection();
511 return;
512 }
513 map.reset();
514 circle.setSelection(true);
515 map.objectLayer.drawFeature(circle.feature);
516 if (map.options.popups) {
517 if (map.popup) {
518 map.popup.reset();
519 }
520 var lonlat = event.feature.geometry.getBounds().getCenterLonLat();
521 var pixel = map.openlayersMap.getPixelFromLonLat(lonlat);
522 map.selectedGlyph = {
523 lon : lonlat.lon,
524 lat : lonlat.lat
525 };
526 map.popup = new PlacenamePopup(map);
527 map.popup.createPopup(pixel.x, pixel.y, circle.placenameTags.placeLabels);
528 if (map.options.selectDefault) {
529 circle.placenameTags.selectLabel();
530 }
531 }
532 }
533 this.objectLayer.events.on({
534 "featureselected" : onFeatureSelect
535 });
536
537 this.openlayersMap.addControl(this.selectFeature);
538 this.selectFeature.activate();
539
540 if (this.zoomSlider) {
541 this.zoomSlider.setMaxAndLevels(1000, this.openlayersMap.getNumZoomLevels());
542 this.zoomSlider.setValue(this.getZoom());
543 }
544
545 Publisher.Subscribe('mapChanged', this, function(mapName) {
546 this.client.setBaseLayerByName(mapName);
547 this.client.gui.setMap();
548 });
549
550 },
551
552 shift : function(shiftX, shiftY) {
553 this.openlayersMap.pan(shiftX, shiftY);
554 },
555
556 addBaseLayers : function(layers) {
557 if ( layers instanceof Array) {
558 for (var i in layers ) {
559 var layer;
560 if (layers[i].type === "XYZ"){
561 layer = new OpenLayers.Layer.XYZ(
562 layers[i].name,
563 [
564 layers[i].url
565 ],
566 {
567 sphericalMercator: true,
568 transitionEffect: "resize",
569 buffer: 1,
570 numZoomLevels: 12,
571 transparent : true,
572 attribution: layers[i].attribution
573 },
574 {
575 isBaseLayer : true
576 }
577 );
578 } else {
579 layer = new OpenLayers.Layer.WMS(
580 layers[i].name, layers[i].url,
581 {
582 projection : "EPSG:4326",
583 layers : layers[i].layer,
584 transparent : "true",
585 format : "image/png"
586 },
587 {
588 attribution: layers[i].attribution,
589 isBaseLayer : true
590 }
591 );
592 }
593 this.baseLayers.push(layer);
594 this.openlayersMap.addLayers([layer]);
595 }
596 }
597 this.gui.setMapsDropdown();
598 },
599
600 /**
601 * set online available maps for Google, Bing and OSM
602 */
603 setBaseLayers : function() {
604 this.baseLayers = [];
605 if (this.options.googleMaps) {
606 // see http://openlayers.org/blog/2010/07/10/google-maps-v3-for-openlayers/ for information
607 var gphy = new OpenLayers.Layer.Google("Google Physical", {
608 type : google.maps.MapTypeId.TERRAIN,
609 minZoomLevel : 1,
610 maxZoomLevel : 19
611 });
612 var gmap = new OpenLayers.Layer.Google("Google Streets", {
613 minZoomLevel : 1,
614 maxZoomLevel : 19
615 });
616 var ghyb = new OpenLayers.Layer.Google("Google Hybrid", {
617 type : google.maps.MapTypeId.HYBRID,
618 minZoomLevel : 1,
619 maxZoomLevel : 19
620 });
621 var gsat = new OpenLayers.Layer.Google("Google Satellite", {
622 type : google.maps.MapTypeId.SATELLITE,
623 minZoomLevel : 1,
624 maxZoomLevel : 19
625 });
626 this.baseLayers.push(gphy);
627 this.baseLayers.push(gmap);
628 this.baseLayers.push(ghyb);
629 this.baseLayers.push(gsat);
630 }
631 if (this.options.bingMaps) {
632 // see http://openlayers.org/blog/2010/12/18/bing-tiles-for-openlayers/ for information
633 var apiKey = this.options.bingApiKey;
634 var road = new OpenLayers.Layer.Bing({
635 name : "Road",
636 key : apiKey,
637 type : "Road"
638 });
639 var hybrid = new OpenLayers.Layer.Bing({
640 name : "Hybrid",
641 key : apiKey,
642 type : "AerialWithLabels"
643 });
644 var aerial = new OpenLayers.Layer.Bing({
645 name : "Aerial",
646 key : apiKey,
647 type : "Aerial"
648 });
649 this.baseLayers.push(road);
650 this.baseLayers.push(hybrid);
651 this.baseLayers.push(aerial);
652 }
653 if (this.options.osmMaps) {
654 this.baseLayers.push(new OpenLayers.Layer.OSM('Open Street Map', '', {
655 sphericalMercator : true,
656 zoomOffset : 1,
657 resolutions : this.resolutions
658 }));
659 }
660 if (this.options.osmMapsMapQuest) {
661 this.baseLayers.push(new OpenLayers.Layer.OSM('Open Street Map (MapQuest)',
662 ["http://otile1.mqcdn.com/tiles/1.0.0/map/${z}/${x}/${y}.png",
663 "http://otile2.mqcdn.com/tiles/1.0.0/map/${z}/${x}/${y}.png",
664 "http://otile3.mqcdn.com/tiles/1.0.0/map/${z}/${x}/${y}.png",
665 "http://otile4.mqcdn.com/tiles/1.0.0/map/${z}/${x}/${y}.png"],
666 {
667 sphericalMercator : true,
668 zoomOffset : 1,
669 resolutions : this.resolutions
670 }
671 ));
672 }
673 for (var i = 0; i < this.baseLayers.length; i++) {
674 this.openlayersMap.addLayers([this.baseLayers[i]]);
675 }
676 if (this.options.alternativeMap) {
677 if (!(this.options.alternativeMap instanceof Array))
678 this.options.alternativeMap = [this.options.alternativeMap];
679 this.addBaseLayers(this.options.alternativeMap);
680 }
681 this.setBaseLayerByName(this.options.baseLayer);
682 },
683
684 setBaseLayerByName : function(name){
685 for (var i = 0; i < this.baseLayers.length; i++) {
686 if (this.baseLayers[i].name == name) {
687 this.setMap(i);
688 }
689 }
690 },
691
692 getBaseLayerName : function() {
693 return this.openlayersMap.baseLayer.name;
694 },
695
696 setOverlays : function(layers) {
697 var map = this;
698 for (var i in this.wmsOverlays ) {
699 this.openlayersMap.removeLayer(this.wmsOverlays[i]);
700 }
701 this.wmsOverlays = [];
702 var featureInfoLayers = [];
703 if ( layers instanceof Array) {
704 for (var i in layers ) {
705 var layer = new OpenLayers.Layer.WMS(layers[i].name, layers[i].url, {
706 projection : "EPSG:4326",
707 layers : layers[i].layer,
708 transparent : "true",
709 format : "image/png"
710 }, {
711 isBaseLayer : false,
712 visibility : map.options.overlayVisibility
713 });
714 this.wmsOverlays.push(layer);
715 if (layers[i].featureInfo) {
716 featureInfoLayers.push(layer);
717 }
718 }
719 this.openlayersMap.addLayers(this.wmsOverlays);
720 }
721 if (this.wmsOverlays.length > 0 && map.options.overlayVisibility) {
722 var map = this;
723 if ( typeof this.featureInfo != 'undefined') {
724 this.featureInfo.deactivate();
725 this.openlayersMap.removeControl(this.featureInfo);
726 }
727 this.featureInfo = new OpenLayers.Control.WMSGetFeatureInfo({
728 url : '/geoserver/wms',
729 layers : featureInfoLayers,
730 eventListeners : {
731 getfeatureinfo : function(event) {
732 if (event.text == '') {
733 return;
734 }
735 var lonlat = map.openlayersMap.getLonLatFromPixel(new OpenLayers.Pixel(event.xy.x, event.xy.y));
736 map.selectedGlyph = {
737 lon : lonlat.lon,
738 lat : lonlat.lat
739 };
740 if ( typeof map.popup != 'undefined') {
741 map.popup.reset();
742 }
743 map.popup = new MapPopup(map);
744 map.popup.initialize(event.xy.x, event.xy.y);
745 map.popup.setContent(event.text);
746 }
747 }
748 });
749 this.openlayersMap.addControl(this.featureInfo);
750 this.featureInfo.activate();
751 this.activateCountrySelector(this.wmsOverlays[this.wmsOverlays.length - 1]);
752 } else {
753 this.deactivateCountrySelector();
754 if (this.openlayersMap.baseLayer instanceof OpenLayers.Layer.WMS) {
755 this.activateCountrySelector(this.openlayersMap.baseLayer);
756 }
757 }
758 },
759
760 addBaseLayer : function(layer) {
761 this.baseLayers.push(layer);
762 this.openlayersMap.addLayers([layer]);
763 for (var i in this.baseLayers ) {
764 if (this.baseLayers[i].name == this.options.baseLayer) {
765 this.setMap(i);
766 }
767 }
768 },
769
770 /**
771 * draws the object layer.
772 * @param {boolean} zoom if there was a zoom; if not, the new boundary of the map is calculated
773 */
774 drawObjectLayer : function(zoom) {
775 if ( typeof this.placenameTags != 'undefined') {
776 this.placenameTags.remove();
777 }
778 var points = this.mds.getAllObjects();
779 if (points == null) {
780 return;
781 }
782 this.objectLayer.removeAllFeatures();
783
784 if (zoom) {
785 var minLat, maxLat, minLon, maxLon;
786 var pointsHighestZoom = points[points.length - 1];
787 for (var i = 0; i < pointsHighestZoom.length; i++) {
788 for (var j = 0; j < pointsHighestZoom[i].length; j++) {
789 var point = pointsHighestZoom[i][j];
790 if (minLon == null || point.originX < minLon) {
791 minLon = point.originX;
792 }
793 if (maxLon == null || point.originX > maxLon) {
794 maxLon = point.originX;
795 }
796 if (minLat == null || point.originY < minLat) {
797 minLat = point.originY;
798 }
799 if (maxLat == null || point.originY > maxLat) {
800 maxLat = point.originY;
801 }
802 }
803 }
804 if (minLon == maxLon && minLat == maxLat) {
805 this.openlayersMap.setCenter(new OpenLayers.LonLat(minLon, minLat));
806 } else {
807 var gapX = 0.1 * (maxLon - minLon );
808 var gapY1 = 0.1 * (maxLat - minLat );
809 var gapY2 = (this.gui.headerHeight / this.gui.mapWindow.offsetHeight + 0.1 ) * (maxLat - minLat );
810 this.openlayersMap.zoomToExtent(new OpenLayers.Bounds(minLon - gapX, minLat - gapY1, maxLon + gapX, maxLat + gapY2));
811 this.openlayersMap.zoomTo(Math.floor(this.getZoom()));
812 }
813 if (this.zoomSlider) {
814 this.zoomSlider.setValue(this.getZoom());
815 }
816 }
817 var displayPoints = this.mds.getObjectsByZoom();
818 var resolution = this.openlayersMap.getResolution();
819 for (var i = 0; i < displayPoints.length; i++) {
820 for (var j = 0; j < displayPoints[i].length; j++) {
821 var p = displayPoints[i][j];
822 var x = p.originX + resolution * p.shiftX;
823 var y = p.originY + resolution * p.shiftY;
824 p.feature.geometry.x = x;
825 p.feature.geometry.y = y;
826 p.olFeature.geometry.x = x;
827 p.olFeature.geometry.y = y;
828 p.feature.style.graphicZIndex = this.zIndices[i];
829 p.olFeature.style.graphicZIndex = this.zIndices[i] + 1;
830 this.objectLayer.addFeatures([p.feature]);
831 this.objectLayer.addFeatures([p.olFeature]);
832 }
833 }
834 var zoomLevel = this.getZoom();
835 /*
836 for (var i = 0; i < this.bins[zoomLevel].length; i++) {
837 var p = this.bins[zoomLevel][i];
838 p.feature.style.graphicZIndex = 0;
839 this.objectLayer.addFeatures([p.feature]);
840 }
841 */
842
843 var dist = function(p1, p2) {
844 return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
845 }
846
847 this.highlightChanged(this.selection.getObjects(this.core));
848
849 },
850
851 riseLayer : function(id) {
852 this.lastId = id;
853 if ( typeof id == 'undefined') {
854 id = this.lastId || 0;
855 }
856 this.zIndices[id] = this.layerZIndex;
857 this.layerZIndex += 2;
858 this.drawObjectLayer(false);
859 for( var i=0; i<this.polygons.length; i++ ){
860 this.objectLayer.addFeatures([this.polygons[i]]);
861 }
862 },
863
864 /**
865 * initializes the object layer.
866 * all point representations for all zoom levels are calculated and initialized
867 * @param {MapObject[][]} mapObjects an array of map objects from different (1-4) sets
868 */
869 initWidget : function(datasets, zoom) {
870
871 this.clearMap();
872
873 this.datasets = datasets;
874 var mapObjects = [];
875 for (var i = 0; i < datasets.length; i++) {
876 mapObjects.push(datasets[i].objects);
877 }
878 if (mapObjects.length > 4) {
879 this.options.circlePackings = false;
880 } else {
881 this.options.circlePackings = this.formerCP;
882 }
883
884 if ( typeof mapObjects == 'undefined') {
885 return;
886 }
887
888 this.count = 0;
889 this.objectCount = 0;
890 for (var i = 0; i < mapObjects.length; i++) {
891 var c = 0;
892 for (var j = 0; j < mapObjects[i].length; j++) {
893 if (mapObjects[i][j].isGeospatial) {
894 c += mapObjects[i][j].weight;
895 this.objectCount++;
896 }
897 }
898 this.count += c;
899 this.zIndices.push(this.layerZIndex);
900 this.layerZIndex += 2;
901 }
902
903 this.mds.initialize(mapObjects);
904 var points = this.mds.getAllObjects();
905 if (points == null) {
906 return;
907 }
908
909 var getArea = function(radius) {
910 return Math.PI * radius * radius;
911 }
912 for (var i = 0; i < points.length; i++) {
913 var area = 0;
914 var maxRadius = 0;
915 for (var j = 0; j < points[i].length; j++) {
916 for (var k = 0; k < points[i][j].length; k++) {
917 if (points[i][j][k].radius > maxRadius) {
918 maxRadius = points[i][j][k].radius;
919 area = getArea(maxRadius);
920 }
921 }
922 }
923 var minArea = getArea(this.options.minimumRadius);
924 var areaDiff = area - minArea;
925 for (var j = 0; j < points[i].length; j++) {
926 for (var k = 0; k < points[i][j].length; k++) {
927 var point = points[i][j][k];
928 var c, shape, rotation, multiplier = 1;
929 if( this.options.useGraphics ){
930 var graphic = this.config.getGraphic(point.search);
931 c = graphic.color;
932 shape = graphic.shape;
933 rotation = graphic.rotation;
934 if( shape == 'square' ){
935 multiplier = 0.75;
936 }
937 }
938 else {
939 c = GeoTemConfig.getAverageDatasetColor(point.search,point.elements);
940 shape = 'circle';
941 rotation = 0;
942 }
943 var opacity;
944 if (this.options.circleOpacity == 'balloon') {
945 var min = this.options.minTransparency;
946 var max = this.options.maxTransparency;
947 opacity = min + Math.abs(min - max) * (1 - (getArea(point.radius) - minArea) / areaDiff);
948 }
949 else {
950 opacity = this.options.circleOpacity;
951 }
952 var col = false, ols = 0;
953 if( this.options.circleOutline ){
954 col = true;
955 ols = this.options.circleOutline;
956 }
957 var style = {
958 graphicName: shape,
959 rotation: rotation,
960 fillColor : 'rgb(' + c.r0 + ',' + c.g0 + ',' + c.b0 + ')',
961 fillOpacity : opacity,
962 strokeWidth : ols,
963 strokeColor : 'rgb(' + c.r1 + ',' + c.g1 + ',' + c.b1 + ')',
964 stroke : col,
965 pointRadius : point.radius * multiplier,
966 cursor : "pointer"
967 };
968 var pointGeometry = new OpenLayers.Geometry.Point(point.originX, point.originY, null);
969 var feature = new OpenLayers.Feature.Vector(pointGeometry);
970 feature.style = style;
971 feature.parent = point;
972 point.setFeature(feature);
973 var olStyle = {
974 graphicName: shape,
975 rotation: rotation,
976 fillColor : 'rgb(' + c.r1 + ',' + c.g1 + ',' + c.b1 + ')',
977 fillOpacity : opacity,
978 stroke : false,
979 pointRadius : 0,
980 cursor : "pointer"
981 };
982 var olPointGeometry = new OpenLayers.Geometry.Point(point.originX, point.originY, null);
983 var olFeature = new OpenLayers.Feature.Vector(olPointGeometry);
984 olFeature.style = olStyle;
985 olFeature.parent = point;
986 point.setOlFeature(olFeature);
987 }
988 }
989 }
990
991 /*
992 this.bins = this.mds.getAllBins();
993 for (var i = 0; i < this.bins.length; i++) {
994 for (var j = 0; j < this.bins[i].length; j++) {
995 var bin = this.bins[i][j];
996 var style = {
997 fillColor : 'rgb(140,140,140)',
998 fillOpacity : 0,
999 strokeWidth : 2,
1000 strokeOpacity : 0,
1001 strokeColor : 'rgb(140,140,140)',
1002 // stroke: false,
1003 pointRadius : bin.radius,
1004 cursor : "pointer"
1005 };
1006 var pointGeometry = new OpenLayers.Geometry.Point(bin.x, bin.y, null);
1007 var feature = new OpenLayers.Feature.Vector(pointGeometry);
1008 feature.style = style;
1009 feature.parent = bin;
1010 bin.feature = feature;
1011 }
1012 }
1013 */
1014
1015 this.gui.updateLegend(datasets);
1016
1017 if ( typeof zoom == "undefined") {
1018 this.drawObjectLayer(true);
1019 } else {
1020 this.drawObjectLayer(zoom);
1021 }
1022 this.gui.updateSpaceQuantity(this.count);
1023
1024 },
1025
1026 /**
1027 * resets the map by destroying all additional elements except the point objects, which are replaced
1028 */
1029 reset : function() {
1030 if ( typeof this.placenameTags != 'undefined') {
1031 this.placenameTags.remove();
1032 }
1033 this.objectLayer.removeFeatures(this.polygons);
1034 this.polygons = [];
1035 this.objectLayer.removeFeatures(this.connections);
1036 this.connections = [];
1037 this.selectFeature.unselectAll();
1038 this.selectedGlyph = false;
1039 if (this.dragControl.activated) {
1040 this.dragControl.deactivate();
1041 }
1042 if (this.popup) {
1043 this.popup.reset();
1044 }
1045 this.filterBar.reset(false);
1046 var points = this.mds.getObjectsByZoom();
1047 if (points == null) {
1048 return;
1049 }
1050 for (var i = 0; i < points.length; i++) {
1051 for (var j = 0; j < points[i].length; j++) {
1052 points[i][j].setSelection(false);
1053 }
1054 }
1055 },
1056
1057 /**
1058 * resets the map by destroying all elements
1059 */
1060 clearMap : function() {
1061 this.reset();
1062 this.selection = new Selection();
1063 this.zIndices = [];
1064 this.layerZIndex = 1;
1065 this.objectLayer.destroyFeatures();
1066 },
1067
1068 /**
1069 * updates the proportional selection status of a point object
1070 * @param {PointObject} point the point to update
1071 * @param {OpenLayers.Geometry.Polygon} polygon the actual displayed map polygon
1072 */
1073 updatePoint : function(point, polygon) {
1074 var olRadius = this.mds.binning.getRadius(point.overlay);
1075 if( this.options.useGraphics ){
1076 var graphic = this.config.getGraphic(point.search);
1077 if( graphic.shape == 'square' ){
1078 olRadius *= 0.75;
1079 }
1080 }
1081 point.olFeature.style.pointRadius = olRadius;
1082 var c = GeoTemConfig.getAverageDatasetColor(point.search, point.overlayElements);
1083 point.olFeature.style.fillColor = 'rgb(' + c.r1 + ',' + c.g1 + ',' + c.b1 + ')';
1084 if (polygon.containsPoint(point.feature.geometry)) {
1085 this.objectLayer.drawFeature(point.olFeature);
1086 }
1087 },
1088
1089 /**
1090 * updates the the object layer of the map after selections had been executed in timeplot or table or zoom level has changed
1091 */
1092 highlightChanged : function(mapObjects) {
1093 if( !GeoTemConfig.highlightEvents ){
1094 return;
1095 }
1096 this.mds.clearOverlay();
1097 if (this.selection.valid()) {
1098 this.mds.setOverlay(GeoTemConfig.mergeObjects(mapObjects, this.selection.getObjects()));
1099 } else {
1100 this.mds.setOverlay(mapObjects);
1101 }
1102 var points = this.mds.getObjectsByZoom();
1103 var polygon = this.openlayersMap.getExtent().toGeometry();
1104 for (var i in points ) {
1105 for (var j in points[i] ) {
1106 this.updatePoint(points[i][j], polygon);
1107 }
1108 }
1109 this.displayConnections();
1110 },
1111
1112 selectionChanged : function(selection) {
1113 if( !GeoTemConfig.selectionEvents ){
1114 return;
1115 }
1116 this.reset();
1117 this.selection = selection;
1118 this.highlightChanged(selection.objects);
1119 },
1120
1121 inPolygon : function(point) {
1122 for (var i = 0; i < this.polygons.length; i++) {
1123 var polygon = this.polygons[i].geometry;
1124 for (var j = 0; j < polygon.components.length; j++) {
1125 if (polygon.components[j].containsPoint(point.feature.geometry)) {
1126 return true;
1127 }
1128 }
1129 }
1130 return false;
1131 },
1132
1133 mapSelection : function() {
1134 var selectedObjects = [];
1135 for (var i = 0; i < this.mds.size(); i++) {
1136 selectedObjects.push([]);
1137 }
1138 var circles = this.mds.getObjectsByZoom();
1139 for (var i = 0; i < circles.length; i++) {
1140
1141 for (var j = 0; j < circles[i].length; j++) {
1142 var c = circles[i][j];
1143 if (c.selected) {
1144 selectedObjects[i] = selectedObjects[i].concat(c.elements);
1145 }
1146 }
1147 }
1148 this.selection = new Selection(selectedObjects, this);
1149 this.highlightChanged(selectedObjects);
1150 this.core.triggerSelection(this.selection);
1151 this.filterBar.reset(true);
1152 },
1153
1154 deselection : function() {
1155 this.reset();
1156 this.selection = new Selection();
1157 this.highlightChanged([]);
1158 this.core.triggerSelection(this.selection);
1159 },
1160
1161 filtering : function() {
1162 for (var i = 0; i < this.datasets.length; i++) {
1163 this.datasets[i].objects = this.selection.objects[i];
1164 }
1165 this.core.triggerRefining(this.datasets);
1166 },
1167
1168 inverseFiltering : function() {
1169 var selectedObjects = [];
1170 for (var i = 0; i < this.mds.size(); i++) {
1171 selectedObjects.push([]);
1172 }
1173 var circles = this.mds.getObjectsByZoom();
1174 for (var i = 0; i < circles.length; i++) {
1175 for (var j = 0; j < circles[i].length; j++) {
1176 var c = circles[i][j];
1177 if (!c.selected) {
1178 selectedObjects[i] = selectedObjects[i].concat(c.elements);
1179 }
1180 }
1181 }
1182 this.selection = new Selection(selectedObjects, this);
1183 this.filtering();
1184 },
1185
1186 mapCircleHighlight : function(circle, undo) {
1187 if (this.polygons.length > 0 && this.inPolygon(circle)) {
1188 return;
1189 }
1190 var mapObjects = [];
1191 for (var i = 0; i < this.mds.size(); i++) {
1192 mapObjects.push([]);
1193 }
1194 if (!undo && !circle.selected) {
1195 mapObjects[circle.search] = circle.elements;
1196 }
1197 this.objectLayer.drawFeature(circle.feature);
1198 this.core.triggerHighlight(mapObjects);
1199 },
1200
1201 mapLabelSelection : function(label) {
1202 var selectedObjects = [];
1203 for (var i = 0; i < this.mds.size(); i++) {
1204 selectedObjects.push([]);
1205 }
1206 selectedObjects[label.index] = label.elements;
1207 this.selection = new Selection(selectedObjects, this);
1208 this.highlightChanged(selectedObjects);
1209 this.core.triggerSelection(this.selection);
1210 this.filterBar.reset(true);
1211 },
1212
1213 triggerMapChanged : function(mapName) {
1214 Publisher.Publish('mapChanged', mapName, this);
1215 },
1216
1217 /**
1218 * displays connections between data objects
1219 */
1220 displayConnections : function() {
1221 return;
1222 if ( typeof this.connection != 'undefined') {
1223 this.objectLayer.removeFeatures(this.connections);
1224 this.connections = [];
1225 }
1226 if (this.options.connections) {
1227 var points = this.mds.getObjectsByZoom();
1228 for (var i in points ) {
1229 for (var j in points[i] ) {
1230
1231 }
1232 }
1233
1234 var slices = this.core.timeplot.getSlices();
1235 for (var i = 0; i < slices.length; i++) {
1236 for (var j = 0; j < slices[i].stacks.length; j++) {
1237 var e = slices[i].stacks[j].elements;
1238 if (e.length == 0) {
1239 continue;
1240 }
1241 var points = [];
1242 for (var k = 0; k < e.length; k++) {
1243 var point = this.mds.getCircle(j, e[k].index).feature.geometry;
1244 if (arrayIndex(points, point) == -1) {
1245 points.push(point);
1246 }
1247 }
1248 var matrix = new AdjMatrix(points.length);
1249 for (var k = 0; k < points.length - 1; k++) {
1250 for (var l = k + 1; l < points.length; l++) {
1251 matrix.setEdge(k, l, dist(points[k], points[l]));
1252 }
1253 }
1254 var tree = Prim(matrix);
1255 var lines = [];
1256 for (var z = 0; z < tree.length; z++) {
1257 lines.push(new OpenLayers.Geometry.LineString(new Array(points[tree[z].v1], points[tree[z].v2])));
1258 }
1259 this.connections[j].push({
1260 first : this.mds.getCircle(j, e[0].index).feature.geometry,
1261 last : this.mds.getCircle(j, e[e.length - 1].index).feature.geometry,
1262 lines : lines,
1263 time : slices[i].date
1264 });
1265 }
1266 }
1267 var ltm = this.core.timeplot.leftFlagTime;
1268 var rtm = this.core.timeplot.rightFlagTime;
1269 if (ltm == undefined || ltm == null) {
1270 return;
1271 } else {
1272 ltm = ltm.getTime();
1273 rtm = rtm.getTime();
1274 }
1275 // this.connectionLayer.destroyFeatures();
1276 if (thisConnections) {
1277 for (var i = 0; i < this.connections.length; i++) {
1278 var c = GeoTemConfig.colors[i];
1279 var style = {
1280 strokeColor : 'rgb(' + c.r1 + ',' + c.g1 + ',' + c.b1 + ')',
1281 strokeOpacity : 0.5,
1282 strokeWidth : 3
1283 };
1284 var pointsToConnect = [];
1285 var last = undefined;
1286 for (var j = 0; j < this.connections[i].length; j++) {
1287 var c = this.connections[i][j];
1288 var ct = c.time.getTime();
1289 if (ct >= ltm && ct <= rtm) {
1290 if (last != undefined) {
1291 var line = new OpenLayers.Geometry.LineString(new Array(last, c.first));
1292 this.connectionLayer.addFeatures([new OpenLayers.Feature.Vector(line, null, style)]);
1293 }
1294 for (var k = 0; k < c.lines.length; k++) {
1295 this.connectionLayer.addFeatures([new OpenLayers.Feature.Vector(c.lines[k], null, style)]);
1296 }
1297 last = c.last;
1298 }
1299 }
1300 }
1301 // this.connectionLayer.redraw();
1302 }
1303 }
1304 },
1305
1306 /**
1307 * performs a zoom on the map
1308 * @param {int} delta the change of zoom levels
1309 */
1310 zoom : function(delta) {
1311 var zoom = this.getZoom() + delta;
1312 if (this.openlayersMap.baseLayer instanceof OpenLayers.Layer.WMS) {
1313 this.openlayersMap.zoomTo(zoom);
1314 } else {
1315 this.openlayersMap.zoomTo(Math.round(zoom));
1316 if (this.zoomSlider) {
1317 this.zoomSlider.setValue(this.getZoom());
1318 }
1319 }
1320 return true;
1321 },
1322
1323 deactivateCountrySelector : function() {
1324 this.openlayersMap.removeControl(this.selectCountry);
1325 this.selectCountry = undefined;
1326 },
1327
1328 activateCountrySelector : function(layer) {
1329 var map = this;
1330 if (this.options.countrySelect && this.options.mapSelectionTools) {
1331 this.selectCountry = new OpenLayers.Control.GetFeature({
1332 protocol : OpenLayers.Protocol.WFS.fromWMSLayer(layer),
1333 click : true
1334 });
1335 this.selectCountry.events.register("featureselected", this, function(e) {
1336 map.snapper();
1337 map.drawnPolygonHandler(e.feature.geometry);
1338 });
1339 this.openlayersMap.addControl(this.selectCountry);
1340 this.countrySelectionControl.enable();
1341 }
1342 },
1343
1344 setMap : function(index) {
1345 this.baselayerIndex = index;
1346 if (this.selectCountry) {
1347 // if( this.wmsOverlays.length == 0 ){
1348 this.deactivateCountrySelector();
1349 // }
1350 }
1351 if (this.baseLayers[index] instanceof OpenLayers.Layer.WMS) {
1352 // if( this.wmsOverlays.length == 0 ){
1353 this.activateCountrySelector(this.baseLayers[index]);
1354 // }
1355 } else {
1356 if (this.countrySelectionControl) {
1357 this.countrySelectionControl.disable();
1358 }
1359 }
1360 this.openlayersMap.zoomTo(Math.floor(this.getZoom()));
1361 this.openlayersMap.setBaseLayer(this.baseLayers[index]);
1362 if (this.baseLayers[index].name == 'Open Street Map') {
1363 this.gui.osmLink.style.visibility = 'visible';
1364 } else {
1365 this.gui.osmLink.style.visibility = 'hidden';
1366 }
1367 if (this.baseLayers[index].name == 'Open Street Map (MapQuest)') {
1368 this.gui.osmMapQuestLink.style.visibility = 'visible';
1369 } else {
1370 this.gui.osmMapQuestLink.style.visibility = 'hidden';
1371 }
1372 this.triggerMapChanged(this.baseLayers[index].name);
1373 },
1374
1375 //vhz added title to buttons
1376 initSelectorTools : function() {
1377 var map = this;
1378 this.mapControls = [];
1379
1380 if (this.options.squareSelect) {
1381 var button = document.createElement("div");
1382 $(button).addClass('mapControl');
1383 var activate = function() {
1384 map.drawSquare.activate();
1385 }
1386 var deactivate = function() {
1387 map.drawSquare.deactivate();
1388 }
1389 this.mapControls.push(new MapControl(this, button, 'square', activate, deactivate));
1390 }
1391 if (this.options.circleSelect) {
1392 var button = document.createElement("div");
1393 $(button).addClass('mapControl');
1394 var activate = function() {
1395 map.drawCircle.activate();
1396 }
1397 var deactivate = function() {
1398 map.drawCircle.deactivate();
1399 }
1400 this.mapControls.push(new MapControl(this, button, 'circle', activate, deactivate));
1401 }
1402 if (this.options.polygonSelect) {
1403 var button = document.createElement("div");
1404 $(button).addClass('mapControl');
1405 var activate = function() {
1406 map.drawPolygon.activate();
1407 }
1408 var deactivate = function() {
1409 map.drawPolygon.deactivate();
1410 }
1411 this.mapControls.push(new MapControl(this, button, 'polygon', activate, deactivate));
1412 }
1413 if (this.options.countrySelect) {
1414 var button = document.createElement("div");
1415 $(button).addClass('mapControl');
1416 var activate = function() {
1417 map.selectCountry.activate();
1418 map.dragControl.disable();
1419 }
1420 var deactivate = function() {
1421 map.selectCountry.deactivate();
1422 map.dragControl.enable();
1423 }
1424 this.countrySelectionControl = new MapControl(this, button, 'country', activate, deactivate);
1425 this.mapControls.push(this.countrySelectionControl);
1426 /*
1427 if( !(this.openlayersMap.baseLayer instanceof OpenLayers.Layer.WMS) ){
1428 this.countrySelectionControl.disable();
1429 }
1430 */
1431 }
1432 return this.mapControls;
1433 },
1434
1435 getZoom : function() {
1436 //calculate zoom from active resolution
1437 var resolution = this.openlayersMap.getResolution();
1438 var zoom = this.resolutions.indexOf(resolution);
1439 if (zoom == -1){
1440 //fractional zoom
1441 for (zoom = 0; zoom < this.resolutions.length; zoom++){
1442 if (resolution>=this.resolutions[zoom]){
1443 break;
1444 }
1445 }
1446 if (zoom == this.resolutions.length){
1447 zoom--;
1448 }
1449 }
1450 return(zoom);
1451 },
1452
1453 setMarker : function(lon, lat) {
1454 var p = new OpenLayers.Geometry.Point(lon, lat, null);
1455 p.transform(this.openlayersMap.displayProjection, this.openlayersMap.projection);
1456 this.openlayersMap.setCenter(new OpenLayers.LonLat(p.x, p.y));
1457 var size = new OpenLayers.Size(22, 33);
1458 var offset = new OpenLayers.Pixel(-(size.w / 2), -size.h);
1459 var icon = new OpenLayers.Icon(GeoTemConfig.path + 'marker.png', size, offset);
1460 var marker = new OpenLayers.Marker(new OpenLayers.LonLat(p.x, p.y), icon);
1461 marker.setOpacity(0.9);
1462 this.markerLayer.setZIndex(parseInt(this.objectLayer.getZIndex()) + 1);
1463 this.markerLayer.addMarker(marker);
1464 // find nearest neighbor
1465 var nearestNeighbor;
1466 var points = this.mds.getAllObjects();
1467 if (points == null) {
1468 return;
1469 }
1470 var dist = function(p1, p2) {
1471 return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
1472 }
1473 var zoomLevels = this.openlayersMap.getNumZoomLevels();
1474 var pointSet = points[zoomLevels - 1];
1475 var closestDistance = undefined;
1476 var closestPoint;
1477 for (var i = 0; i < pointSet.length; i++) {
1478 for (var j = 0; j < pointSet[i].length; j++) {
1479 var point = pointSet[i][j].feature.geometry;
1480 var d = dist(point, p);
1481 if (!closestDistance || d < closestDistance) {
1482 closestDistance = d;
1483 closestPoint = point;
1484 }
1485 }
1486 }
1487 // find minimal zoom level
1488 var gap = 0;
1489 var x_s = this.gui.mapWindow.offsetWidth / 2 - gap;
1490 var y_s = this.gui.mapWindow.offsetHeight / 2 - gap;
1491 if (typeof closestPoint !== "undefined"){
1492 var xDist = Math.abs(p.x - closestPoint.x);
1493 var yDist = Math.abs(p.y - closestPoint.y);
1494 for (var i = 0; i < zoomLevels; i++) {
1495 var resolution = this.openlayersMap.getResolutionForZoom(zoomLevels - i - 1);
1496 if (xDist / resolution < x_s && yDist / resolution < y_s) {
1497 this.openlayersMap.zoomTo(zoomLevels - i - 1);
1498 if (this.zoomSlider) {
1499 this.zoomSlider.setValue(this.getZoom());
1500 }
1501 this.drawObjectLayer(false);
1502 break;
1503 }
1504 }
1505 } else {
1506 //if there are no points on the map, zoom to max
1507 this.openlayersMap.zoomTo(0);
1508 if (this.zoomSlider) {
1509 this.zoomSlider.setValue(this.getZoom());
1510 }
1511 this.drawObjectLayer(false);
1512 }
1513 },
1514
1515 removeMarker : function() {
1516 this.markerLayer.removeMarker(this.markerLayer.markers[0]);
1517 },
1518
1519 getLevelOfDetail : function() {
1520 var zoom = Math.floor(this.getZoom());
1521 if (zoom <= 1) {
1522 return 0;
1523 } else if (zoom <= 3) {
1524 return 1;
1525 } else if (zoom <= 8) {
1526 return 2;
1527 } else {
1528 return 3;
1529 }
1530 }
1531 }