openlayers madness
This commit is contained in:
Steve Coast
parent
b95e9d2759
commit
b2b6892a45
54 changed files with 8021 additions and 10 deletions
|
|
@ -5,6 +5,36 @@
|
|||
</form>
|
||||
</div>
|
||||
|
||||
<div id="map" style="WIDTH: 700px; HEIGHT: 500px;"></div>
|
||||
|
||||
<script src="lib/OpenLayers.js"></script>
|
||||
<script type="text/javascript">
|
||||
<!--
|
||||
function init(){
|
||||
var map = new OpenLayers.Map('map');
|
||||
|
||||
var osm_wms = new OpenLayers.Layer.WMS( "OpenStreetMap Streets",
|
||||
"http://tile.openstreetmap.org/cgi-bin/mapserv?map=/usr/lib/cgi-bin/steve/osm.map",
|
||||
{layers: "default_segment,segments,class_segment",
|
||||
transparent: "true", format: "image/png" });
|
||||
|
||||
// FIXME this should be landsat.openstreetmap.org
|
||||
|
||||
var jpl_wms = new OpenLayers.Layer.WMS( "NASA Global Mosaic",
|
||||
"http://wms.jpl.nasa.gov/wms.cgi",
|
||||
{layers: "modis,global_mosaic"});
|
||||
|
||||
|
||||
map.addLayers([jpl_wms, osm_wms]);
|
||||
map.zoomToFullExtent();
|
||||
}
|
||||
|
||||
init();
|
||||
// -->
|
||||
</script>
|
||||
|
||||
|
||||
<!--
|
||||
<div id="drag" style="WIDTH: 700px; HEIGHT: 500px;">
|
||||
<div id='controls'>
|
||||
<a id="zoomout" class="mapcontrol"><img src="/images/map_zoomout.png" alt="zoom out"></a>
|
||||
|
|
@ -13,7 +43,7 @@
|
|||
</div>
|
||||
|
||||
<div id="debuginfo"></div>
|
||||
|
||||
-->
|
||||
<% unless @user %>
|
||||
<div id="gads">
|
||||
<script type="text/javascript"><!--
|
||||
|
|
@ -30,15 +60,17 @@
|
|||
google_color_text = "000000";
|
||||
//--></script><script type="text/javascript"
|
||||
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
|
||||
</script>We're trialing adverts to support the project. Login and they go away.
|
||||
</div>
|
||||
<% end %>
|
||||
</script>We're trialing adverts to support the project. Login and they go away.
|
||||
</div>
|
||||
<% end %>
|
||||
|
||||
<!--
|
||||
<script type="text/javascript">
|
||||
lat = 0;
|
||||
lon = 0;
|
||||
zoom = 0;
|
||||
|
||||
<script type="text/javascript">
|
||||
lat = 0;
|
||||
lon = 0;
|
||||
zoom = 0;
|
||||
init();
|
||||
</script>
|
||||
|
||||
init();
|
||||
</script>
|
||||
-->
|
||||
|
|
|
|||
BIN
public/img/drag-rectangle-off.png
Normal file
BIN
public/img/drag-rectangle-off.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.8 KiB |
BIN
public/img/drag-rectangle-on.png
Normal file
BIN
public/img/drag-rectangle-on.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.8 KiB |
BIN
public/img/east-mini.png
Normal file
BIN
public/img/east-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 451 B |
BIN
public/img/marker.png
Normal file
BIN
public/img/marker.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 606 B |
BIN
public/img/measuring-stick-off.png
Normal file
BIN
public/img/measuring-stick-off.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.3 KiB |
BIN
public/img/measuring-stick-on.png
Normal file
BIN
public/img/measuring-stick-on.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.7 KiB |
BIN
public/img/north-mini.png
Normal file
BIN
public/img/north-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 484 B |
BIN
public/img/panning-hand-off.png
Normal file
BIN
public/img/panning-hand-off.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.8 KiB |
BIN
public/img/panning-hand-on.png
Normal file
BIN
public/img/panning-hand-on.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.9 KiB |
BIN
public/img/slider.png
Normal file
BIN
public/img/slider.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 285 B |
BIN
public/img/south-mini.png
Normal file
BIN
public/img/south-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 481 B |
BIN
public/img/west-mini.png
Normal file
BIN
public/img/west-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 453 B |
BIN
public/img/zoom-minus-mini.png
Normal file
BIN
public/img/zoom-minus-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 359 B |
BIN
public/img/zoom-plus-mini.png
Normal file
BIN
public/img/zoom-plus-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 489 B |
BIN
public/img/zoom-world-mini.png
Normal file
BIN
public/img/zoom-world-mini.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1 KiB |
BIN
public/img/zoombar.png
Normal file
BIN
public/img/zoombar.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 463 B |
104
public/lib/OpenLayers.js
Normal file
104
public/lib/OpenLayers.js
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
////
|
||||
/// This blob sucks in all the files in uncompressed form for ease of use
|
||||
///
|
||||
|
||||
OpenLayers = new Object();
|
||||
|
||||
OpenLayers._scriptName = (
|
||||
typeof(_OPENLAYERS_SFL_) == "undefined" ? "lib/OpenLayers.js"
|
||||
: "OpenLayers.js" );
|
||||
|
||||
OpenLayers._getScriptLocation = function () {
|
||||
var scriptLocation = "";
|
||||
var SCRIPT_NAME = OpenLayers._scriptName;
|
||||
|
||||
var scripts = document.getElementsByTagName('script');
|
||||
for (var i = 0; i < scripts.length; i++) {
|
||||
var src = scripts[i].getAttribute('src');
|
||||
if (src) {
|
||||
var index = src.lastIndexOf(SCRIPT_NAME);
|
||||
// is it found, at the end of the URL?
|
||||
if ((index > -1) && (index + SCRIPT_NAME.length == src.length)) {
|
||||
scriptLocation = src.slice(0, -SCRIPT_NAME.length);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return scriptLocation;
|
||||
}
|
||||
|
||||
/*
|
||||
`_OPENLAYERS_SFL_` is a flag indicating this file is being included
|
||||
in a Single File Library build of the OpenLayers Library.
|
||||
|
||||
When we are *not* part of a SFL build we dynamically include the
|
||||
OpenLayers library code.
|
||||
|
||||
When we *are* part of a SFL build we do not dynamically include the
|
||||
OpenLayers library code as it will be appended at the end of this file.
|
||||
*/
|
||||
if (typeof(_OPENLAYERS_SFL_) == "undefined") {
|
||||
/*
|
||||
The original code appeared to use a try/catch block
|
||||
to avoid polluting the global namespace,
|
||||
we now use a anonymous function to achieve the same result.
|
||||
*/
|
||||
(function() {
|
||||
var jsfiles=new Array(
|
||||
"Prototype.js",
|
||||
"Rico/Corner.js",
|
||||
"Rico/Color.js",
|
||||
"OpenLayers/Util.js",
|
||||
"OpenLayers/Ajax.js",
|
||||
"OpenLayers/Events.js",
|
||||
"OpenLayers/Map.js",
|
||||
"OpenLayers/Layer.js",
|
||||
"OpenLayers/Icon.js",
|
||||
"OpenLayers/Marker.js",
|
||||
"OpenLayers/Popup.js",
|
||||
"OpenLayers/Tile.js",
|
||||
"OpenLayers/Feature.js",
|
||||
"OpenLayers/Feature/WFS.js",
|
||||
"OpenLayers/Tile/Image.js",
|
||||
"OpenLayers/Tile/WFS.js",
|
||||
// "OpenLayers/Layer/Google.js",
|
||||
// "OpenLayers/Layer/VirtualEarth.js",
|
||||
// "OpenLayers/Layer/Yahoo.js",
|
||||
"OpenLayers/Layer/Grid.js",
|
||||
"OpenLayers/Layer/KaMap.js",
|
||||
"OpenLayers/Layer/Markers.js",
|
||||
"OpenLayers/Layer/Text.js",
|
||||
"OpenLayers/Layer/WMS.js",
|
||||
"OpenLayers/Layer/WFS.js",
|
||||
"OpenLayers/Layer/WMS/Untiled.js",
|
||||
"OpenLayers/Popup/Anchored.js",
|
||||
"OpenLayers/Popup/AnchoredBubble.js",
|
||||
"OpenLayers/Control.js",
|
||||
"OpenLayers/Control/MouseDefaults.js",
|
||||
"OpenLayers/Control/MouseToolbar.js",
|
||||
"OpenLayers/Control/KeyboardDefaults.js",
|
||||
"OpenLayers/Control/PanZoom.js",
|
||||
"OpenLayers/Control/PanZoomBar.js",
|
||||
"OpenLayers/Control/LayerSwitcher.js"
|
||||
); // etc.
|
||||
|
||||
var allScriptTags = "";
|
||||
var host = OpenLayers._getScriptLocation() + "lib/";
|
||||
|
||||
// check to see if prototype.js was already loaded
|
||||
// if so, skip the first dynamic include
|
||||
//
|
||||
var start=1;
|
||||
try { x = Prototype; }
|
||||
catch (e) { start=0; }
|
||||
|
||||
for (var i = start; i < jsfiles.length; i++) {
|
||||
var currentScriptTag = "<script src='" + host + jsfiles[i] + "'></script>";
|
||||
allScriptTags += currentScriptTag;
|
||||
}
|
||||
document.write(allScriptTags);
|
||||
})();
|
||||
}
|
||||
113
public/lib/OpenLayers/Ajax.js
Normal file
113
public/lib/OpenLayers/Ajax.js
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
|
||||
OpenLayers.ProxyHost = "/proxy/?url=";
|
||||
//OpenLayers.ProxyHost = "examples/proxy.cgi?url=";
|
||||
|
||||
/**
|
||||
* Ajax reader for OpenLayers
|
||||
*
|
||||
*@uri url to do remote XML http get
|
||||
*@param 'get' format params (x=y&a=b...)
|
||||
*@who object to handle callbacks for this request
|
||||
*@complete the function to be called on success
|
||||
*@failure the function to be called on failure
|
||||
*
|
||||
* example usage from a caller:
|
||||
*
|
||||
* caps: function(request) {
|
||||
* -blah-
|
||||
* },
|
||||
*
|
||||
* OpenLayers.loadURL(url,params,this,caps);
|
||||
*
|
||||
* Notice the above example does not provide an error handler; a default empty
|
||||
* handler is provided which merely logs the error if a failure handler is not
|
||||
* supplied
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* @param {} request
|
||||
*/
|
||||
OpenLayers.nullHandler = function(request) {
|
||||
alert("Unhandled request return " + request.statusText);
|
||||
};
|
||||
|
||||
/** Background load a document
|
||||
*
|
||||
* @param {String} uri URI of source doc
|
||||
* @param {String} params Params on get (doesnt seem to work)
|
||||
* @param {Object} caller object which gets callbacks
|
||||
* @param {Function} onComplete callback for success
|
||||
* @param {Function} onFailure callback for failure
|
||||
*
|
||||
* Both callbacks optional (though silly)
|
||||
*/
|
||||
OpenLayers.loadURL = function(uri, params, caller,
|
||||
onComplete, onFailure) {
|
||||
|
||||
if (OpenLayers.ProxyHost && uri.startsWith("http")) {
|
||||
uri = OpenLayers.ProxyHost + escape(uri);
|
||||
|
||||
if (!params) {
|
||||
params="";
|
||||
}
|
||||
params += "&cachehack=" + new Date().getTime();
|
||||
}
|
||||
|
||||
var success = (onComplete) ? onComplete.bind(caller)
|
||||
: OpenLayers.nullHandler;
|
||||
|
||||
var failure = (onFailure) ? onFailure.bind(caller)
|
||||
: OpenLayers.nullHandler;
|
||||
|
||||
// from prototype.js
|
||||
new Ajax.Request(uri,
|
||||
{ method: 'get',
|
||||
parameters: params,
|
||||
onComplete: success,
|
||||
onFailure: failure
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
/** Parse XML into a doc structure
|
||||
* @param {String} text
|
||||
*
|
||||
* @returns Parsed Ajax Response ??
|
||||
* @type ?
|
||||
*/
|
||||
OpenLayers.parseXMLString = function(text) {
|
||||
|
||||
//MS sucks, if the server is bad it dies
|
||||
var index = text.indexOf('<');
|
||||
if (index > 0) {
|
||||
text = text.substring(index);
|
||||
}
|
||||
|
||||
var ajaxResponse = Try.these(
|
||||
function() {
|
||||
var xmldom = new ActiveXObject('Microsoft.XMLDOM');
|
||||
xmldom.loadXML(text);
|
||||
return xmldom;
|
||||
},
|
||||
function() {
|
||||
return new DOMParser().parseFromString(text, 'text/xml');
|
||||
},
|
||||
function() {
|
||||
var req = new XMLHttpRequest();
|
||||
req.open("GET", "data:" + "text/xml" +
|
||||
";charset=utf-8," + encodeURIComponent(text), false);
|
||||
if (req.overrideMimeType) {
|
||||
req.overrideMimeType("text/xml");
|
||||
}
|
||||
req.send(null);
|
||||
return req.responseXML;
|
||||
}
|
||||
);
|
||||
|
||||
return ajaxResponse;
|
||||
};
|
||||
63
public/lib/OpenLayers/Control.js
Normal file
63
public/lib/OpenLayers/Control.js
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Control = Class.create();
|
||||
OpenLayers.Control.prototype = {
|
||||
|
||||
/** this gets set in the addControl() function in OpenLayers.Map
|
||||
* @type OpenLayers.Map */
|
||||
map: null,
|
||||
|
||||
/** @type DOMElement */
|
||||
div: null,
|
||||
|
||||
/** @type OpenLayers.Pixel */
|
||||
position: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
initialize: function (options) {
|
||||
Object.extend(this, options);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns A reference to the DIV DOMElement containing the control
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function (px) {
|
||||
if (this.div == null) {
|
||||
this.div = OpenLayers.Util.createDiv();
|
||||
}
|
||||
if (px != null) {
|
||||
this.position = px.copyOf();
|
||||
}
|
||||
this.moveTo(this.position);
|
||||
return this.div;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
moveTo: function (px) {
|
||||
if ((px != null) && (this.div != null)) {
|
||||
this.div.style.left = px.x + "px";
|
||||
this.div.style.top = px.x + "px";
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
*/
|
||||
destroy: function () {
|
||||
// eliminate circular references
|
||||
this.map = null;
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Control"
|
||||
};
|
||||
65
public/lib/OpenLayers/Control/KeyboardDefaults.js
Normal file
65
public/lib/OpenLayers/Control/KeyboardDefaults.js
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Control.js
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Control.KeyboardDefaults = Class.create();
|
||||
OpenLayers.Control.KeyboardDefaults.prototype =
|
||||
Object.extend( new OpenLayers.Control(), {
|
||||
|
||||
/** @type int */
|
||||
slideFactor: 50,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
initialize: function() {
|
||||
OpenLayers.Control.prototype.initialize.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
draw: function() {
|
||||
Event.observe(document,
|
||||
'keypress',
|
||||
this.defaultKeyDown.bind(this));
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultKeyDown: function (evt) {
|
||||
|
||||
var slide = this.map.getResolution() * this.slideFactor;
|
||||
var center = this.map.getCenter();
|
||||
|
||||
var newCenter = center.copyOf();
|
||||
|
||||
switch(evt.keyCode) {
|
||||
case Event.KEY_LEFT:
|
||||
newCenter = newCenter.add( -slide, 0);
|
||||
break;
|
||||
case Event.KEY_RIGHT:
|
||||
newCenter = newCenter.add( slide, 0);
|
||||
break;
|
||||
case Event.KEY_UP:
|
||||
newCenter = newCenter.add( 0, slide);
|
||||
break;
|
||||
case Event.KEY_DOWN:
|
||||
newCenter = newCenter.add( 0, -slide);
|
||||
break;
|
||||
}
|
||||
|
||||
if (!newCenter.equals(center)) {
|
||||
this.map.setCenter(newCenter);
|
||||
Event.stop(evt);
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Control.KeyboardDefaults"
|
||||
});
|
||||
224
public/lib/OpenLayers/Control/LayerSwitcher.js
Normal file
224
public/lib/OpenLayers/Control/LayerSwitcher.js
Normal file
|
|
@ -0,0 +1,224 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Control.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Control.LayerSwitcher = Class.create();
|
||||
|
||||
/** color used in the UI to show a layer is active/displayed
|
||||
*
|
||||
* @final
|
||||
* @type String
|
||||
*/
|
||||
OpenLayers.Control.LayerSwitcher.ACTIVE_COLOR = "darkblue";
|
||||
|
||||
/** color used in the UI to show a layer is deactivated/hidden
|
||||
*
|
||||
* @final
|
||||
* @type String
|
||||
*/
|
||||
OpenLayers.Control.LayerSwitcher.NONACTIVE_COLOR = "lightblue";
|
||||
|
||||
|
||||
OpenLayers.Control.LayerSwitcher.prototype =
|
||||
Object.extend( new OpenLayers.Control(), {
|
||||
|
||||
/** @type String */
|
||||
activeColor: "",
|
||||
|
||||
/** @type String */
|
||||
nonActiveColor: "",
|
||||
|
||||
/** @type String */
|
||||
mode: "checkbox",
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
initialize: function(options) {
|
||||
this.activeColor = OpenLayers.Control.LayerSwitcher.ACTIVE_COLOR;
|
||||
this.nonActiveColor = OpenLayers.Control.LayerSwitcher.NONACTIVE_COLOR;
|
||||
this.backdrops = [];
|
||||
OpenLayers.Control.prototype.initialize.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns A reference to the DIV DOMElement containing the switcher tabs
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function() {
|
||||
// initialize our internal div
|
||||
OpenLayers.Control.prototype.draw.apply(this);
|
||||
|
||||
this.div.style.position = "absolute";
|
||||
this.div.style.top = "10px";
|
||||
this.div.style.right = "0px";
|
||||
this.div.style.left = "";
|
||||
this.div.style.fontFamily = "sans-serif";
|
||||
this.div.style.color = "white";
|
||||
this.div.style.fontWeight = "bold";
|
||||
this.div.style.marginTop = "3px";
|
||||
this.div.style.marginLeft = "3px";
|
||||
this.div.style.marginBottom = "3px";
|
||||
this.div.style.fontSize="smaller";
|
||||
this.div.style.width = "10em";
|
||||
|
||||
this.map.events.register("addlayer", this, this.redraw);
|
||||
this.map.events.register("removelayer", this, this.redraw);
|
||||
return this.redraw();
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns A reference to the DIV DOMElement containing the switcher tabs
|
||||
* @type DOMElement
|
||||
*/
|
||||
redraw: function() {
|
||||
|
||||
//clear out previous incarnation of LayerSwitcher tabs
|
||||
this.div.innerHTML = "";
|
||||
var visible = false;
|
||||
for( var i = 0; i < this.map.layers.length; i++) {
|
||||
if (visible && this.mode == "radio") {
|
||||
this.map.layers[i].setVisibility(false);
|
||||
} else {
|
||||
visible = this.map.layers[i].getVisibility();
|
||||
}
|
||||
this.addTab(this.map.layers[i]);
|
||||
}
|
||||
|
||||
return this.div;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {event} evt
|
||||
*/
|
||||
singleClick: function(evt) {
|
||||
var div = Event.element(evt);
|
||||
|
||||
// See comment about OL #57 fix below.
|
||||
// If the click occurred on the corner spans we need
|
||||
// to make sure we act on the actual label tab instead.
|
||||
div = div.labelElement || div;
|
||||
|
||||
var layer = div.layer;
|
||||
if (this.mode == "radio") {
|
||||
for(var i=0; i < this.backdrops.length; i++) {
|
||||
this.setTabActivation(this.backdrops[i], false);
|
||||
this.backdrops[i].layer.setVisibility(false);
|
||||
}
|
||||
this.setTabActivation(div, true);
|
||||
layer.setVisibility(true);
|
||||
} else {
|
||||
var visible = layer.getVisibility();
|
||||
|
||||
this.setTabActivation(div, !visible);
|
||||
layer.setVisibility(!visible);
|
||||
}
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {event} evt
|
||||
*/
|
||||
ignoreEvent: function(evt) {
|
||||
Event.stop(evt);
|
||||
return false;
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {OpenLayers.Layer} layer
|
||||
*/
|
||||
addTab: function(layer) {
|
||||
|
||||
// Outer DIV - for Rico Corners
|
||||
//
|
||||
var backdropLabelOuter = document.createElement('div');
|
||||
backdropLabelOuter.id = "LayerSwitcher_" + layer.name + "_Tab";
|
||||
backdropLabelOuter.style.marginTop = "4px";
|
||||
backdropLabelOuter.style.marginBottom = "4px";
|
||||
|
||||
this._setEventHandlers(backdropLabelOuter);
|
||||
|
||||
// Inner Label - for Rico Corners
|
||||
//
|
||||
var backdropLabel = document.createElement('p');
|
||||
backdropLabel.innerHTML = layer.name;
|
||||
backdropLabel.style.marginTop = "0px";
|
||||
backdropLabel.style.marginBottom = "0px";
|
||||
backdropLabel.style.paddingLeft = "10px";
|
||||
backdropLabel.style.paddingRight = "10px";
|
||||
|
||||
// add reference to layer onto the div for use in event handlers
|
||||
backdropLabel.layer = layer;
|
||||
|
||||
// set event handlers
|
||||
this._setEventHandlers(backdropLabel);
|
||||
|
||||
// add label to div
|
||||
backdropLabelOuter.appendChild(backdropLabel);
|
||||
|
||||
this.backdrops.append(backdropLabel);
|
||||
|
||||
// add div to main LayerSwitcher Div
|
||||
this.div.appendChild(backdropLabelOuter);
|
||||
|
||||
Rico.Corner.round(backdropLabelOuter, {corners: "tl bl",
|
||||
bgColor: "transparent",
|
||||
color: "white",
|
||||
blend: false});
|
||||
|
||||
// extend the event handlers to operate on the
|
||||
// rounded corners as well. (Fixes OL #57.)
|
||||
var spanElements=backdropLabel.parentNode.getElementsByTagName("span");
|
||||
|
||||
for (var currIdx = 0; currIdx < spanElements.length; currIdx++) {
|
||||
this._setEventHandlers(spanElements[currIdx], backdropLabel);
|
||||
}
|
||||
|
||||
this.setTabActivation(backdropLabel, layer.getVisibility());
|
||||
},
|
||||
|
||||
/*
|
||||
@private
|
||||
|
||||
@param {DOMElement} div
|
||||
@param {Boolean} activate
|
||||
*/
|
||||
_setEventHandlers : function(element, labelDiv) {
|
||||
|
||||
// We only want to respond to a mousedown event.
|
||||
element.onclick = this.singleClick.bindAsEventListener(this);
|
||||
element.ondblclick = this.singleClick.bindAsEventListener(this);
|
||||
element.onmouseup = this.ignoreEvent.bindAsEventListener(this);
|
||||
element.onmousedown = this.ignoreEvent.bindAsEventListener(this);
|
||||
|
||||
// If we are operating on a corner span we need to store a
|
||||
// reference to the actual tab. (See comment about OL #57 fix above.)
|
||||
if (labelDiv) {
|
||||
element.labelElement = labelDiv;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {DOMElement} div
|
||||
* @param {Boolean} activate
|
||||
*/
|
||||
setTabActivation:function(div, activate) {
|
||||
var color = (activate) ? this.activeColor : this.nonActiveColor;
|
||||
Rico.Corner.changeColor(div, color);
|
||||
},
|
||||
|
||||
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Control.LayerSwitcher"
|
||||
});
|
||||
|
||||
130
public/lib/OpenLayers/Control/MouseDefaults.js
Normal file
130
public/lib/OpenLayers/Control/MouseDefaults.js
Normal file
|
|
@ -0,0 +1,130 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Control.js
|
||||
OpenLayers.Control.MouseDefaults = Class.create();
|
||||
OpenLayers.Control.MouseDefaults.prototype =
|
||||
Object.extend( new OpenLayers.Control(), {
|
||||
|
||||
performedDrag: false,
|
||||
|
||||
initialize: function() {
|
||||
OpenLayers.Control.prototype.initialize.apply(this, arguments);
|
||||
},
|
||||
|
||||
draw: function() {
|
||||
this.map.events.register( "click", this, this.defaultClick );
|
||||
this.map.events.register( "dblclick", this, this.defaultDblClick );
|
||||
this.map.events.register( "mousedown", this, this.defaultMouseDown );
|
||||
this.map.events.register( "mouseup", this, this.defaultMouseUp );
|
||||
this.map.events.register( "mousemove", this, this.defaultMouseMove );
|
||||
this.map.events.register( "mouseout", this, this.defaultMouseOut );
|
||||
},
|
||||
|
||||
defaultClick: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
var notAfterDrag = !this.performedDrag;
|
||||
this.performedDrag = false;
|
||||
return notAfterDrag;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultDblClick: function (evt) {
|
||||
var newCenter = this.map.getLonLatFromViewPortPx( evt.xy );
|
||||
this.map.setCenter(newCenter, this.map.zoom + 1);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultMouseDown: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
this.mouseDragStart = evt.xy.copyOf();
|
||||
this.performedDrag = false;
|
||||
if (evt.shiftKey) {
|
||||
this.map.div.style.cursor = "crosshair";
|
||||
this.zoomBox = OpenLayers.Util.createDiv('zoomBox',
|
||||
this.mouseDragStart,
|
||||
null,
|
||||
null,
|
||||
"absolute",
|
||||
"2px solid red");
|
||||
this.zoomBox.style.backgroundColor = "white";
|
||||
this.zoomBox.style.filter = "alpha(opacity=50)"; // IE
|
||||
this.zoomBox.style.opacity = "0.50";
|
||||
this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1;
|
||||
this.map.viewPortDiv.appendChild(this.zoomBox);
|
||||
}
|
||||
document.onselectstart=function() { return false; }
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultMouseMove: function (evt) {
|
||||
if (this.mouseDragStart != null) {
|
||||
if (this.zoomBox) {
|
||||
var deltaX = Math.abs(this.mouseDragStart.x - evt.xy.x);
|
||||
var deltaY = Math.abs(this.mouseDragStart.y - evt.xy.y);
|
||||
this.zoomBox.style.width = deltaX+"px";
|
||||
this.zoomBox.style.height = deltaY+"px";
|
||||
if (evt.xy.x < this.mouseDragStart.x) {
|
||||
this.zoomBox.style.left = evt.xy.x+"px";
|
||||
}
|
||||
if (evt.xy.y < this.mouseDragStart.y) {
|
||||
this.zoomBox.style.top = evt.xy.y+"px";
|
||||
}
|
||||
} else {
|
||||
var deltaX = this.mouseDragStart.x - evt.xy.x;
|
||||
var deltaY = this.mouseDragStart.y - evt.xy.y;
|
||||
var size = this.map.getSize();
|
||||
var newXY = new OpenLayers.Pixel(size.w / 2 + deltaX,
|
||||
size.h / 2 + deltaY);
|
||||
var newCenter = this.map.getLonLatFromViewPortPx( newXY );
|
||||
this.map.setCenter(newCenter, null, true);
|
||||
this.mouseDragStart = evt.xy.copyOf();
|
||||
this.map.div.style.cursor = "move";
|
||||
}
|
||||
this.performedDrag = true;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultMouseUp: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
if (this.zoomBox) {
|
||||
var start = this.map.getLonLatFromViewPortPx( this.mouseDragStart );
|
||||
var end = this.map.getLonLatFromViewPortPx( evt.xy );
|
||||
var top = Math.max(start.lat, end.lat);
|
||||
var bottom = Math.min(start.lat, end.lat);
|
||||
var left = Math.min(start.lon, end.lon);
|
||||
var right = Math.max(start.lon, end.lon);
|
||||
var bounds = new OpenLayers.Bounds(left, bottom, right, top);
|
||||
var zoom = this.map.getZoomForExtent(bounds);
|
||||
this.map.setCenter(new OpenLayers.LonLat(
|
||||
(start.lon + end.lon) / 2,
|
||||
(start.lat + end.lat) / 2
|
||||
), zoom);
|
||||
this.map.viewPortDiv.removeChild(document.getElementById("zoomBox"));
|
||||
this.zoomBox = null;
|
||||
} else {
|
||||
this.map.setCenter(this.map.center);
|
||||
}
|
||||
document.onselectstart=null;
|
||||
this.mouseDragStart = null;
|
||||
this.map.div.style.cursor = "default";
|
||||
},
|
||||
|
||||
defaultMouseOut: function (evt) {
|
||||
if (this.mouseDragStart != null
|
||||
&& OpenLayers.Util.mouseLeft(evt, this.map.div)) {
|
||||
this.defaultMouseUp(evt);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
262
public/lib/OpenLayers/Control/MouseToolbar.js
Normal file
262
public/lib/OpenLayers/Control/MouseToolbar.js
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Control.js
|
||||
OpenLayers.Control.MouseToolbar = Class.create();
|
||||
OpenLayers.Control.MouseToolbar.X = 6;
|
||||
OpenLayers.Control.MouseToolbar.Y = 300;
|
||||
OpenLayers.Control.MouseToolbar.prototype =
|
||||
Object.extend( new OpenLayers.Control(), {
|
||||
|
||||
mode: null,
|
||||
|
||||
buttons: null,
|
||||
|
||||
direction: "vertical",
|
||||
|
||||
initialize: function(position, direction) {
|
||||
OpenLayers.Control.prototype.initialize.apply(this, arguments);
|
||||
this.position = new OpenLayers.Pixel(OpenLayers.Control.MouseToolbar.X,
|
||||
OpenLayers.Control.MouseToolbar.Y);
|
||||
if (position) {
|
||||
this.position = position;
|
||||
}
|
||||
if (direction) {
|
||||
this.direction = direction;
|
||||
}
|
||||
this.measureDivs = [];
|
||||
},
|
||||
|
||||
draw: function() {
|
||||
OpenLayers.Control.prototype.draw.apply(this, arguments);
|
||||
this.buttons = new Object();
|
||||
this.map.events.register( "dblclick", this, this.defaultDblClick );
|
||||
this.map.events.register( "mousedown", this, this.defaultMouseDown );
|
||||
this.map.events.register( "mouseup", this, this.defaultMouseUp );
|
||||
this.map.events.register( "mousemove", this, this.defaultMouseMove );
|
||||
this.map.events.register( "mouseout", this, this.defaultMouseOut );
|
||||
var sz = new OpenLayers.Size(28,28);
|
||||
var centered = this.position;
|
||||
this._addButton("zoombox", "drag-rectangle-off.png", "drag-rectangle-on.png", centered, sz, "Shift->Drag to zoom to area");
|
||||
centered = centered.add((this.direction == "vertical" ? 0 : sz.w), (this.direction == "vertical" ? sz.h : 0));
|
||||
this._addButton("pan", "panning-hand-off.png", "panning-hand-on.png", centered, sz, "Drag the map to pan.");
|
||||
centered = centered.add((this.direction == "vertical" ? 0 : sz.w), (this.direction == "vertical" ? sz.h : 0));
|
||||
this._addButton("measure", "measuring-stick-off.png", "measuring-stick-on.png", centered, sz, "Hold alt when clicking to show distance between selected points");
|
||||
this.switchModeTo("pan");
|
||||
this.map.events.register("zoomend", this, function() { this.switchModeTo("pan"); });
|
||||
return this.div;
|
||||
|
||||
},
|
||||
|
||||
_addButton:function(id, img, activeImg, xy, sz, title) {
|
||||
var imgLocation = OpenLayers.Util.getImagesLocation() + img;
|
||||
var activeImgLocation = OpenLayers.Util.getImagesLocation() + activeImg;
|
||||
// var btn = new ol.AlphaImage("_"+id, imgLocation, xy, sz);
|
||||
var btn = OpenLayers.Util.createAlphaImageDiv(
|
||||
"OpenLayers_Control_MouseToolbar_" + id,
|
||||
xy, sz, imgLocation, "absolute");
|
||||
|
||||
//we want to add the outer div
|
||||
this.div.appendChild(btn);
|
||||
btn.imgLocation = imgLocation;
|
||||
btn.activeImgLocation = activeImgLocation;
|
||||
|
||||
btn.events = new OpenLayers.Events(this, btn);
|
||||
btn.events.register("mousedown", this, this.buttonClick);
|
||||
btn.events.register("mouseup", this, Event.stop);
|
||||
btn.action = id;
|
||||
btn.title = title;
|
||||
btn.alt = title;
|
||||
btn.map = this.map;
|
||||
|
||||
//we want to remember/reference the outer div
|
||||
this.buttons[id] = btn;
|
||||
return btn;
|
||||
},
|
||||
|
||||
buttonClick: function(evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
this.switchModeTo(evt.div.action);
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultDblClick: function (evt) {
|
||||
this.switchModeTo("pan");
|
||||
var newCenter = this.map.getLonLatFromViewPortPx( evt.xy );
|
||||
this.map.setCenter(newCenter, this.map.zoom + 2);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultMouseDown: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
this.mouseDragStart = evt.xy.copyOf();
|
||||
if (evt.shiftKey && this.mode !="zoombox") {
|
||||
this.switchModeTo("zoombox");
|
||||
} else if (evt.altKey && this.mode !="measure") {
|
||||
this.switchModeTo("measure");
|
||||
} else if (!this.mode) {
|
||||
this.switchModeTo("pan");
|
||||
}
|
||||
|
||||
switch (this.mode) {
|
||||
case "zoombox":
|
||||
this.map.div.style.cursor = "crosshair";
|
||||
this.zoomBox = OpenLayers.Util.createDiv('zoomBox',
|
||||
this.mouseDragStart,
|
||||
null,
|
||||
null,
|
||||
"absolute",
|
||||
"2px solid red");
|
||||
this.zoomBox.style.backgroundColor = "white";
|
||||
this.zoomBox.style.filter = "alpha(opacity=50)"; // IE
|
||||
this.zoomBox.style.opacity = "0.50";
|
||||
this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1;
|
||||
this.map.viewPortDiv.appendChild(this.zoomBox);
|
||||
break;
|
||||
case "measure":
|
||||
var distance = "";
|
||||
if (this.measureStart) {
|
||||
measureEnd = this.map.getLonLatFromViewPortPx(this.mouseDragStart);
|
||||
distance = OpenLayers.Util.distVincenty(this.measureStart, measureEnd);
|
||||
distance = Math.round(distance * 100) / 100;
|
||||
distance = distance + "km";
|
||||
this.measureStartBox = this.measureBox;
|
||||
}
|
||||
this.measureStart = this.map.getLonLatFromViewPortPx(this.mouseDragStart);;
|
||||
this.measureBox = OpenLayers.Util.createDiv(null,
|
||||
this.mouseDragStart.add(
|
||||
-2-parseInt(this.map.layerContainerDiv.style.left),
|
||||
-2-parseInt(this.map.layerContainerDiv.style.top)),
|
||||
null,
|
||||
null,
|
||||
"absolute");
|
||||
this.measureBox.style.width="4px";
|
||||
this.measureBox.style.height="4px";
|
||||
this.measureBox.style.backgroundColor="red";
|
||||
this.measureBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1;
|
||||
this.map.layerContainerDiv.appendChild(this.measureBox);
|
||||
if (distance) {
|
||||
this.measureBoxDistance = OpenLayers.Util.createDiv(null,
|
||||
this.mouseDragStart.add(
|
||||
-2-parseInt(this.map.layerContainerDiv.style.left),
|
||||
2-parseInt(this.map.layerContainerDiv.style.top)),
|
||||
null,
|
||||
null,
|
||||
"absolute");
|
||||
|
||||
this.measureBoxDistance.innerHTML = distance;
|
||||
this.measureBoxDistance.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1;
|
||||
this.map.layerContainerDiv.appendChild(this.measureBoxDistance);
|
||||
this.measureDivs.append(this.measureBoxDistance);
|
||||
}
|
||||
this.measureBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1;
|
||||
this.map.layerContainerDiv.appendChild(this.measureBox);
|
||||
this.measureDivs.append(this.measureBox);
|
||||
break;
|
||||
default:
|
||||
this.map.div.style.cursor = "move";
|
||||
break;
|
||||
}
|
||||
document.onselectstart = function() { return false; }
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
switchModeTo: function(mode) {
|
||||
if (mode != this.mode) {
|
||||
if (this.mode) {
|
||||
OpenLayers.Util.modifyAlphaImageDiv(this.buttons[this.mode], null, null, null, this.buttons[this.mode].imgLocation);
|
||||
}
|
||||
if (this.mode == "measure" && mode != "measure") {
|
||||
for(var i = 0; i < this.measureDivs.length; i++) {
|
||||
if (this.measureDivs[i]) {
|
||||
this.map.layerContainerDiv.removeChild(this.measureDivs[i]);
|
||||
}
|
||||
}
|
||||
this.measureDivs = [];
|
||||
this.measureStart = null;
|
||||
}
|
||||
this.mode = mode;
|
||||
OpenLayers.Util.modifyAlphaImageDiv(this.buttons[mode], null, null, null, this.buttons[mode].activeImgLocation);
|
||||
}
|
||||
},
|
||||
|
||||
leaveMode: function() {
|
||||
this.switchModeTo("pan");
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultMouseMove: function (evt) {
|
||||
if (this.mouseDragStart != null) {
|
||||
switch (this.mode) {
|
||||
case "zoombox":
|
||||
var deltaX = Math.abs(this.mouseDragStart.x - evt.xy.x);
|
||||
var deltaY = Math.abs(this.mouseDragStart.y - evt.xy.y);
|
||||
this.zoomBox.style.width = deltaX+"px";
|
||||
this.zoomBox.style.height = deltaY+"px";
|
||||
if (evt.xy.x < this.mouseDragStart.x) {
|
||||
this.zoomBox.style.left = evt.xy.x+"px";
|
||||
}
|
||||
if (evt.xy.y < this.mouseDragStart.y) {
|
||||
this.zoomBox.style.top = evt.xy.y+"px";
|
||||
}
|
||||
break;
|
||||
default:
|
||||
var deltaX = this.mouseDragStart.x - evt.xy.x;
|
||||
var deltaY = this.mouseDragStart.y - evt.xy.y;
|
||||
var size = this.map.getSize();
|
||||
var newXY = new OpenLayers.Pixel(size.w / 2 + deltaX,
|
||||
size.h / 2 + deltaY);
|
||||
var newCenter = this.map.getLonLatFromViewPortPx( newXY );
|
||||
this.map.setCenter(newCenter, null, true);
|
||||
this.mouseDragStart = evt.xy.copyOf();
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
defaultMouseUp: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
switch (this.mode) {
|
||||
case "zoombox":
|
||||
var start = this.map.getLonLatFromViewPortPx( this.mouseDragStart );
|
||||
var end = this.map.getLonLatFromViewPortPx( evt.xy );
|
||||
var top = Math.max(start.lat, end.lat);
|
||||
var bottom = Math.min(start.lat, end.lat);
|
||||
var left = Math.min(start.lon, end.lon);
|
||||
var right = Math.max(start.lon, end.lon);
|
||||
var bounds = new OpenLayers.Bounds(left, bottom, right, top);
|
||||
var zoom = this.map.getZoomForExtent(bounds);
|
||||
this.map.setCenter(new OpenLayers.LonLat(
|
||||
(start.lon + end.lon) / 2,
|
||||
(start.lat + end.lat) / 2
|
||||
), zoom);
|
||||
this.map.viewPortDiv.removeChild(document.getElementById("zoomBox"));
|
||||
this.zoomBox = null;
|
||||
this.leaveMode();
|
||||
break;
|
||||
case "pan":
|
||||
this.map.setCenter(this.map.center);
|
||||
|
||||
}
|
||||
document.onselectstart = null;
|
||||
this.mouseDragStart = null;
|
||||
this.map.div.style.cursor = "default";
|
||||
},
|
||||
|
||||
defaultMouseOut: function (evt) {
|
||||
if (this.mouseDragStart != null
|
||||
&& OpenLayers.Util.mouseLeft(evt, this.map.div)) {
|
||||
this.defaultMouseUp(evt);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
164
public/lib/OpenLayers/Control/PanZoom.js
Normal file
164
public/lib/OpenLayers/Control/PanZoom.js
Normal file
|
|
@ -0,0 +1,164 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Control.js
|
||||
|
||||
/**
|
||||
* @class
|
||||
*
|
||||
* default zoom/pan controls
|
||||
*/
|
||||
OpenLayers.Control.PanZoom = Class.create();
|
||||
OpenLayers.Control.PanZoom.X = 4;
|
||||
OpenLayers.Control.PanZoom.Y = 4;
|
||||
OpenLayers.Control.PanZoom.prototype =
|
||||
Object.extend( new OpenLayers.Control(), {
|
||||
|
||||
/** @type int */
|
||||
slideFactor: 50,
|
||||
|
||||
/** @type Array of Button Divs */
|
||||
buttons: null,
|
||||
|
||||
/** @type OpenLayers.Pixel */
|
||||
position: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*/
|
||||
initialize: function() {
|
||||
OpenLayers.Control.prototype.initialize.apply(this, arguments);
|
||||
this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X,
|
||||
OpenLayers.Control.PanZoom.Y);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns A reference to the container div for the PanZoom control
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function(px) {
|
||||
// initialize our internal div
|
||||
OpenLayers.Control.prototype.draw.apply(this, arguments);
|
||||
px = this.position;
|
||||
|
||||
// place the controls
|
||||
this.buttons = new Array();
|
||||
|
||||
var sz = new OpenLayers.Size(18,18);
|
||||
var centered = new OpenLayers.Pixel(px.x+sz.w/2, px.y);
|
||||
|
||||
this._addButton("panup", "north-mini.png", centered, sz);
|
||||
px.y = centered.y+sz.h;
|
||||
this._addButton("panleft", "west-mini.png", px, sz);
|
||||
this._addButton("panright", "east-mini.png", px.add(sz.w, 0), sz);
|
||||
this._addButton("pandown", "south-mini.png",
|
||||
centered.add(0, sz.h*2), sz);
|
||||
this._addButton("zoomin", "zoom-plus-mini.png",
|
||||
centered.add(0, sz.h*3+5), sz);
|
||||
this._addButton("zoomworld", "zoom-world-mini.png",
|
||||
centered.add(0, sz.h*4+5), sz);
|
||||
this._addButton("zoomout", "zoom-minus-mini.png",
|
||||
centered.add(0, sz.h*5+5), sz);
|
||||
return this.div;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} id
|
||||
* @param {String} img
|
||||
* @param {OpenLayers.Pixel} xy
|
||||
* @param {OpenLayers.Size} sz
|
||||
*
|
||||
* @returns A Div (an alphaImageDiv, to be precise) that contains the
|
||||
* image of the button, and has all the proper event handlers
|
||||
* set.
|
||||
* @type DOMElement
|
||||
*/
|
||||
_addButton:function(id, img, xy, sz) {
|
||||
var imgLocation = OpenLayers.Util.getImagesLocation() + img;
|
||||
// var btn = new ol.AlphaImage("_"+id, imgLocation, xy, sz);
|
||||
var btn = OpenLayers.Util.createAlphaImageDiv(
|
||||
"OpenLayers_Control_PanZoom_" + id,
|
||||
xy, sz, imgLocation, "absolute");
|
||||
|
||||
//we want to add the outer div
|
||||
this.div.appendChild(btn);
|
||||
|
||||
btn.onmousedown = this.buttonDown.bindAsEventListener(btn);
|
||||
btn.ondblclick = this.doubleClick.bindAsEventListener(btn);
|
||||
btn.onclick = this.doubleClick.bindAsEventListener(btn);
|
||||
btn.action = id;
|
||||
btn.map = this.map;
|
||||
btn.slideFactor = this.slideFactor;
|
||||
|
||||
//we want to remember/reference the outer div
|
||||
this.buttons.push(btn);
|
||||
return btn;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {event} evt
|
||||
*
|
||||
* @type Boolean
|
||||
*/
|
||||
doubleClick: function (evt) {
|
||||
Event.stop(evt);
|
||||
return false;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {event} evt
|
||||
*/
|
||||
buttonDown: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
|
||||
var slide = this.map.getResolution() * this.slideFactor;
|
||||
var center = this.map.getCenter();
|
||||
|
||||
var newCenter = center.copyOf();
|
||||
|
||||
switch (this.action) {
|
||||
case "panup":
|
||||
newCenter = newCenter.add( 0, slide);
|
||||
break;
|
||||
case "pandown":
|
||||
newCenter = newCenter.add( 0, -slide);
|
||||
break;
|
||||
case "panleft":
|
||||
newCenter = newCenter.add( -slide, 0);
|
||||
break;
|
||||
case "panright":
|
||||
newCenter = newCenter.add( slide, 0);
|
||||
break;
|
||||
case "zoomin":
|
||||
this.map.zoomIn();
|
||||
break;
|
||||
case "zoomout":
|
||||
this.map.zoomOut();
|
||||
break;
|
||||
case "zoomworld":
|
||||
this.map.zoomToFullExtent();
|
||||
break;
|
||||
}
|
||||
|
||||
if (!newCenter.equals(center)) {
|
||||
this.map.setCenter(newCenter);
|
||||
}
|
||||
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
OpenLayers.Control.prototype.destroy.apply(this, arguments);
|
||||
for(i=0; i<this.buttons.length; i++) {
|
||||
this.buttons[i].map = null;
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Control.PanZoom"
|
||||
});
|
||||
202
public/lib/OpenLayers/Control/PanZoomBar.js
Normal file
202
public/lib/OpenLayers/Control/PanZoomBar.js
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Control/PanZoom.js
|
||||
|
||||
//
|
||||
// default zoom/pan controls
|
||||
//
|
||||
OpenLayers.Control.PanZoomBar = Class.create();
|
||||
OpenLayers.Control.PanZoomBar.X = 4;
|
||||
OpenLayers.Control.PanZoomBar.Y = 4;
|
||||
OpenLayers.Control.PanZoomBar.prototype =
|
||||
Object.extend( new OpenLayers.Control.PanZoom(), {
|
||||
/** @type Array(...) */
|
||||
buttons: null,
|
||||
|
||||
/** @type int */
|
||||
zoomStopWidth: 18,
|
||||
|
||||
/** @type int */
|
||||
zoomStopHeight: 11,
|
||||
|
||||
initialize: function() {
|
||||
OpenLayers.Control.PanZoom.prototype.initialize.apply(this, arguments);
|
||||
this.position = new OpenLayers.Pixel(OpenLayers.Control.PanZoomBar.X,
|
||||
OpenLayers.Control.PanZoomBar.Y);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
draw: function(px) {
|
||||
// initialize our internal div
|
||||
OpenLayers.Control.prototype.draw.apply(this, arguments);
|
||||
px = this.position;
|
||||
|
||||
// place the controls
|
||||
this.buttons = new Array();
|
||||
|
||||
var sz = new OpenLayers.Size(18,18);
|
||||
var centered = new OpenLayers.Pixel(px.x+sz.w/2, px.y);
|
||||
|
||||
this._addButton("panup", "north-mini.png", centered, sz);
|
||||
px.y = centered.y+sz.h;
|
||||
this._addButton("panleft", "west-mini.png", px, sz);
|
||||
this._addButton("panright", "east-mini.png", px.add(sz.w, 0), sz);
|
||||
this._addButton("pandown", "south-mini.png", centered.add(0, sz.h*2), sz);
|
||||
this._addButton("zoomin", "zoom-plus-mini.png", centered.add(0, sz.h*3+5), sz);
|
||||
centered = this._addZoomBar(centered.add(0, sz.h*4 + 5));
|
||||
this._addButton("zoomout", "zoom-minus-mini.png", centered, sz);
|
||||
return this.div;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} location where zoombar drawing is to start.
|
||||
*/
|
||||
_addZoomBar:function(centered) {
|
||||
var imgLocation = OpenLayers.Util.getImagesLocation();
|
||||
|
||||
var id = "OpenLayers_Control_PanZoomBar_Slider" + this.map.id;
|
||||
var slider = OpenLayers.Util.createAlphaImageDiv(id,
|
||||
centered.add(-1,
|
||||
(this.map.getZoomLevels())*this.zoomStopHeight),
|
||||
new OpenLayers.Size(20,9),
|
||||
imgLocation+"slider.png",
|
||||
"absolute");
|
||||
this.slider = slider;
|
||||
|
||||
this.sliderEvents = new OpenLayers.Events(this, slider);
|
||||
this.sliderEvents.register("mousedown", this, this.zoomBarDown);
|
||||
this.sliderEvents.register("mousemove", this, this.zoomBarDrag);
|
||||
this.sliderEvents.register("mouseup", this, this.zoomBarUp);
|
||||
this.sliderEvents.register("dblclick", this, this.doubleClick);
|
||||
this.sliderEvents.register("click", this, this.doubleClick);
|
||||
|
||||
sz = new OpenLayers.Size();
|
||||
sz.h = this.zoomStopHeight*(this.map.getZoomLevels()+1);
|
||||
sz.w = this.zoomStopWidth;
|
||||
var div = null
|
||||
|
||||
if (OpenLayers.Util.alphaHack()) {
|
||||
var id = "OpenLayers_Control_PanZoomBar" + this.map.id;
|
||||
div = OpenLayers.Util.createAlphaImageDiv(id, centered,
|
||||
new OpenLayers.Size(sz.w,
|
||||
this.zoomStopHeight),
|
||||
imgLocation + "zoombar.png",
|
||||
"absolute", null, "crop");
|
||||
div.style.height = sz.h;
|
||||
} else {
|
||||
div = OpenLayers.Util.createDiv(
|
||||
'OpenLayers_Control_PanZoomBar_Zoombar' + this.map.id,
|
||||
centered,
|
||||
sz,
|
||||
imgLocation+"zoombar.png");
|
||||
}
|
||||
|
||||
this.zoombarDiv = div;
|
||||
|
||||
this.divEvents = new OpenLayers.Events(this, div);
|
||||
this.divEvents.register("mousedown", this, this.divClick);
|
||||
this.divEvents.register("mousemove", this, this.passEventToSlider);
|
||||
this.divEvents.register("dblclick", this, this.doubleClick);
|
||||
this.divEvents.register("click", this, this.doubleClick);
|
||||
|
||||
this.div.appendChild(div);
|
||||
|
||||
this.startTop = parseInt(div.style.top);
|
||||
this.div.appendChild(slider);
|
||||
|
||||
this.map.events.register("zoomend", this, this.moveZoomBar);
|
||||
|
||||
centered = centered.add(0,
|
||||
this.zoomStopHeight*(this.map.getZoomLevels()+1));
|
||||
return centered;
|
||||
},
|
||||
/*
|
||||
* @param evt
|
||||
* This function is used to pass events that happen on the div, or the map,
|
||||
* through to the slider, which then does its moving thing.
|
||||
*/
|
||||
passEventToSlider:function(evt) {
|
||||
this.sliderEvents.handleBrowserEvent(evt);
|
||||
},
|
||||
|
||||
/*
|
||||
* divClick: Picks up on clicks directly on the zoombar div
|
||||
* and sets the zoom level appropriately.
|
||||
*/
|
||||
divClick: function (evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
var y = evt.xy.y;
|
||||
var top = Position.page(evt.object)[1];
|
||||
var levels = Math.floor((y - top)/this.zoomStopHeight);
|
||||
this.map.zoomTo(this.map.getZoomLevels() - levels);
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/*
|
||||
* @param evt
|
||||
* event listener for clicks on the slider
|
||||
*/
|
||||
zoomBarDown:function(evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
this.map.events.register("mousemove", this, this.passEventToSlider);
|
||||
this.map.events.register("mouseup", this, this.passEventToSlider);
|
||||
this.mouseDragStart = evt.xy.copyOf();
|
||||
this.zoomStart = evt.xy.copyOf();
|
||||
this.div.style.cursor = "move";
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/*
|
||||
* @param evt
|
||||
* This is what happens when a click has occurred, and the client is dragging.
|
||||
* Here we must ensure that the slider doesn't go beyond the bottom/top of the
|
||||
* zoombar div, as well as moving the slider to its new visual location
|
||||
*/
|
||||
zoomBarDrag:function(evt) {
|
||||
if (this.mouseDragStart != null) {
|
||||
var deltaY = this.mouseDragStart.y - evt.xy.y
|
||||
var offsets = Position.page(this.zoombarDiv);
|
||||
if ((evt.clientY - offsets[1]) > 0 &&
|
||||
(evt.clientY - offsets[1]) < parseInt(this.zoombarDiv.style.height) - 2) {
|
||||
var newTop = parseInt(this.slider.style.top) - deltaY;
|
||||
this.slider.style.top = newTop+"px";
|
||||
}
|
||||
this.mouseDragStart = evt.xy.copyOf();
|
||||
}
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/*
|
||||
* @param evt
|
||||
* Perform cleanup when a mouseup event is received -- discover new zoom level
|
||||
* and switch to it.
|
||||
*/
|
||||
zoomBarUp:function(evt) {
|
||||
if (!Event.isLeftClick(evt)) return;
|
||||
if (this.zoomStart) {
|
||||
this.div.style.cursor="default";
|
||||
this.map.events.remove("mousemove");
|
||||
this.map.events.remove("mouseup");
|
||||
var deltaY = this.zoomStart.y - evt.xy.y
|
||||
this.map.zoomTo(this.map.zoom + Math.round(deltaY/this.zoomStopHeight));
|
||||
this.moveZoomBar();
|
||||
this.mouseDragStart = null;
|
||||
Event.stop(evt);
|
||||
}
|
||||
},
|
||||
|
||||
/*
|
||||
* Change the location of the slider to match the current zoom level.
|
||||
*/
|
||||
moveZoomBar:function() {
|
||||
var newTop =
|
||||
(this.map.getZoomLevels() - this.map.getZoom()) * this.zoomStopHeight
|
||||
+ this.startTop + 1;
|
||||
this.slider.style.top = newTop + "px";
|
||||
},
|
||||
|
||||
CLASS_NAME: "OpenLayers.Control.PanZoomBar"
|
||||
});
|
||||
124
public/lib/OpenLayers/Events.js
Normal file
124
public/lib/OpenLayers/Events.js
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
OpenLayers.Events = Class.create();
|
||||
|
||||
OpenLayers.Events.prototype = {
|
||||
// Array: supported events
|
||||
BROWSER_EVENTS: [
|
||||
"mouseover", "mouseout",
|
||||
"mousedown", "mouseup", "mousemove",
|
||||
"click", "dblclick",
|
||||
"resize", "focus", "blur"
|
||||
],
|
||||
|
||||
// hash of Array(Function): events listener functions
|
||||
listeners: null,
|
||||
|
||||
// Object: the code object issuing application events
|
||||
object: null,
|
||||
|
||||
// DOMElement: the DOM element receiving browser events
|
||||
div: null,
|
||||
|
||||
// Array: list of support application events
|
||||
eventTypes: null,
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Map} map
|
||||
* @param {DOMElement} div
|
||||
*/
|
||||
initialize: function (object, div, eventTypes) {
|
||||
this.listeners = {};
|
||||
this.object = object;
|
||||
this.div = div;
|
||||
this.eventTypes = eventTypes;
|
||||
if (eventTypes) {
|
||||
for (var i = 0; i < this.eventTypes.length; i++) {
|
||||
// create a listener list for every custom application event
|
||||
this.listeners[ this.eventTypes[i] ] = [];
|
||||
}
|
||||
}
|
||||
for (var i = 0; i < this.BROWSER_EVENTS.length; i++) {
|
||||
var eventType = this.BROWSER_EVENTS[i];
|
||||
|
||||
// every browser event has a corresponding application event
|
||||
// (whether it's listened for or not).
|
||||
this.listeners[ eventType ] = [];
|
||||
|
||||
Event.observe(div, eventType,
|
||||
this.handleBrowserEvent.bindAsEventListener(this));
|
||||
}
|
||||
// disable dragstart in IE so that mousedown/move/up works normally
|
||||
Event.observe(div, "dragstart", Event.stop);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {str} type
|
||||
* @param {Object} obj
|
||||
* @param {Function} func
|
||||
*/
|
||||
register: function (type, obj, func) {
|
||||
if (func == null) {
|
||||
obj = this.object;
|
||||
func = obj;
|
||||
}
|
||||
var listeners = this.listeners[type];
|
||||
listeners.push( {obj: obj, func: func} );
|
||||
},
|
||||
|
||||
unregister: function (type, obj, func) {
|
||||
var listeners = this.listeners[type];
|
||||
for (var i = 0; i < listeners.length; i++) {
|
||||
if (listeners[i].obj == obj && listeners[i].type == type) {
|
||||
listeners.splice(i, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
remove: function(type) {
|
||||
this.listeners[type].pop();
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {event} evt
|
||||
*/
|
||||
handleBrowserEvent: function (evt) {
|
||||
evt.xy = this.getMousePosition(evt);
|
||||
this.triggerEvent(evt.type, evt)
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {event} evt
|
||||
*
|
||||
* @return {OpenLayers.Pixel}
|
||||
*/
|
||||
getMousePosition: function (evt) {
|
||||
if (!this.div.offsets) {
|
||||
this.div.offsets = Position.page(this.div);
|
||||
}
|
||||
return new OpenLayers.Pixel(
|
||||
evt.clientX - this.div.offsets[0],
|
||||
evt.clientY - this.div.offsets[1]);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {str} type
|
||||
* @param {event} evt
|
||||
*/
|
||||
triggerEvent: function (type, evt) {
|
||||
if (evt == null) {
|
||||
evt = {};
|
||||
}
|
||||
evt.object = this.object;
|
||||
evt.div = this.div;
|
||||
|
||||
var listeners = this.listeners[type];
|
||||
for (var i = 0; i < listeners.length; i++) {
|
||||
var callback = listeners[i];
|
||||
var continueChain = callback.func.call(callback.obj, evt);
|
||||
if (continueChain != null && !continueChain) break;
|
||||
}
|
||||
}
|
||||
};
|
||||
110
public/lib/OpenLayers/Feature.js
Normal file
110
public/lib/OpenLayers/Feature.js
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Feature = Class.create();
|
||||
OpenLayers.Feature.prototype= {
|
||||
|
||||
/** @type OpenLayers.Events */
|
||||
events:null,
|
||||
|
||||
/** @type OpenLayers.Layer */
|
||||
layer: null,
|
||||
|
||||
/** @type String */
|
||||
id: null,
|
||||
|
||||
/** @type OpenLayers.LonLat */
|
||||
lonlat:null,
|
||||
|
||||
/** @type Object */
|
||||
data:null,
|
||||
|
||||
/** @type OpenLayers.Marker */
|
||||
marker: null,
|
||||
|
||||
/** @type OpenLayers.Popup */
|
||||
popup: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {OpenLayers.Layer} layer
|
||||
* @param {String} id
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
* @param {Object} data
|
||||
*/
|
||||
initialize: function(layer, lonlat, data, id) {
|
||||
this.layer = layer;
|
||||
this.lonlat = lonlat;
|
||||
this.data = (data != null) ? data : new Object();
|
||||
this.id = (id ? id : 'f' + Math.random());
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
|
||||
//remove the popup from the map
|
||||
if ((this.layer != null) && (this.layer.map != null)) {
|
||||
if (this.popup != null) {
|
||||
this.layer.map.removePopup(this.popup);
|
||||
}
|
||||
}
|
||||
|
||||
this.events = null;
|
||||
this.layer = null;
|
||||
this.id = null;
|
||||
this.lonlat = null;
|
||||
this.data = null;
|
||||
if (this.marker != null) {
|
||||
this.marker.destroy();
|
||||
this.marker = null;
|
||||
}
|
||||
if (this.popup != null) {
|
||||
this.popup.destroy();
|
||||
this.popup = null;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* @returns A Marker Object created from the 'lonlat' and 'icon' properties
|
||||
* set in this.data. If no 'lonlat' is set, returns null. If no
|
||||
* 'icon' is set, OpenLayers.Marker() will load the default image
|
||||
* @type OpenLayers.Marker
|
||||
*/
|
||||
createMarker: function() {
|
||||
|
||||
var marker = null;
|
||||
|
||||
if (this.lonlat != null) {
|
||||
this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon);
|
||||
}
|
||||
return this.marker;
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
createPopup: function() {
|
||||
|
||||
if (this.lonlat != null) {
|
||||
|
||||
var id = this.id + "_popup";
|
||||
var anchor = (this.marker) ? this.marker.icon : null;
|
||||
|
||||
this.popup = new OpenLayers.Popup.AnchoredBubble(id,
|
||||
this.lonlat,
|
||||
this.data.popupSize,
|
||||
this.data.popupContentHTML,
|
||||
anchor);
|
||||
}
|
||||
return this.popup;
|
||||
},
|
||||
|
||||
CLASS_NAME: "OpenLayers.Feature"
|
||||
};
|
||||
64
public/lib/OpenLayers/Feature/WFS.js
Normal file
64
public/lib/OpenLayers/Feature/WFS.js
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Feature.WFS = Class.create();
|
||||
OpenLayers.Feature.WFS.prototype =
|
||||
Object.extend( new OpenLayers.Feature(), {
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {OpenLayers.Layer} layer
|
||||
* @param {XMLNode} xmlNode
|
||||
*/
|
||||
initialize: function(layer, xmlNode) {
|
||||
var newArguments = arguments;
|
||||
if (arguments.length > 0) {
|
||||
var data = this.processXMLNode(xmlNode);
|
||||
newArguments = new Array(layer, data.lonlat, data, data.id)
|
||||
}
|
||||
OpenLayers.Feature.prototype.initialize.apply(this, newArguments);
|
||||
|
||||
if (arguments.length > 0) {
|
||||
this.createMarker();
|
||||
this.layer.addMarker(this.marker);
|
||||
}
|
||||
},
|
||||
|
||||
destroy: function() {
|
||||
if (this.marker != null) {
|
||||
this.layer.removeMarker(this.marker);
|
||||
}
|
||||
OpenLayers.Feature.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {XMLNode} xmlNode
|
||||
*
|
||||
* @returns Data Object with 'id', 'lonlat', and private properties set
|
||||
* @type Object
|
||||
*/
|
||||
processXMLNode: function(xmlNode) {
|
||||
//this should be overridden by subclasses
|
||||
// must return an Object with 'id' and 'lonlat' values set
|
||||
var point = xmlNode.getElementsByTagName("Point");
|
||||
var text = point[0].textContent;
|
||||
var floats = text.split(",");
|
||||
|
||||
return {lonlat: new OpenLayers.LonLat(parseFloat(floats[0]),
|
||||
parseFloat(floats[1])),
|
||||
id: null};
|
||||
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Feature.WFS"
|
||||
});
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
106
public/lib/OpenLayers/Icon.js
Normal file
106
public/lib/OpenLayers/Icon.js
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Icon = Class.create();
|
||||
OpenLayers.Icon.prototype = {
|
||||
|
||||
/** image url
|
||||
* @type String */
|
||||
url: null,
|
||||
|
||||
/** @type OpenLayers.Size */
|
||||
size:null,
|
||||
|
||||
/** distance in pixels to offset the image when being rendered
|
||||
* @type OpenLayers.Pixel */
|
||||
offset: null,
|
||||
|
||||
/** Function to calculate the offset (based on the size)
|
||||
* @type OpenLayers.Pixel */
|
||||
calculateOffset: null,
|
||||
|
||||
/** @type DOMElement */
|
||||
imageDiv: null,
|
||||
|
||||
/** @type OpenLayers.Pixel */
|
||||
px: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} url
|
||||
* @param {OpenLayers.Size} size
|
||||
* @param {Function} calculateOffset
|
||||
*/
|
||||
initialize: function(url, size, offset, calculateOffset) {
|
||||
this.url = url;
|
||||
this.size = (size) ? size : new OpenLayers.Size(20,20);
|
||||
this.offset = (offset) ? offset : new OpenLayers.Pixel(0,0);
|
||||
this.calculateOffset = calculateOffset;
|
||||
|
||||
this.imageDiv = OpenLayers.Util.createAlphaImageDiv();
|
||||
},
|
||||
|
||||
destroy: function() {
|
||||
this.imageDiv = null;
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns A fresh copy of the icon.
|
||||
* @type OpenLayers.Icon
|
||||
*/
|
||||
clone: function() {
|
||||
return new OpenLayers.Icon(this.size, this.url, this.offset);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
setSize: function(size) {
|
||||
if (size != null) {
|
||||
this.size = size;
|
||||
}
|
||||
this.draw();
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @return A new DOM Image of this icon set at the location passed-in
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function(px) {
|
||||
OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv,
|
||||
null,
|
||||
null,
|
||||
this.size,
|
||||
this.url,
|
||||
"absolute");
|
||||
this.moveTo(px);
|
||||
return this.imageDiv;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
moveTo: function (px) {
|
||||
//if no px passed in, use stored location
|
||||
if (px != null) {
|
||||
this.px = px;
|
||||
}
|
||||
|
||||
if ((this.px != null) && (this.imageDiv != null)) {
|
||||
if (this.calculateOffset) {
|
||||
this.offset = this.calculateOffset(this.size);
|
||||
}
|
||||
var offsetPx = this.px.offset(this.offset);
|
||||
OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv, null, offsetPx);
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Icon"
|
||||
};
|
||||
92
public/lib/OpenLayers/Layer.js
Normal file
92
public/lib/OpenLayers/Layer.js
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer = Class.create();
|
||||
OpenLayers.Layer.prototype = {
|
||||
|
||||
/** @type String */
|
||||
name: null,
|
||||
|
||||
/** @type DOMElement */
|
||||
div: null,
|
||||
|
||||
/** This variable is set in map.addLayer, not within the layer itself
|
||||
* @type OpenLayers.Map */
|
||||
map: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} name
|
||||
*/
|
||||
initialize: function(name) {
|
||||
if (arguments.length > 0) {
|
||||
this.name = name;
|
||||
if (this.div == null) {
|
||||
this.div = OpenLayers.Util.createDiv();
|
||||
this.div.style.width = "100%";
|
||||
this.div.style.height = "100%";
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Destroy is a destructor: this is to alleviate cyclic references which
|
||||
* the Javascript garbage cleaner can not take care of on its own.
|
||||
*/
|
||||
destroy: function() {
|
||||
if (this.map != null) {
|
||||
this.map.removeLayer(this);
|
||||
}
|
||||
this.map = null;
|
||||
},
|
||||
|
||||
/**
|
||||
* @params {OpenLayers.Bounds} bound
|
||||
* @params {Boolean} zoomChanged tells when zoom has changed, as layers have to do some init work in that case.
|
||||
*/
|
||||
moveTo: function (bound, zoomChanged) {
|
||||
// not implemented here
|
||||
return;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Map} map
|
||||
*/
|
||||
setMap: function(map) {
|
||||
this.map = map;
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns Whether or not the layer is a base layer. This should be
|
||||
* determined individually by all subclasses.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
//this function should be implemented by all subclasses.
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns Whether or not the layer is visible
|
||||
* @type Boolean
|
||||
*/
|
||||
getVisibility: function() {
|
||||
return (this.div.style.display != "none");
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {bool} visible
|
||||
*/
|
||||
setVisibility: function(visible) {
|
||||
this.div.style.display = (visible) ? "block" : "none";
|
||||
if ((visible) && (this.map != null)) {
|
||||
this.moveTo(this.map.getExtent());
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer"
|
||||
};
|
||||
152
public/lib/OpenLayers/Layer/Google.js
Normal file
152
public/lib/OpenLayers/Layer/Google.js
Normal file
|
|
@ -0,0 +1,152 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer.js
|
||||
|
||||
// load Google map control script
|
||||
// this key was generated for: http://openlayers.python-hosting.com/testing/euzuro/
|
||||
document.write("<script src='http://maps.google.com/maps?file=api&v=2&key=ABQIAAAAmQ3udCHPQVB_9T_edFZ7YRRRlP-tOiFgaSzksg_0w1dphL9c5BTfdJMKT91b0UJGibNcWEM0Q5-O1w'></script>");
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.Google = Class.create();
|
||||
OpenLayers.Layer.Google.prototype = Object.extend( new OpenLayers.Layer(), {
|
||||
|
||||
/** @type Boolean */
|
||||
viewPortLayer: true,
|
||||
|
||||
/** @type GMap2 gmap stores the Google Map element */
|
||||
gmap:null,
|
||||
|
||||
/** @type Boolean */
|
||||
dragging:false,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} name
|
||||
*/
|
||||
initialize: function(name) {
|
||||
OpenLayers.Layer.prototype.initialize.apply(this, [name]);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Map} map
|
||||
*/
|
||||
setMap:function(map) {
|
||||
OpenLayers.Layer.prototype.setMap.apply(this, arguments);
|
||||
|
||||
// once our layer has been added to the map, we can create the vemap
|
||||
this.map.events.register("addlayer", this, this.loadGMap);
|
||||
},
|
||||
|
||||
/** Google layer is always a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return true;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {int} zoomChanged
|
||||
*/
|
||||
moveTo:function(bounds,zoomChanged) {
|
||||
|
||||
if ((this.gmap != null) && (!this.dragging)) {
|
||||
|
||||
var olCenter = this.map.getCenter();
|
||||
var gCenter = this.getGMapCenter();
|
||||
|
||||
var olZoom = this.map.getZoom();
|
||||
var gZoom = this.gmap.getZoom();
|
||||
|
||||
if ((!olCenter.equals(gCenter)) || ((olZoom +1) != gZoom)) {
|
||||
this.gmap.setCenter(new GLatLng(olCenter.lat, olCenter.lon),
|
||||
olZoom + 1);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
loadGMap:function() {
|
||||
// create div and set to same size as map
|
||||
var gDiv = OpenLayers.Util.createDiv(this.name);
|
||||
var sz = this.map.getSize();
|
||||
gDiv.style.width = sz.w;
|
||||
gDiv.style.height = sz.h;
|
||||
this.div.appendChild(gDiv);
|
||||
|
||||
// create GMap, hide nav controls
|
||||
this.gmap = new GMap2(this.div);
|
||||
this.moveTo();
|
||||
|
||||
// catch pans and zooms from GMap
|
||||
GEvent.addListener(this.gmap,
|
||||
"moveend",
|
||||
this.catchPanZoom.bindAsEventListener(this));
|
||||
|
||||
|
||||
// attach to the drag start and end and we´ll set a flag so that
|
||||
// we dont get recursivity. this is because the events fall through
|
||||
// the gmaps div and into the main layer div
|
||||
GEvent.addListener(this.gmap,
|
||||
"dragstart",
|
||||
this.dragStart.bindAsEventListener(this));
|
||||
|
||||
GEvent.addListener(this.gmap,
|
||||
"dragend",
|
||||
this.dragEnd.bindAsEventListener(this));
|
||||
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
dragStart: function() {
|
||||
this.dragging = true;
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
dragEnd: function() {
|
||||
this.dragging = false;
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {event} e
|
||||
*/
|
||||
catchPanZoom: function(e) {
|
||||
var olCenter = this.getGMapCenter();
|
||||
var gZoom = this.gmap.getZoom();
|
||||
|
||||
this.map.setCenter(olCenter, gZoom - 1);
|
||||
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @returns An OpenLayers.LonLat with the center of the gmap, or null if
|
||||
* the GMap has not been centered yet
|
||||
* @type OpenLayers.LonLat
|
||||
*/
|
||||
getGMapCenter:function() {
|
||||
var olCenter = null;
|
||||
var gCenter = this.gmap.getCenter();
|
||||
if (gCenter != null) {
|
||||
olCenter = new OpenLayers.LonLat(gCenter.lng(), gCenter.lat());
|
||||
}
|
||||
return olCenter;
|
||||
},
|
||||
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.Google"
|
||||
});
|
||||
296
public/lib/OpenLayers/Layer/Grid.js
Normal file
296
public/lib/OpenLayers/Layer/Grid.js
Normal file
|
|
@ -0,0 +1,296 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer.js
|
||||
// @require: OpenLayers/Util.js
|
||||
OpenLayers.Layer.Grid = Class.create();
|
||||
OpenLayers.Layer.Grid.TILE_WIDTH = 256;
|
||||
OpenLayers.Layer.Grid.TILE_HEIGHT = 256;
|
||||
OpenLayers.Layer.Grid.prototype = Object.extend( new OpenLayers.Layer(), {
|
||||
|
||||
// str: url
|
||||
url: null,
|
||||
|
||||
// hash: params
|
||||
params: null,
|
||||
|
||||
// tileSize: OpenLayers.Size
|
||||
tileSize: null,
|
||||
|
||||
// grid: Array(Array())
|
||||
// this is an array of rows, each row is an array of tiles
|
||||
grid: null,
|
||||
|
||||
/**
|
||||
* @param {str} name
|
||||
* @param {str} url
|
||||
* @param {hash} params
|
||||
*/
|
||||
initialize: function(name, url, params) {
|
||||
var newArguments = arguments;
|
||||
if (arguments.length > 0) {
|
||||
newArguments = [name];
|
||||
}
|
||||
OpenLayers.Layer.prototype.initialize.apply(this, newArguments);
|
||||
this.url = url;
|
||||
this.params = params;
|
||||
this.tileSize = new OpenLayers.Size(OpenLayers.Layer.Grid.TILE_WIDTH,
|
||||
OpenLayers.Layer.Grid.TILE_HEIGHT);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
this.params = null;
|
||||
this.clearGrid();
|
||||
this.grid = null;
|
||||
OpenLayers.Layer.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
setTileSize: function (size) {
|
||||
this.tileSize = size.copyOf();
|
||||
},
|
||||
|
||||
/**
|
||||
* moveTo
|
||||
* moveTo is a function called whenever the map is moved. All the moving
|
||||
* of actual 'tiles' is done by the map, but moveTo's role is to accept
|
||||
* a bounds and make sure the data that that bounds requires is pre-loaded.
|
||||
* @param {OpenLayers.Bounds}
|
||||
*/
|
||||
moveTo:function(bounds,zoomChanged) {
|
||||
if (!this.getVisibility()) {
|
||||
if (zoomChanged) {
|
||||
this.grid = null;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (!this.grid || zoomChanged) {
|
||||
this._initTiles();
|
||||
} else {
|
||||
var i = 0;
|
||||
while (this.getGridBounds().bottom > bounds.bottom) {
|
||||
this.insertRow(false);
|
||||
}
|
||||
while (this.getGridBounds().left > bounds.left) {
|
||||
this.insertColumn(true);
|
||||
}
|
||||
while (this.getGridBounds().top < bounds.top) {
|
||||
this.insertRow(true);
|
||||
}
|
||||
while (this.getGridBounds().right < bounds.right) {
|
||||
this.insertColumn(false);
|
||||
}
|
||||
}
|
||||
},
|
||||
getGridBounds:function() {
|
||||
var topLeftTile = this.grid[0][0];
|
||||
var bottomRightTile = this.grid[this.grid.length-1][this.grid[0].length-1];
|
||||
return new OpenLayers.Bounds(topLeftTile.bounds.left,
|
||||
bottomRightTile.bounds.bottom,
|
||||
bottomRightTile.bounds.right,
|
||||
topLeftTile.bounds.top);
|
||||
},
|
||||
|
||||
/**
|
||||
*/
|
||||
_initTiles:function() {
|
||||
|
||||
//first of all, clear out the main div
|
||||
this.div.innerHTML = "";
|
||||
|
||||
//now clear out the old grid and start a new one
|
||||
this.clearGrid();
|
||||
this.grid = new Array();
|
||||
|
||||
var viewSize = this.map.getSize();
|
||||
var bounds = this.map.getExtent();
|
||||
var extent = this.map.getFullExtent();
|
||||
var resolution = this.map.getResolution();
|
||||
var tilelon = resolution*this.tileSize.w;
|
||||
var tilelat = resolution*this.tileSize.h;
|
||||
|
||||
var offsetlon = bounds.left - extent.left;
|
||||
var tilecol = Math.floor(offsetlon/tilelon);
|
||||
var tilecolremain = offsetlon/tilelon - tilecol;
|
||||
var tileoffsetx = -tilecolremain * this.tileSize.w;
|
||||
var tileoffsetlon = extent.left + tilecol * tilelon;
|
||||
|
||||
var offsetlat = bounds.top - (extent.bottom + tilelat);
|
||||
var tilerow = Math.ceil(offsetlat/tilelat);
|
||||
var tilerowremain = tilerow - offsetlat/tilelat;
|
||||
var tileoffsety = -tilerowremain * this.tileSize.h;
|
||||
var tileoffsetlat = extent.bottom + tilerow * tilelat;
|
||||
|
||||
tileoffsetx = Math.round(tileoffsetx); // heaven help us
|
||||
tileoffsety = Math.round(tileoffsety);
|
||||
|
||||
this.origin = new OpenLayers.Pixel(tileoffsetx,tileoffsety);
|
||||
|
||||
var startX = tileoffsetx;
|
||||
var startLon = tileoffsetlon;
|
||||
|
||||
do {
|
||||
var row = new Array();
|
||||
this.grid.append(row);
|
||||
tileoffsetlon = startLon;
|
||||
tileoffsetx = startX;
|
||||
do {
|
||||
var tileBounds = new OpenLayers.Bounds(tileoffsetlon,
|
||||
tileoffsetlat,
|
||||
tileoffsetlon+tilelon,
|
||||
tileoffsetlat+tilelat);
|
||||
|
||||
var tile = this.addTile(tileBounds,
|
||||
new OpenLayers.Pixel(tileoffsetx - parseInt(this.map.layerContainerDiv.style.left),
|
||||
tileoffsety - parseInt(this.map.layerContainerDiv.style.top))
|
||||
);
|
||||
tile.draw((this.params.TRANSPARENT == 'true'));
|
||||
row.append(tile);
|
||||
|
||||
tileoffsetlon += tilelon;
|
||||
tileoffsetx += this.tileSize.w;
|
||||
} while (tileoffsetlon < bounds.right)
|
||||
|
||||
tileoffsetlat -= tilelat;
|
||||
tileoffsety += this.tileSize.h;
|
||||
} while(tileoffsetlat > bounds.bottom - tilelat)
|
||||
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {bool} prepend - if true, prepend to beginning.
|
||||
* if false, then append to end
|
||||
*/
|
||||
insertRow:function(prepend) {
|
||||
var modelRowIndex = (prepend) ? 0 : (this.grid.length - 1);
|
||||
var modelRow = this.grid[modelRowIndex];
|
||||
|
||||
var newRow = new Array();
|
||||
|
||||
var resolution = this.map.getResolution();
|
||||
var deltaY = (prepend) ? -this.tileSize.h : this.tileSize.h;
|
||||
var deltaLat = resolution * -deltaY;
|
||||
|
||||
for (var i=0; i < modelRow.length; i++) {
|
||||
var modelTile = modelRow[i];
|
||||
var bounds = modelTile.bounds.copyOf();
|
||||
var position = modelTile.position.copyOf();
|
||||
bounds.bottom = bounds.bottom + deltaLat;
|
||||
bounds.top = bounds.top + deltaLat;
|
||||
position.y = position.y + deltaY;
|
||||
var newTile = this.addTile(bounds, position);
|
||||
newTile.draw((this.params.TRANSPARENT == 'true'));
|
||||
newRow.append(newTile);
|
||||
}
|
||||
|
||||
if (newRow.length>0){
|
||||
if (prepend) {
|
||||
this.grid.prepend(newRow);
|
||||
} else {
|
||||
this.grid.append(newRow);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {bool} prepend - if true, prepend to beginning.
|
||||
* if false, then append to end
|
||||
*/
|
||||
insertColumn:function(prepend) {
|
||||
var modelCellIndex;
|
||||
var deltaX = (prepend) ? -this.tileSize.w : this.tileSize.w;
|
||||
var resolution = this.map.getResolution();
|
||||
var deltaLon = resolution * deltaX;
|
||||
|
||||
for (var i=0; i<this.grid.length; i++) {
|
||||
var row = this.grid[i];
|
||||
modelTileIndex = (prepend) ? 0 : (row.length - 1);
|
||||
var modelTile = row[modelTileIndex];
|
||||
|
||||
var bounds = modelTile.bounds.copyOf();
|
||||
var position = modelTile.position.copyOf();
|
||||
bounds.left = bounds.left + deltaLon;
|
||||
bounds.right = bounds.right + deltaLon;
|
||||
position.x = position.x + deltaX;
|
||||
var newTile = this.addTile(bounds, position);
|
||||
newTile.draw((this.params.TRANSPARENT == 'true'));
|
||||
|
||||
if (prepend) {
|
||||
row = row.prepend(newTile);
|
||||
} else {
|
||||
row = row.append(newTile);
|
||||
}
|
||||
}
|
||||
},
|
||||
/** combine the ds's serverPath with its params and the tile's params.
|
||||
*
|
||||
* does checking on the serverPath variable, allowing for cases when it
|
||||
* is supplied with trailing ? or &, as well as cases where not.
|
||||
*
|
||||
* return in formatted string like this:
|
||||
* "server?key1=value1&key2=value2&key3=value3"
|
||||
*
|
||||
* @return {str}
|
||||
*/
|
||||
getFullRequestString:function(params) {
|
||||
var requestString = "";
|
||||
this.params.SRS = this.map.projection;
|
||||
// concat tile params with layer params and convert to string
|
||||
var allParams = Object.extend(this.params, params);
|
||||
var paramsString = OpenLayers.Util.getParameterString(allParams);
|
||||
|
||||
var server = this.url;
|
||||
var lastServerChar = server.charAt(server.length - 1);
|
||||
|
||||
if ((lastServerChar == "&") || (lastServerChar == "?")) {
|
||||
requestString = server + paramsString;
|
||||
} else {
|
||||
if (server.indexOf('?') == -1) {
|
||||
//serverPath has no ? -- add one
|
||||
requestString = server + '?' + paramsString;
|
||||
} else {
|
||||
//serverPath contains ?, so must already have paramsString at the end
|
||||
requestString = server + '&' + paramsString;
|
||||
}
|
||||
}
|
||||
return requestString;
|
||||
},
|
||||
|
||||
/** go through and remove all tiles from the grid, calling
|
||||
* destroy() on each of them to kill circular references
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
clearGrid:function() {
|
||||
if (this.grid) {
|
||||
while(this.grid.length > 0) {
|
||||
var row = this.grid[0];
|
||||
while(row.length > 0) {
|
||||
var tile = row[0];
|
||||
tile.destroy();
|
||||
row.remove(tile);
|
||||
}
|
||||
this.grid.remove(row);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* addTile gives subclasses of Grid the opportunity to create an
|
||||
* OpenLayer.Tile of their choosing. The implementer should initialize
|
||||
* the new tile and take whatever steps necessary to display it.
|
||||
*
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
*
|
||||
* @returns The added OpenLayers.Tile
|
||||
* @type OpenLayers.Tile
|
||||
*/
|
||||
addTile:function(bounds,position) {
|
||||
// Should be implemented by subclasses
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Grid"
|
||||
});
|
||||
53
public/lib/OpenLayers/Layer/KaMap.js
Normal file
53
public/lib/OpenLayers/Layer/KaMap.js
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer/Grid.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.KaMap = Class.create();
|
||||
OpenLayers.Layer.KaMap.prototype =
|
||||
Object.extend( new OpenLayers.Layer.Grid(), {
|
||||
metaTileHeight: 6,
|
||||
metaTileWidth: 6,
|
||||
|
||||
DEFAULT_PARAMS: {
|
||||
i: 'jpeg',
|
||||
map: ''
|
||||
},
|
||||
|
||||
// this.cellSize = newScale/(oMap.resolution * inchesPerUnit[oMap.units]);
|
||||
// kaMap.prototype.geoToPix = function( gX, gY ) { var pX = gX / this.cellSize; var pY = -1 * gY / this.cellSize; }
|
||||
initialize: function(name, url, params, origin) {
|
||||
this.kaOrigin = origin;
|
||||
var newArguments = new Array();
|
||||
newArguments.push(name, url, params);
|
||||
OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
|
||||
this.params = (params ? params : {});
|
||||
if (arguments.length > 0 && params) {
|
||||
OpenLayers.Util.applyDefaults(
|
||||
this.params,
|
||||
this.DEFAULT_PARAMS
|
||||
);
|
||||
}
|
||||
},
|
||||
addTile:function(bounds,position) {
|
||||
var zoom = this.map.getZoom();
|
||||
var resolution = this.map.getResolution();
|
||||
var scale = 128000000 / Math.pow(2, zoom);
|
||||
// 1280000 is an empirical value for a specific tile server, not yet figured out the right way to do this in general.
|
||||
// This will probably be based on map.maxResolution.
|
||||
var cellSize = new OpenLayers.Size(resolution*this.tileSize.w, resolution*this.tileSize.h);
|
||||
var pX = Math.floor(((bounds.left + this.kaOrigin.lon) / cellSize.w) * this.tileSize.w);
|
||||
var pY = -Math.floor(((bounds.top+this.kaOrigin.lat) / cellSize.h) * this.tileSize.h);
|
||||
var url = this.getFullRequestString(
|
||||
{ t: pY,
|
||||
l: pX,
|
||||
s: scale
|
||||
});
|
||||
return new OpenLayers.Tile.Image(this, position, bounds,
|
||||
url, this.tileSize);
|
||||
},
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.KaMap"
|
||||
});
|
||||
113
public/lib/OpenLayers/Layer/Markers.js
Normal file
113
public/lib/OpenLayers/Layer/Markers.js
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.Markers = Class.create();
|
||||
OpenLayers.Layer.Markers.prototype =
|
||||
Object.extend( new OpenLayers.Layer(), {
|
||||
|
||||
/** internal marker list
|
||||
* @type Array(OpenLayers.Marker) */
|
||||
markers: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} name
|
||||
*/
|
||||
initialize: function(name) {
|
||||
OpenLayers.Layer.prototype.initialize.apply(this, arguments);
|
||||
this.markers = new Array();
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
this.clearMarkers();
|
||||
markers = null;
|
||||
OpenLayers.Layer.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {Boolean} zoomChanged
|
||||
*/
|
||||
moveTo: function(bounds, zoomChanged) {
|
||||
if (zoomChanged) {
|
||||
this.redraw();
|
||||
}
|
||||
},
|
||||
|
||||
/** WFS layer is never a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return false;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Marker} marker
|
||||
*/
|
||||
addMarker: function(marker) {
|
||||
this.markers.append(marker);
|
||||
if (this.map && this.map.getExtent()) {
|
||||
marker.map = this.map;
|
||||
this.drawMarker(marker);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Marker} marker
|
||||
*/
|
||||
removeMarker: function(marker) {
|
||||
this.markers.remove(marker);
|
||||
if ((marker.icon != null) && (marker.icon.imageDiv != null) &&
|
||||
(marker.icon.imageDiv.parentNode == this.div) ) {
|
||||
this.div.removeChild(marker.icon.imageDiv);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
clearMarkers: function() {
|
||||
if (this.markers != null) {
|
||||
while(this.markers.length > 0) {
|
||||
this.removeMarker(this.markers[0]);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/** clear all the marker div's from the layer and then redraw all of them.
|
||||
* Use the map to recalculate new placement of markers.
|
||||
*/
|
||||
redraw: function() {
|
||||
for(i=0; i < this.markers.length; i++) {
|
||||
this.drawMarker(this.markers[i]);
|
||||
}
|
||||
},
|
||||
|
||||
/** Calculate the pixel location for the marker, create it, and
|
||||
* add it to the layer's div
|
||||
*
|
||||
* @private
|
||||
*
|
||||
* @param {OpenLayers.Marker} marker
|
||||
*/
|
||||
drawMarker: function(marker) {
|
||||
var px = this.map.getLayerPxFromLonLat(marker.lonlat);
|
||||
var markerImg = marker.draw(px);
|
||||
if (!marker.drawn) {
|
||||
this.div.appendChild(markerImg);
|
||||
marker.drawn = true;
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.Markers"
|
||||
});
|
||||
172
public/lib/OpenLayers/Layer/Text.js
Normal file
172
public/lib/OpenLayers/Layer/Text.js
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer/Markers.js
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.Text = Class.create();
|
||||
OpenLayers.Layer.Text.prototype =
|
||||
Object.extend( new OpenLayers.Layer.Markers(), {
|
||||
|
||||
/** store url of text file
|
||||
* @type str */
|
||||
location:null,
|
||||
|
||||
/** @type Array(OpenLayers.Feature) */
|
||||
features: null,
|
||||
|
||||
/** @type OpenLayers.Feature */
|
||||
selectedFeature: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} name
|
||||
* @param {String} location
|
||||
*/
|
||||
initialize: function(name, location) {
|
||||
OpenLayers.Layer.Markers.prototype.initialize.apply(this, [name]);
|
||||
this.location = location;
|
||||
this.features = new Array();
|
||||
new Ajax.Request(location,
|
||||
{ method: 'get', onComplete:this.parseData.bind(this) } );
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
this.clearFeatures();
|
||||
this.features = null;
|
||||
OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
/** WFS layer is never a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return false;
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* @param {?} ajaxRequest
|
||||
*/
|
||||
parseData: function(ajaxRequest) {
|
||||
var text = ajaxRequest.responseText;
|
||||
var lines = text.split('\n');
|
||||
var columns;
|
||||
// length - 1 to allow for trailing new line
|
||||
for (var lcv = 0; lcv < (lines.length - 1); lcv++) {
|
||||
var currLine = lines[lcv].replace(/^\s*/,'').replace(/\s*$/,'');
|
||||
|
||||
if (currLine.charAt(0) != '#') { /* not a comment */
|
||||
|
||||
if (!columns) {
|
||||
//First line is columns
|
||||
columns = currLine.split('\t');
|
||||
} else {
|
||||
var vals = currLine.split('\t');
|
||||
var location = new OpenLayers.LonLat(0,0);
|
||||
var title; var url;
|
||||
var icon, iconSize, iconOffset;
|
||||
var set = false;
|
||||
for (var valIndex = 0; valIndex < vals.length; valIndex++) {
|
||||
if (vals[valIndex]) {
|
||||
if (columns[valIndex] == 'point') {
|
||||
var coords = vals[valIndex].split(',');
|
||||
location.lat = parseFloat(coords[0]);
|
||||
location.lon = parseFloat(coords[1]);
|
||||
set = true;
|
||||
} else if (columns[valIndex] == 'lat') {
|
||||
location.lat = parseFloat(vals[valIndex]);
|
||||
set = true;
|
||||
} else if (columns[valIndex] == 'lon') {
|
||||
location.lon = parseFloat(vals[valIndex]);
|
||||
set = true;
|
||||
} else if (columns[valIndex] == 'title')
|
||||
title = vals[valIndex];
|
||||
else if (columns[valIndex] == 'image' ||
|
||||
columns[valIndex] == 'icon')
|
||||
url = vals[valIndex];
|
||||
else if (columns[valIndex] == 'iconSize') {
|
||||
var size = vals[valIndex].split(',');
|
||||
iconSize = new OpenLayers.Size(parseFloat(size[0]),
|
||||
parseFloat(size[1]));
|
||||
} else if (columns[valIndex] == 'iconOffset') {
|
||||
var offset = vals[valIndex].split(',');
|
||||
iconOffset = new OpenLayers.Pixel(parseFloat(offset[0]),
|
||||
parseFloat(offset[1]));
|
||||
} else if (columns[valIndex] == 'title') {
|
||||
title = vals[valIndex];
|
||||
} else if (columns[valIndex] == 'description') {
|
||||
description = vals[valIndex];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (set) {
|
||||
var data = new Object();
|
||||
if (url != null) {
|
||||
data.icon = new OpenLayers.Icon(url,
|
||||
iconSize,
|
||||
iconOffset);
|
||||
} else {
|
||||
data.icon = OpenLayers.Marker.defaultIcon();
|
||||
|
||||
//allows for the case where the image url is not
|
||||
// specified but the size is. use a default icon
|
||||
// but change the size
|
||||
if (iconSize != null) {
|
||||
data.icon.setSize(iconSize);
|
||||
}
|
||||
|
||||
}
|
||||
if ((title != null) && (description != null)) {
|
||||
data['popupContentHTML'] = '<h2>'+title+'</h2><p>'+description+'</p>';
|
||||
}
|
||||
var feature = new OpenLayers.Feature(this, location, data);
|
||||
this.features.append(feature);
|
||||
var marker = feature.createMarker();
|
||||
marker.events.register('click', feature, this.markerClick);
|
||||
this.addMarker(marker);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Event} evt
|
||||
*/
|
||||
markerClick: function(evt) {
|
||||
sameMarkerClicked = (this == this.layer.selectedFeature);
|
||||
this.layer.selectedFeature = (!sameMarkerClicked) ? this : null;
|
||||
for(var i=0; i < this.layer.map.popups.length; i++) {
|
||||
this.layer.map.removePopup(this.layer.map.popups[i]);
|
||||
}
|
||||
if (!sameMarkerClicked) {
|
||||
this.layer.map.addPopup(this.createPopup());
|
||||
}
|
||||
Event.stop(evt);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
clearFeatures: function() {
|
||||
if (this.features != null) {
|
||||
while(this.features.length > 0) {
|
||||
var feature = this.features[0];
|
||||
this.features.remove(feature);
|
||||
feature.destroy();
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Text"
|
||||
});
|
||||
|
||||
|
||||
107
public/lib/OpenLayers/Layer/VirtualEarth.js
Normal file
107
public/lib/OpenLayers/Layer/VirtualEarth.js
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer.js
|
||||
|
||||
// load VE map control script
|
||||
document.write("<script src='http://dev.virtualearth.net/mapcontrol/v3/mapcontrol.js'></script>");
|
||||
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.VirtualEarth = Class.create();
|
||||
OpenLayers.Layer.VirtualEarth.prototype =
|
||||
Object.extend( new OpenLayers.Layer(), {
|
||||
|
||||
/** @type Boolean */
|
||||
viewPortLayer: true,
|
||||
|
||||
/** @type VEMap */
|
||||
vemap: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {str} name
|
||||
*/
|
||||
initialize:function(name) {
|
||||
OpenLayers.Layer.prototype.initialize.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Map} map
|
||||
*/
|
||||
setMap:function(map) {
|
||||
OpenLayers.Layer.prototype.setMap.apply(this, arguments);
|
||||
|
||||
// once our layer has been added to the map, we can create the vemap
|
||||
this.map.events.register("addlayer", this, this.loadVEMap);
|
||||
},
|
||||
|
||||
/** Virtual Earth layer is always a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return true;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {int} zoomChanged
|
||||
*/
|
||||
moveTo:function(bounds,zoomChanged) {
|
||||
|
||||
if (this.vemap != null) {
|
||||
var olCenter = this.map.getCenter();
|
||||
var olZoom = this.map.getZoom();
|
||||
|
||||
this.vemap.SetCenterAndZoom(new VELatLong(olCenter.lat, olCenter.lon),
|
||||
olZoom + 1);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
loadVEMap:function() {
|
||||
// create div and set to same size as map
|
||||
var veDiv = OpenLayers.Util.createDiv(this.name);
|
||||
var sz = this.map.getSize();
|
||||
veDiv.style.width = sz.w;
|
||||
veDiv.style.height = sz.h;
|
||||
this.div.appendChild(veDiv);
|
||||
|
||||
// create VEMap, hide nav controls
|
||||
this.vemap = new VEMap(this.name);
|
||||
this.vemap.LoadMap();
|
||||
this.vemap.HideDashboard();
|
||||
|
||||
// catch pans and zooms from VE Map
|
||||
this.vemap.AttachEvent("onendcontinuouspan",
|
||||
this.catchPanZoom.bindAsEventListener(this));
|
||||
this.vemap.AttachEvent("onendzoom",
|
||||
this.catchPanZoom.bindAsEventListener(this));
|
||||
|
||||
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {event} e
|
||||
*/
|
||||
catchPanZoom: function(e) {
|
||||
var veCenter = this.vemap.GetCenter();
|
||||
var veZoom = this.vemap.GetZoomLevel();
|
||||
|
||||
var olCenter = new OpenLayers.LonLat(veCenter.Longitude,
|
||||
veCenter.Latitude);
|
||||
|
||||
this.map.setCenter(olCenter, veZoom - 1);
|
||||
|
||||
},
|
||||
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.VirtualEarth"
|
||||
});
|
||||
116
public/lib/OpenLayers/Layer/WFS.js
Normal file
116
public/lib/OpenLayers/Layer/WFS.js
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer/Grid.js
|
||||
// @require: OpenLayers/Layer/Markers.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.WFS = Class.create();
|
||||
OpenLayers.Layer.WFS.prototype =
|
||||
Object.extend(new OpenLayers.Layer.Grid(),
|
||||
Object.extend(new OpenLayers.Layer.Markers(), {
|
||||
|
||||
/** @type Object */
|
||||
featureClass: OpenLayers.Feature.WFS,
|
||||
|
||||
/** @final @type hash */
|
||||
DEFAULT_PARAMS: { service: "WFS",
|
||||
version: "1.0.0",
|
||||
request: "GetFeature",
|
||||
typename: "docpoint"
|
||||
},
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {str} name
|
||||
* @param {str} url
|
||||
* @param {hash} params
|
||||
* @param {Object} featureClass
|
||||
*/
|
||||
initialize: function(name, url, params, featureClass) {
|
||||
if (featureClass != null) this.featureClass = featureClass;
|
||||
|
||||
var newArguments = new Array();
|
||||
if (arguments.length > 0) {
|
||||
//uppercase params
|
||||
params = OpenLayers.Util.upperCaseObject(params);
|
||||
newArguments.push(name, url, params);
|
||||
}
|
||||
OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
|
||||
OpenLayers.Layer.Markers.prototype.initialize.apply(this, newArguments);
|
||||
|
||||
if (arguments.length > 0) {
|
||||
OpenLayers.Util.applyDefaults(
|
||||
this.params,
|
||||
OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
|
||||
);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
OpenLayers.Layer.Grid.prototype.destroy.apply(this, arguments);
|
||||
OpenLayers.Layer.Markers.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {Boolean} zoomChanged
|
||||
*/
|
||||
moveTo: function(bounds, zoomChanged) {
|
||||
OpenLayers.Layer.Grid.prototype.moveTo.apply(this, arguments);
|
||||
OpenLayers.Layer.Markers.prototype.moveTo.apply(this, arguments);
|
||||
},
|
||||
|
||||
/** WFS layer is never a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return false;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} name
|
||||
* @param {hash} params
|
||||
*
|
||||
* @returns A clone of this OpenLayers.Layer.WMS, with the passed-in
|
||||
* parameters merged in.
|
||||
* @type OpenLayers.Layer.WMS
|
||||
*/
|
||||
clone: function (name, params) {
|
||||
var mergedParams = {}
|
||||
Object.extend(mergedParams, this.params);
|
||||
Object.extend(mergedParams, params);
|
||||
var obj = new OpenLayers.Layer.WFS(name, this.url, mergedParams);
|
||||
obj.setTileSize(this.tileSize);
|
||||
return obj;
|
||||
},
|
||||
|
||||
/**
|
||||
* addTile creates a tile, initializes it (via 'draw' in this case), and
|
||||
* adds it to the layer div.
|
||||
*
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
*
|
||||
* @returns The added OpenLayers.Tile.WFS
|
||||
* @type OpenLayers.Tile.WFS
|
||||
*/
|
||||
addTile:function(bounds, position) {
|
||||
url = this.getFullRequestString(
|
||||
{ BBOX:bounds.toBBOX() });
|
||||
|
||||
return new OpenLayers.Tile.WFS(this, position, bounds,
|
||||
url, this.tileSize);
|
||||
},
|
||||
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.WFS"
|
||||
}
|
||||
)
|
||||
);
|
||||
91
public/lib/OpenLayers/Layer/WMS.js
Normal file
91
public/lib/OpenLayers/Layer/WMS.js
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer/Grid.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.WMS = Class.create();
|
||||
OpenLayers.Layer.WMS.prototype =
|
||||
Object.extend( new OpenLayers.Layer.Grid(), {
|
||||
|
||||
/** @final @type hash */
|
||||
DEFAULT_PARAMS: { service: "WMS",
|
||||
version: "1.1.1",
|
||||
request: "GetMap",
|
||||
styles: "",
|
||||
exceptions: "application/vnd.ogc.se_inimage",
|
||||
format: "image/jpeg"
|
||||
},
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {str} name
|
||||
* @param {str} url
|
||||
* @param {hash} params
|
||||
*/
|
||||
initialize: function(name, url, params) {
|
||||
var newArguments = new Array();
|
||||
if (arguments.length > 0) {
|
||||
//uppercase params
|
||||
params = OpenLayers.Util.upperCaseObject(params);
|
||||
newArguments.push(name, url, params);
|
||||
}
|
||||
OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
|
||||
|
||||
if (arguments.length > 0) {
|
||||
OpenLayers.Util.applyDefaults(
|
||||
this.params,
|
||||
OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
|
||||
);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/** WFS layer is never a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return (this.params.TRANSPARENT != 'true');
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} name
|
||||
* @param {hash} params
|
||||
*
|
||||
* @returns A clone of this OpenLayers.Layer.WMS, with the passed-in
|
||||
* parameters merged in.
|
||||
* @type OpenLayers.Layer.WMS
|
||||
*/
|
||||
clone: function (name, params) {
|
||||
var mergedParams = {};
|
||||
Object.extend(mergedParams, this.params);
|
||||
Object.extend(mergedParams, params);
|
||||
var obj = new OpenLayers.Layer.WMS(name, this.url, mergedParams);
|
||||
obj.setTileSize(this.tileSize);
|
||||
return obj;
|
||||
},
|
||||
|
||||
/**
|
||||
* addTile creates a tile, initializes it (via 'draw' in this case), and
|
||||
* adds it to the layer div.
|
||||
*
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
*
|
||||
* @returns The added OpenLayers.Tile.Image
|
||||
* @type OpenLayers.Tile.Image
|
||||
*/
|
||||
addTile:function(bounds,position) {
|
||||
url = this.getFullRequestString(
|
||||
{BBOX:bounds.toBBOX(),
|
||||
WIDTH:this.tileSize.w,
|
||||
HEIGHT:this.tileSize.h});
|
||||
|
||||
return new OpenLayers.Tile.Image(this, position, bounds,
|
||||
url, this.tileSize);
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.WMS"
|
||||
});
|
||||
97
public/lib/OpenLayers/Layer/WMS/Untiled.js
Normal file
97
public/lib/OpenLayers/Layer/WMS/Untiled.js
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer/Grid.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.WMS.Untiled = Class.create();
|
||||
OpenLayers.Layer.WMS.Untiled.prototype =
|
||||
Object.extend( new OpenLayers.Layer.Grid(), {
|
||||
|
||||
/** @final @type hash */
|
||||
DEFAULT_PARAMS: { service: "WMS",
|
||||
version: "1.1.1",
|
||||
request: "GetMap",
|
||||
styles: "",
|
||||
exceptions: "application/vnd.ogc.se_inimage",
|
||||
format: "image/jpeg"
|
||||
},
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {str} name
|
||||
* @param {str} url
|
||||
* @param {hash} params
|
||||
*/
|
||||
initialize: function(name, url, params) {
|
||||
var newArguments = new Array();
|
||||
if (arguments.length > 0) {
|
||||
//uppercase params
|
||||
params = OpenLayers.Util.upperCaseObject(params);
|
||||
newArguments.push(name, url, params);
|
||||
}
|
||||
OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
|
||||
|
||||
if (arguments.length > 0) {
|
||||
OpenLayers.Util.applyDefaults(
|
||||
this.params,
|
||||
OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
|
||||
);
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/** WFS layer is never a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return (this.params.TRANSPARENT != true);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} name
|
||||
* @param {hash} params
|
||||
*
|
||||
* @returns A clone of this OpenLayers.Layer.WMS, with the passed-in
|
||||
* parameters merged in.
|
||||
* @type OpenLayers.Layer.WMS
|
||||
*/
|
||||
clone: function (name, params) {
|
||||
var mergedParams = {};
|
||||
Object.extend(mergedParams, this.params);
|
||||
Object.extend(mergedParams, params);
|
||||
var obj = new OpenLayers.Layer.WMS(name, this.url, mergedParams);
|
||||
obj.setTileSize(this.tileSize);
|
||||
return obj;
|
||||
},
|
||||
|
||||
/**
|
||||
* addTile creates a tile, initializes it (via 'draw' in this case), and
|
||||
* adds it to the layer div.
|
||||
*
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
*
|
||||
* @returns The added OpenLayers.Tile.Image
|
||||
* @type OpenLayers.Tile.Image
|
||||
*/
|
||||
addTile:function(bounds,position) {
|
||||
url = this.getFullRequestString(
|
||||
{BBOX:bounds.toBBOX(),
|
||||
WIDTH:this.map.getSize().w,
|
||||
HEIGHT:this.map.getSize().h});
|
||||
|
||||
return new OpenLayers.Tile.Image(this, position, bounds,
|
||||
url, this.map.getSize());
|
||||
},
|
||||
moveTo:function(bounds,zoomChanged, minor) {
|
||||
if (!minor) {
|
||||
this.div.innerHTML = "";
|
||||
tile = this.addTile(bounds, new OpenLayers.Pixel(-parseInt(this.map.layerContainerDiv.style.left), -parseInt(this.map.layerContainerDiv.style.top)));
|
||||
tile.draw();
|
||||
}
|
||||
},
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.WMS.Untiled"
|
||||
});
|
||||
149
public/lib/OpenLayers/Layer/Yahoo.js
Normal file
149
public/lib/OpenLayers/Layer/Yahoo.js
Normal file
|
|
@ -0,0 +1,149 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Layer.js
|
||||
|
||||
// load Yahoo map control script
|
||||
document.write("<script src='http://api.maps.yahoo.com/ajaxymap?v=3.0&appid=euzuro-openlayers'></script>");
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Layer.Yahoo = Class.create();
|
||||
OpenLayers.Layer.Yahoo.prototype = Object.extend( new OpenLayers.Layer(), {
|
||||
|
||||
/** @type Boolean */
|
||||
viewPortLayer: true,
|
||||
|
||||
/** @type GMap2 gmap stores the Google Map element */
|
||||
ymap:null,
|
||||
|
||||
/** @type Boolean */
|
||||
dragging:false,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} name
|
||||
*/
|
||||
initialize: function(name) {
|
||||
OpenLayers.Layer.prototype.initialize.apply(this, [name]);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Map} map
|
||||
*/
|
||||
setMap:function(map) {
|
||||
OpenLayers.Layer.prototype.setMap.apply(this, arguments);
|
||||
|
||||
// once our layer has been added to the map, we can create the vemap
|
||||
this.map.events.register("addlayer", this, this.loadYMap);
|
||||
},
|
||||
|
||||
/** Yahoo layer is always a base class.
|
||||
* @type Boolean
|
||||
*/
|
||||
isBaseLayer: function() {
|
||||
return true;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {int} zoomChanged
|
||||
*/
|
||||
moveTo:function(bounds,zoomChanged) {
|
||||
|
||||
if ((this.ymap != null) && (!this.dragging)) {
|
||||
|
||||
var olCenter = this.map.getCenter();
|
||||
var yCenter = this.getYMapCenter();
|
||||
|
||||
var olZoom = this.map.getZoom();
|
||||
var yZoom = this.ymap.getZoomLevel();
|
||||
|
||||
if ((!olCenter.equals(yCenter)) || (( 16 - olZoom) != yZoom)) {
|
||||
this.ymap.drawZoomAndCenter(new YGeoPoint(olCenter.lat, olCenter.lon),
|
||||
16 - olZoom);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
loadYMap:function() {
|
||||
// create div and set to same size as map
|
||||
var yDiv = OpenLayers.Util.createDiv(this.name);
|
||||
var sz = this.map.getSize();
|
||||
yDiv.style.width = sz.w;
|
||||
yDiv.style.height = sz.h;
|
||||
this.div.appendChild(yDiv);
|
||||
|
||||
// create GMap, hide nav controls
|
||||
this.ymap = new YMap(this.div);
|
||||
|
||||
// catch pans and zooms from GMap
|
||||
YEvent.Capture(this.ymap,
|
||||
EventsList.endPan,
|
||||
this.catchPanZoom,
|
||||
this);
|
||||
|
||||
// catch pans and zooms from GMap
|
||||
YEvent.Capture(this.ymap,
|
||||
EventsList.endAutoPan,
|
||||
this.catchPanZoom,
|
||||
this);
|
||||
|
||||
|
||||
// attach to the drag start and end and we´ll set a flag so that
|
||||
// we dont get recursivity. this is because the events fall through
|
||||
// the gmaps div and into the main layer div
|
||||
YEvent.Capture(this.ymap,
|
||||
EventsList.startPan,
|
||||
this.dragStart,
|
||||
this);
|
||||
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
dragStart: function() {
|
||||
this.dragging = true;
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {event} e
|
||||
*/
|
||||
catchPanZoom: function(e) {
|
||||
this.dragging = false;
|
||||
|
||||
var olCenter = this.getYMapCenter();
|
||||
var yZoom = this.ymap.getZoomLevel();
|
||||
|
||||
this.map.setCenter(olCenter, 16 - yZoom);
|
||||
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @returns An OpenLayers.LonLat with the center of the ymap, or null if
|
||||
* the YMap has not been centered yet
|
||||
* @type OpenLayers.LonLat
|
||||
*/
|
||||
getYMapCenter:function() {
|
||||
var olCenter = null;
|
||||
var yCenter = this.ymap.getCenterLatLon();
|
||||
if (yCenter != null) {
|
||||
olCenter = new OpenLayers.LonLat(yCenter.Lon, yCenter.Lat);
|
||||
}
|
||||
return olCenter;
|
||||
},
|
||||
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Layer.Yahoo"
|
||||
});
|
||||
574
public/lib/OpenLayers/Map.js
Normal file
574
public/lib/OpenLayers/Map.js
Normal file
|
|
@ -0,0 +1,574 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Util.js
|
||||
/**
|
||||
* @class
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
OpenLayers.Map = Class.create();
|
||||
OpenLayers.Map.prototype = {
|
||||
// Hash: base z-indexes for different classes of thing
|
||||
Z_INDEX_BASE: { Layer: 100, Popup: 200, Control: 1000 },
|
||||
|
||||
// Array: supported application event types
|
||||
EVENT_TYPES: [
|
||||
"addlayer", "removelayer", "movestart", "move", "moveend",
|
||||
"zoomend", "layerchanged", "popupopen", "popupclose",
|
||||
"addmarker", "removemarker", "clearmarkers", "mouseover",
|
||||
"mouseout", "mousemove", "dragstart", "drag", "dragend" ],
|
||||
|
||||
// int: zoom levels, used to draw zoom dragging control and limit zooming
|
||||
maxZoomLevel: 16,
|
||||
|
||||
// OpenLayers.Bounds
|
||||
maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90),
|
||||
|
||||
/* projection */
|
||||
projection: "EPSG:4326",
|
||||
|
||||
/** @type OpenLayers.Size */
|
||||
size: null,
|
||||
|
||||
// float
|
||||
maxResolution: 1.40625, // degrees per pixel
|
||||
// Default is whole world in 256 pixels, from GMaps
|
||||
|
||||
// DOMElement: the div that our map lives in
|
||||
div: null,
|
||||
|
||||
// HTMLDivElement: the map's view port
|
||||
viewPortDiv: null,
|
||||
|
||||
// HTMLDivElement: the map's layer container
|
||||
layerContainerDiv: null,
|
||||
|
||||
// Array(OpenLayers.Layer): ordered list of layers in the map
|
||||
layers: null,
|
||||
|
||||
// Array(OpenLayers.Control)
|
||||
controls: null,
|
||||
|
||||
// Array(OpenLayers.Popup)
|
||||
popups: null,
|
||||
|
||||
// OpenLayers.LonLat
|
||||
center: null,
|
||||
|
||||
// int
|
||||
zoom: null,
|
||||
|
||||
// OpenLayers.Events
|
||||
events: null,
|
||||
|
||||
// OpenLayers.Pixel
|
||||
mouseDragStart: null,
|
||||
|
||||
/** @type OpenLayers.Layer */
|
||||
baseLayer: null,
|
||||
|
||||
/**
|
||||
* @param {DOMElement} div
|
||||
*/
|
||||
initialize: function (div, options) {
|
||||
Object.extend(this, options);
|
||||
|
||||
this.div = div = $(div);
|
||||
|
||||
// the viewPortDiv is the outermost div we modify
|
||||
var id = div.id + "_OpenLayers_ViewPort";
|
||||
this.viewPortDiv = OpenLayers.Util.createDiv(id, null, null, null,
|
||||
"relative", null,
|
||||
"hidden");
|
||||
this.viewPortDiv.style.width = "100%";
|
||||
this.viewPortDiv.style.height = "100%";
|
||||
this.div.appendChild(this.viewPortDiv);
|
||||
|
||||
// the layerContainerDiv is the one that holds all the layers
|
||||
id = div.id + "_OpenLayers_Container";
|
||||
this.layerContainerDiv = OpenLayers.Util.createDiv(id);
|
||||
this.viewPortDiv.appendChild(this.layerContainerDiv);
|
||||
|
||||
this.events = new OpenLayers.Events(this, div, this.EVENT_TYPES);
|
||||
|
||||
this.updateSize();
|
||||
// make the entire maxExtent fix in zoom level 0 by default
|
||||
if (this.maxResolution == null || this.maxResolution == "auto") {
|
||||
this.maxResolution = Math.max(
|
||||
this.maxExtent.getWidth() / this.size.w,
|
||||
this.maxExtent.getHeight() / this.size.h );
|
||||
}
|
||||
// update the internal size register whenever the div is resized
|
||||
this.events.register("resize", this, this.updateSize);
|
||||
|
||||
this.layers = [];
|
||||
|
||||
if (!this.controls) {
|
||||
this.controls = [];
|
||||
this.addControl(new OpenLayers.Control.MouseDefaults());
|
||||
this.addControl(new OpenLayers.Control.PanZoom());
|
||||
}
|
||||
|
||||
this.popups = new Array();
|
||||
|
||||
// always call map.destroy()
|
||||
Event.observe(window, 'unload',
|
||||
this.destroy.bindAsEventListener(this));
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
destroy:function() {
|
||||
if (this.layers != null) {
|
||||
for(var i=0; i< this.layers.length; i++) {
|
||||
this.layers[i].destroy();
|
||||
}
|
||||
this.layers = null;
|
||||
}
|
||||
if (this.controls != null) {
|
||||
for(var i=0; i< this.controls.length; i++) {
|
||||
this.controls[i].destroy();
|
||||
}
|
||||
this.controls = null;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Layer} layer
|
||||
*/
|
||||
addLayer: function (layer) {
|
||||
layer.setMap(this);
|
||||
layer.div.style.overflow = "";
|
||||
layer.div.style.zIndex = this.Z_INDEX_BASE['Layer'] + this.layers.length;
|
||||
|
||||
if (layer.viewPortLayer) {
|
||||
this.viewPortDiv.appendChild(layer.div);
|
||||
} else {
|
||||
this.layerContainerDiv.appendChild(layer.div);
|
||||
}
|
||||
this.layers.push(layer);
|
||||
|
||||
// hack hack hack - until we add a more robust layer switcher,
|
||||
// which is able to determine which layers are base layers and
|
||||
// which are not (and put baselayers in a radiobutton group and
|
||||
// other layers in checkboxes) this seems to be the most straight-
|
||||
// forward way of dealing with this.
|
||||
//
|
||||
if (layer.isBaseLayer()) {
|
||||
this.baseLayer = layer;
|
||||
}
|
||||
this.events.triggerEvent("addlayer");
|
||||
},
|
||||
|
||||
/** Removes a layer from the map by removing its visual element (the
|
||||
* layer.div property), then removing it from the map's internal list
|
||||
* of layers, setting the layer's map property to null.
|
||||
*
|
||||
* a "removelayer" event is triggered.
|
||||
*
|
||||
* very worthy of mention is that simply removing a layer from a map
|
||||
* will not cause the removal of any popups which may have been created
|
||||
* by the layer. this is due to the fact that it was decided at some
|
||||
* point that popups would not belong to layers. thus there is no way
|
||||
* for us to know here to which layer the popup belongs.
|
||||
*
|
||||
* A simple solution to this is simply to call destroy() on the layer.
|
||||
* the default OpenLayers.Layer class's destroy() function
|
||||
* automatically takes care to remove itself from whatever map it has
|
||||
* been attached to.
|
||||
*
|
||||
* The correct solution is for the layer itself to register an
|
||||
* event-handler on "removelayer" and when it is called, if it
|
||||
* recognizes itself as the layer being removed, then it cycles through
|
||||
* its own personal list of popups, removing them from the map.
|
||||
*
|
||||
* @param {OpenLayers.Layer} layer
|
||||
*/
|
||||
removeLayer: function(layer) {
|
||||
this.layerContainerDiv.removeChild(layer.div);
|
||||
this.layers.remove(layer);
|
||||
layer.map = null;
|
||||
this.events.triggerEvent("removelayer");
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {Array(OpenLayers.Layer)} layers
|
||||
*/
|
||||
addLayers: function (layers) {
|
||||
for (var i = 0; i < layers.length; i++) {
|
||||
this.addLayer(layers[i]);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Control} control
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
addControl: function (control, px) {
|
||||
control.map = this;
|
||||
this.controls.push(control);
|
||||
var div = control.draw(px);
|
||||
if (div) {
|
||||
div.style.zIndex = this.Z_INDEX_BASE['Control'] +
|
||||
this.controls.length;
|
||||
this.viewPortDiv.appendChild( div );
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Popup} popup
|
||||
*/
|
||||
addPopup: function(popup) {
|
||||
popup.map = this;
|
||||
this.popups.push(popup);
|
||||
var popupDiv = popup.draw();
|
||||
if (popupDiv) {
|
||||
popupDiv.style.zIndex = this.Z_INDEX_BASE['Popup'] +
|
||||
this.popups.length;
|
||||
this.layerContainerDiv.appendChild(popupDiv);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Popup} popup
|
||||
*/
|
||||
removePopup: function(popup) {
|
||||
this.popups.remove(popup);
|
||||
if (popup.div) {
|
||||
this.layerContainerDiv.removeChild(popup.div);
|
||||
}
|
||||
popup.map = null;
|
||||
},
|
||||
|
||||
/**
|
||||
* @return {float}
|
||||
*/
|
||||
getResolution: function () {
|
||||
// return degrees per pixel
|
||||
return this.maxResolution / Math.pow(2, this.zoom);
|
||||
},
|
||||
|
||||
/**
|
||||
* @return {int}
|
||||
*/
|
||||
getZoom: function () {
|
||||
return this.zoom;
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns {OpenLayers.Size}
|
||||
*/
|
||||
getSize: function () {
|
||||
return this.size;
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
updateSize: function() {
|
||||
this.size = new OpenLayers.Size(
|
||||
this.div.clientWidth, this.div.clientHeight);
|
||||
this.events.div.offsets = null;
|
||||
// Workaround for the fact that hidden elements return 0 for size.
|
||||
if (this.size.w == 0 && this.size.h == 0) {
|
||||
var dim = Element.getDimensions(this.div);
|
||||
this.size.w = dim.width;
|
||||
this.size.h = dim.height;
|
||||
}
|
||||
if (this.size.w == 0 && this.size.h == 0) {
|
||||
this.size.w = parseInt(this.div.style.width);
|
||||
this.size.h = parseInt(this.div.style.height);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @return {OpenLayers.LonLat}
|
||||
*/
|
||||
getCenter: function () {
|
||||
return this.center;
|
||||
},
|
||||
|
||||
/**
|
||||
* @return {OpenLayers.Bounds}
|
||||
*/
|
||||
getExtent: function () {
|
||||
if (this.center) {
|
||||
var res = this.getResolution();
|
||||
var size = this.getSize();
|
||||
var w_deg = size.w * res;
|
||||
var h_deg = size.h * res;
|
||||
return new OpenLayers.Bounds(
|
||||
this.center.lon - w_deg / 2,
|
||||
this.center.lat - h_deg / 2,
|
||||
this.center.lon + w_deg / 2,
|
||||
this.center.lat + h_deg / 2);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @return {OpenLayers.Bounds}
|
||||
*/
|
||||
getFullExtent: function () {
|
||||
return this.maxExtent;
|
||||
},
|
||||
|
||||
getZoomLevels: function() {
|
||||
return this.maxZoomLevel;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
*
|
||||
* @return {int}
|
||||
*/
|
||||
getZoomForExtent: function (bounds) {
|
||||
var size = this.getSize();
|
||||
var width = bounds.getWidth();
|
||||
var height = bounds.getHeight();
|
||||
var deg_per_pixel = (width > height ? width / size.w : height / size.h);
|
||||
var zoom = Math.log(this.maxResolution / deg_per_pixel) / Math.log(2);
|
||||
return Math.floor(Math.min(Math.max(zoom, 0), this.getZoomLevels()));
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} layerPx
|
||||
*
|
||||
* @returns px translated into view port pixel coordinates
|
||||
* @type OpenLayers.Pixel
|
||||
* @private
|
||||
*/
|
||||
getViewPortPxFromLayerPx:function(layerPx) {
|
||||
var viewPortPx = layerPx.copyOf();
|
||||
|
||||
viewPortPx.x += parseInt(this.layerContainerDiv.style.left);
|
||||
viewPortPx.y += parseInt(this.layerContainerDiv.style.top);
|
||||
|
||||
return viewPortPx;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} viewPortPx
|
||||
*
|
||||
* @returns px translated into view port pixel coordinates
|
||||
* @type OpenLayers.Pixel
|
||||
* @private
|
||||
*/
|
||||
getLayerPxFromViewPortPx:function(viewPortPx) {
|
||||
var layerPx = viewPortPx.copyOf();
|
||||
|
||||
layerPx.x -= parseInt(this.layerContainerDiv.style.left);
|
||||
layerPx.y -= parseInt(this.layerContainerDiv.style.top);
|
||||
|
||||
return layerPx;
|
||||
},
|
||||
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @return {OpenLayers.LonLat}
|
||||
*/
|
||||
getLonLatFromLayerPx: function (px) {
|
||||
//adjust for displacement of layerContainerDiv
|
||||
px = this.getViewPortPxFromLayerPx(px);
|
||||
return this.getLonLatFromViewPortPx(px);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} viewPortPx
|
||||
*
|
||||
* @returns An OpenLayers.LonLat which is the passed-in view port
|
||||
* OpenLayers.Pixel, translated into lon/lat given the
|
||||
* current extent and resolution
|
||||
* @type OpenLayers.LonLat
|
||||
* @private
|
||||
*/
|
||||
getLonLatFromViewPortPx: function (viewPortPx) {
|
||||
var center = this.getCenter(); //map center lon/lat
|
||||
var res = this.getResolution();
|
||||
var size = this.getSize();
|
||||
|
||||
var delta_x = viewPortPx.x - (size.w / 2);
|
||||
var delta_y = viewPortPx.y - (size.h / 2);
|
||||
|
||||
return new OpenLayers.LonLat(center.lon + delta_x * res ,
|
||||
center.lat - delta_y * res);
|
||||
},
|
||||
|
||||
// getLonLatFromPixel is a convenience function for the API
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} pixel
|
||||
*
|
||||
* @returns An OpenLayers.LonLat corresponding to the given
|
||||
* OpenLayers.Pixel, translated into lon/lat using the
|
||||
* current extent and resolution
|
||||
* @type OpenLayers.LonLat
|
||||
*/
|
||||
getLonLatFromPixel: function (px) {
|
||||
return this.getLonLatFromViewPortPx(px);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
*
|
||||
* @returns An OpenLayers.Pixel which is the passed-in OpenLayers.LonLat,
|
||||
* translated into layer pixels given the current extent
|
||||
* and resolution
|
||||
* @type OpenLayers.Pixel
|
||||
*/
|
||||
getLayerPxFromLonLat: function (lonlat) {
|
||||
//adjust for displacement of layerContainerDiv
|
||||
var px = this.getViewPortPxFromLonLat(lonlat);
|
||||
return this.getLayerPxFromViewPortPx(px);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
*
|
||||
* @returns An OpenLayers.Pixel which is the passed-in OpenLayers.LonLat,
|
||||
* translated into view port pixels given the current extent
|
||||
* and resolution
|
||||
* @type OpenLayers.Pixel
|
||||
* @private
|
||||
*/
|
||||
getViewPortPxFromLonLat: function (lonlat) {
|
||||
var resolution = this.getResolution();
|
||||
var extent = this.getExtent();
|
||||
return new OpenLayers.Pixel(
|
||||
Math.round(1/resolution * (lonlat.lon - extent.left)),
|
||||
Math.round(1/resolution * (extent.top - lonlat.lat))
|
||||
);
|
||||
},
|
||||
|
||||
// getLonLatFromPixel is a convenience function for the API
|
||||
/**
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
*
|
||||
* @returns An OpenLayers.Pixel corresponding to the OpenLayers.LonLat
|
||||
* translated into view port pixels using the current extent
|
||||
* and resolution
|
||||
* @type OpenLayers.Pixel
|
||||
*/
|
||||
getPixelFromLonLat: function (lonlat) {
|
||||
return this.getViewPortPxFromLonLat(lonlat);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
* @param {int} zoom
|
||||
*/
|
||||
setCenter: function (lonlat, zoom, minor) {
|
||||
if (this.center) { // otherwise there's nothing to move yet
|
||||
this.moveLayerContainer(lonlat);
|
||||
}
|
||||
this.center = lonlat.copyOf();
|
||||
var zoomChanged = null;
|
||||
if (zoom != null && zoom != this.zoom
|
||||
&& zoom >= 0 && zoom <= this.getZoomLevels()) {
|
||||
zoomChanged = (this.zoom == null ? 0 : this.zoom);
|
||||
this.zoom = zoom;
|
||||
}
|
||||
|
||||
if (!minor) this.events.triggerEvent("movestart");
|
||||
this.moveToNewExtent(zoomChanged, minor);
|
||||
if (!minor) this.events.triggerEvent("moveend");
|
||||
},
|
||||
|
||||
/**
|
||||
* ZOOM TO BOUNDS FUNCTION
|
||||
* @private
|
||||
*/
|
||||
moveToNewExtent: function (zoomChanged, minor) {
|
||||
if (zoomChanged != null) { // reset the layerContainerDiv's location
|
||||
this.layerContainerDiv.style.left = "0px";
|
||||
this.layerContainerDiv.style.top = "0px";
|
||||
|
||||
//redraw popups
|
||||
for (var i = 0; i < this.popups.length; i++) {
|
||||
this.popups[i].updatePosition();
|
||||
}
|
||||
|
||||
}
|
||||
var bounds = this.getExtent();
|
||||
for (var i = 0; i < this.layers.length; i++) {
|
||||
this.layers[i].moveTo(bounds, (zoomChanged != null), minor);
|
||||
}
|
||||
this.events.triggerEvent("move");
|
||||
if (zoomChanged != null)
|
||||
this.events.triggerEvent("zoomend",
|
||||
{oldZoom: zoomChanged, newZoom: this.zoom});
|
||||
},
|
||||
|
||||
/**
|
||||
* zoomIn
|
||||
* Increase zoom level by one.
|
||||
* @param {int} zoom
|
||||
*/
|
||||
zoomIn: function() {
|
||||
if (this.zoom != null && this.zoom <= this.getZoomLevels()) {
|
||||
this.zoomTo( this.zoom += 1 );
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* zoomTo
|
||||
* Set Zoom To int
|
||||
* @param {int} zoom
|
||||
*/
|
||||
zoomTo: function(zoom) {
|
||||
if (zoom >= 0 && zoom <= this.getZoomLevels()) {
|
||||
var oldZoom = this.zoom;
|
||||
this.zoom = zoom;
|
||||
this.moveToNewExtent(oldZoom);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* zoomOut
|
||||
* Decrease zoom level by one.
|
||||
* @param {int} zoom
|
||||
*/
|
||||
zoomOut: function() {
|
||||
if (this.zoom != null && this.zoom > 0) {
|
||||
this.zoomTo( this.zoom - 1 );
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* zoomToFullExtent
|
||||
* Zoom to the full extent and recenter.
|
||||
*/
|
||||
zoomToFullExtent: function() {
|
||||
var fullExtent = this.getFullExtent();
|
||||
this.setCenter(
|
||||
new OpenLayers.LonLat((fullExtent.left+fullExtent.right)/2,
|
||||
(fullExtent.bottom+fullExtent.top)/2),
|
||||
this.getZoomForExtent(fullExtent)
|
||||
);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
* @private
|
||||
*/
|
||||
moveLayerContainer: function (lonlat) {
|
||||
var container = this.layerContainerDiv;
|
||||
var resolution = this.getResolution();
|
||||
|
||||
var deltaX = Math.round((this.center.lon - lonlat.lon) / resolution);
|
||||
var deltaY = Math.round((this.center.lat - lonlat.lat) / resolution);
|
||||
|
||||
var offsetLeft = parseInt(container.style.left);
|
||||
var offsetTop = parseInt(container.style.top);
|
||||
|
||||
container.style.left = (offsetLeft + deltaX) + "px";
|
||||
container.style.top = (offsetTop - deltaY) + "px";
|
||||
},
|
||||
|
||||
CLASS_NAME: "OpenLayers.Map"
|
||||
};
|
||||
109
public/lib/OpenLayers/Marker.js
Normal file
109
public/lib/OpenLayers/Marker.js
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Marker = Class.create();
|
||||
OpenLayers.Marker.prototype = {
|
||||
|
||||
/** @type OpenLayers.Icon */
|
||||
icon: null,
|
||||
|
||||
/** location of object
|
||||
* @type OpenLayers.LonLat */
|
||||
lonlat: null,
|
||||
|
||||
/** @type OpenLayers.Events*/
|
||||
events: null,
|
||||
|
||||
/** @type OpenLayers.Map */
|
||||
map: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {OpenLayers.Icon} icon
|
||||
* @param {OpenLayers.LonLat lonlat
|
||||
*/
|
||||
initialize: function(lonlat, icon) {
|
||||
this.lonlat = lonlat;
|
||||
this.icon = (icon) ? icon : OpenLayers.Marker.defaultIcon();
|
||||
|
||||
this.events = new OpenLayers.Events(this, this.icon.imageDiv, null);
|
||||
},
|
||||
|
||||
destroy: function() {
|
||||
this.map = null;
|
||||
|
||||
if (this.icon != null) {
|
||||
this.icon.destroy();
|
||||
this.icon = null;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @return A new DOM Image with this marker´s icon set at the
|
||||
* location passed-in
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function(px) {
|
||||
return this.icon.draw(px);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
moveTo: function (px) {
|
||||
if ((px != null) && (this.icon != null)) {
|
||||
this.icon.moveTo(px);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns Whether or not the marker is currently visible on screen.
|
||||
* @type Boolean
|
||||
*/
|
||||
onScreen:function() {
|
||||
|
||||
var onScreen = false;
|
||||
if (this.map) {
|
||||
var screenBounds = this.map.getExtent();
|
||||
onScreen = screenBounds.contains(this.lonlat.lon, this.lonlat.lat);
|
||||
}
|
||||
return onScreen;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {float} inflate
|
||||
*/
|
||||
inflate: function(inflate) {
|
||||
if (this.icon) {
|
||||
var newSize = new OpenLayers.Size(this.icon.size.w * inflate,
|
||||
this.icon.size.h * inflate);
|
||||
this.icon.setSize(newSize);
|
||||
}
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Marker"
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @returns A default OpenLayers.Icon to use for a marker
|
||||
* @type OpenLayers.Icon
|
||||
*/
|
||||
OpenLayers.Marker.defaultIcon = function() {
|
||||
var url = OpenLayers.Util.getImagesLocation() + "marker.png";
|
||||
var size = new OpenLayers.Size(21, 25);
|
||||
var calculateOffset = function(size) {
|
||||
return new OpenLayers.Pixel(-(size.w/2), -size.h);
|
||||
};
|
||||
|
||||
return new OpenLayers.Icon(url, size, null, calculateOffset);
|
||||
};
|
||||
|
||||
|
||||
232
public/lib/OpenLayers/Popup.js
Normal file
232
public/lib/OpenLayers/Popup.js
Normal file
|
|
@ -0,0 +1,232 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Popup = Class.create();
|
||||
|
||||
OpenLayers.Popup.count = 0;
|
||||
OpenLayers.Popup.WIDTH = 200;
|
||||
OpenLayers.Popup.HEIGHT = 200;
|
||||
OpenLayers.Popup.COLOR = "white";
|
||||
OpenLayers.Popup.OPACITY = 1;
|
||||
OpenLayers.Popup.BORDER = "0px";
|
||||
|
||||
OpenLayers.Popup.prototype = {
|
||||
|
||||
/** @type OpenLayers.Events*/
|
||||
events: null,
|
||||
|
||||
/** @type String */
|
||||
id: "",
|
||||
|
||||
/** @type OpenLayers.LonLat */
|
||||
lonlat: null,
|
||||
|
||||
/** @type DOMElement */
|
||||
div: null,
|
||||
|
||||
/** @type OpenLayers.Size*/
|
||||
size: null,
|
||||
|
||||
/** @type String */
|
||||
contentHTML: "",
|
||||
|
||||
/** @type String */
|
||||
backgroundColor: "",
|
||||
|
||||
/** @type float */
|
||||
opacity: "",
|
||||
|
||||
/** @type String */
|
||||
border: "",
|
||||
|
||||
/** this gets set in Map.js when the popup is added to the map
|
||||
* @type OpenLayers.Map */
|
||||
map: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} id
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
* @param {OpenLayers.Size} size
|
||||
* @param {String} contentHTML
|
||||
*/
|
||||
initialize:function(id, lonlat, size, contentHTML) {
|
||||
OpenLayers.Popup.count += 1;
|
||||
this.id = (id != null) ? id : "Popup" + OpenLayers.Popup.count;
|
||||
this.lonlat = lonlat;
|
||||
this.size = (size != null) ? size
|
||||
: new OpenLayers.Size(
|
||||
OpenLayers.Popup.WIDTH,
|
||||
OpenLayers.Popup.HEIGHT);
|
||||
if (contentHTML != null) {
|
||||
this.contentHTML = contentHTML;
|
||||
}
|
||||
this.backgroundColor = OpenLayers.Popup.COLOR;
|
||||
this.opacity = OpenLayers.Popup.OPACITY;
|
||||
this.border = OpenLayers.Popup.BORDER;
|
||||
|
||||
this.div = OpenLayers.Util.createDiv(this.id + "_div", null, null,
|
||||
null, null, null, "hidden");
|
||||
|
||||
this.events = new OpenLayers.Events(this, this.div, null);
|
||||
},
|
||||
|
||||
/**
|
||||
*/
|
||||
destroy: function() {
|
||||
if (this.map != null) {
|
||||
this.map.removePopup(this);
|
||||
}
|
||||
this.div = null;
|
||||
this.map = null;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns Reference to a div that contains the drawn popup
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function(px) {
|
||||
if (px == null) {
|
||||
if ((this.lonlat != null) && (this.map != null)) {
|
||||
px = this.map.getLayerPxFromLonLat(this.lonlat);
|
||||
}
|
||||
}
|
||||
|
||||
this.setSize();
|
||||
this.setBackgroundColor();
|
||||
this.setOpacity();
|
||||
this.setBorder();
|
||||
this.setContentHTML();
|
||||
this.moveTo(px);
|
||||
|
||||
return this.div;
|
||||
},
|
||||
|
||||
/**
|
||||
* if the popup has a lonlat and its map members set,
|
||||
* then have it move itself to its proper position
|
||||
*/
|
||||
updatePosition: function() {
|
||||
if ((this.lonlat) && (this.map)) {
|
||||
var px = this.map.getLayerPxFromLonLat(this.lonlat);
|
||||
this.moveTo(px);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
moveTo: function(px) {
|
||||
if ((px != null) && (this.div != null)) {
|
||||
this.div.style.left = px.x + "px";
|
||||
this.div.style.top = px.y + "px";
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @returns Boolean indicating whether or not the popup is visible
|
||||
* @type Boolean
|
||||
*/
|
||||
visible: function() {
|
||||
return Element.visible(this.div);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
toggle: function() {
|
||||
Element.toggle(this.div);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
show: function() {
|
||||
Element.show(this.div);
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
hide: function() {
|
||||
Element.hide(this.div);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
setSize:function(size) {
|
||||
if (size != undefined) {
|
||||
this.size = size;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
this.div.style.width = this.size.w;
|
||||
this.div.style.height = this.size.h;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} color
|
||||
*/
|
||||
setBackgroundColor:function(color) {
|
||||
if (color != undefined) {
|
||||
this.backgroundColor = color;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
this.div.style.backgroundColor = this.backgroundColor;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {float} opacity
|
||||
*/
|
||||
setOpacity:function(opacity) {
|
||||
if (opacity != undefined) {
|
||||
this.opacity = opacity;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
// for Mozilla and Safari
|
||||
this.div.style.opacity = this.opacity;
|
||||
|
||||
// for IE
|
||||
this.div.style.filter = 'alpha(opacity=' + this.opacity*100 + ')';
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {int} border
|
||||
*/
|
||||
setBorder:function(border) {
|
||||
if (border != undefined) {
|
||||
this.border = border;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
this.div.style.border = this.border;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} contentHTML
|
||||
*/
|
||||
setContentHTML:function(contentHTML) {
|
||||
if (contentHTML != null) {
|
||||
this.contentHTML = contentHTML;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
this.div.innerHTML = this.contentHTML;
|
||||
}
|
||||
},
|
||||
|
||||
CLASS_NAME: "OpenLayers.Popup"
|
||||
};
|
||||
125
public/lib/OpenLayers/Popup/Anchored.js
Normal file
125
public/lib/OpenLayers/Popup/Anchored.js
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Popup.js
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Popup.Anchored = Class.create();
|
||||
OpenLayers.Popup.Anchored.prototype =
|
||||
Object.extend( new OpenLayers.Popup(), {
|
||||
|
||||
/** "lr", "ll", "tr", "tl" - relative position of the popup.
|
||||
* @type String */
|
||||
relativePosition: null,
|
||||
|
||||
/** Object which must have expose a 'size' (OpenLayers.Size) and
|
||||
* 'offset' (OpenLayers.Pixel)
|
||||
* @type Object */
|
||||
anchor: null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} id
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
* @param {OpenLayers.Size} size
|
||||
* @param {String} contentHTML
|
||||
* @param {Object} anchor Object which must expose a
|
||||
* - 'size' (OpenLayers.Size) and
|
||||
* - 'offset' (OpenLayers.Pixel)
|
||||
* (this is generally an OpenLayers.Icon)
|
||||
*/
|
||||
initialize:function(id, lonlat, size, contentHTML, anchor) {
|
||||
var newArguments = new Array(id, lonlat, size, contentHTML);
|
||||
OpenLayers.Popup.prototype.initialize.apply(this, newArguments);
|
||||
|
||||
this.anchor = (anchor != null) ? anchor
|
||||
: { size: new OpenLayers.Size(0,0),
|
||||
offset: new OpenLayers.Pixel(0,0)};
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns Reference to a div that contains the drawn popup
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function(px) {
|
||||
if (px == null) {
|
||||
if ((this.lonlat != null) && (this.map != null)) {
|
||||
px = this.map.getLayerPxFromLonLat(this.lonlat);
|
||||
}
|
||||
}
|
||||
|
||||
//calculate relative position
|
||||
this.relativePosition = this.calculateRelativePosition(px);
|
||||
|
||||
return OpenLayers.Popup.prototype.draw.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns The relative position ("br" "tr" "tl "bl") at which the popup
|
||||
* should be placed
|
||||
* @type String
|
||||
*/
|
||||
calculateRelativePosition:function(px) {
|
||||
var lonlat = this.map.getLonLatFromLayerPx(px);
|
||||
|
||||
var extent = this.map.getExtent();
|
||||
var quadrant = extent.determineQuadrant(lonlat);
|
||||
|
||||
return OpenLayers.Bounds.oppositeQuadrant(quadrant);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*/
|
||||
moveTo: function(px) {
|
||||
|
||||
var newPx = this.calculateNewPx(px);
|
||||
|
||||
var newArguments = new Array(newPx);
|
||||
OpenLayers.Popup.prototype.moveTo.apply(this, newArguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
setSize:function(size) {
|
||||
OpenLayers.Popup.prototype.setSize.apply(this, arguments);
|
||||
|
||||
if ((this.lonlat) && (this.map)) {
|
||||
var px = this.map.getLayerPxFromLonLat(this.lonlat);
|
||||
this.moveTo(px);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns The the new px position of the popup on the screen
|
||||
* relative to the passed-in px
|
||||
* @type OpenLayers.Pixel
|
||||
*/
|
||||
calculateNewPx:function(px) {
|
||||
var newPx = px.offset(this.anchor.offset);
|
||||
|
||||
var top = (this.relativePosition.charAt(0) == 't');
|
||||
newPx.y += (top) ? -this.size.h : this.anchor.size.h;
|
||||
|
||||
var left = (this.relativePosition.charAt(1) == 'l');
|
||||
newPx.x += (left) ? -this.size.w : this.anchor.size.w;
|
||||
|
||||
return newPx;
|
||||
},
|
||||
|
||||
CLASS_NAME: "OpenLayers.Popup.Anchored"
|
||||
});
|
||||
183
public/lib/OpenLayers/Popup/AnchoredBubble.js
Normal file
183
public/lib/OpenLayers/Popup/AnchoredBubble.js
Normal file
|
|
@ -0,0 +1,183 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Popup/Anchored.js
|
||||
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Popup.AnchoredBubble = Class.create();
|
||||
|
||||
//Border space for the rico corners
|
||||
OpenLayers.Popup.AnchoredBubble.CORNER_SIZE = 5;
|
||||
|
||||
OpenLayers.Popup.AnchoredBubble.prototype =
|
||||
Object.extend( new OpenLayers.Popup.Anchored(), {
|
||||
|
||||
/** @type DOMElement */
|
||||
contentDiv:null,
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {String} id
|
||||
* @param {OpenLayers.LonLat} lonlat
|
||||
* @param {OpenLayers.Size} size
|
||||
* @param {String} contentHTML
|
||||
* @param {Object} anchor Object which must expose a
|
||||
* - 'size' (OpenLayers.Size) and
|
||||
* - 'offset' (OpenLayers.Pixel)
|
||||
* (this is generally an OpenLayers.Icon)
|
||||
*/
|
||||
initialize:function(id, lonlat, size, contentHTML, anchor) {
|
||||
OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Pixel} px
|
||||
*
|
||||
* @returns Reference to a div that contains the drawn popup
|
||||
* @type DOMElement
|
||||
*/
|
||||
draw: function(px) {
|
||||
|
||||
OpenLayers.Popup.Anchored.prototype.draw.apply(this, arguments);
|
||||
|
||||
// make the content Div
|
||||
var contentSize = this.size.copyOf();
|
||||
contentSize.h -= (2 * OpenLayers.Popup.AnchoredBubble.CORNER_SIZE);
|
||||
|
||||
var id = this.div.id + "-contentDiv";
|
||||
this.contentDiv = OpenLayers.Util.createDiv(id, null, contentSize,
|
||||
null, "relative", null,
|
||||
"hidden");
|
||||
this.div.appendChild(this.contentDiv);
|
||||
this.setContentHTML();
|
||||
|
||||
this.setRicoCorners(true);
|
||||
|
||||
//set the popup color and opacity
|
||||
this.setBackgroundColor();
|
||||
this.setOpacity();
|
||||
|
||||
return this.div;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
setSize:function(size) {
|
||||
OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments);
|
||||
|
||||
if (this.contentDiv != null) {
|
||||
|
||||
var contentSize = this.size.copyOf();
|
||||
contentSize.h -= (2 * OpenLayers.Popup.AnchoredBubble.CORNER_SIZE);
|
||||
|
||||
this.contentDiv.style.height = contentSize.h + "px";
|
||||
|
||||
//size has changed - must redo corners
|
||||
this.setRicoCorners(false);
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} color
|
||||
*/
|
||||
setBackgroundColor:function(color) {
|
||||
if (color != undefined) {
|
||||
this.backgroundColor = color;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
if (this.contentDiv != null) {
|
||||
this.div.style.background = "transparent";
|
||||
Rico.Corner.changeColor(this.contentDiv, this.backgroundColor);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {float} opacity
|
||||
*/
|
||||
setOpacity:function(opacity) {
|
||||
if (opacity != undefined) {
|
||||
this.opacity = opacity;
|
||||
}
|
||||
|
||||
if (this.div != null) {
|
||||
if (this.contentDiv != null) {
|
||||
Rico.Corner.changeOpacity(this.contentDiv, this.opacity);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/** Bubble Popups can not have a border
|
||||
*
|
||||
* @param {int} border
|
||||
*/
|
||||
setBorder:function(border) {
|
||||
this.border = 0;
|
||||
},
|
||||
|
||||
/**
|
||||
* @param {String} contentHTML
|
||||
*/
|
||||
setContentHTML:function(contentHTML) {
|
||||
if (contentHTML != null) {
|
||||
this.contentHTML = contentHTML;
|
||||
}
|
||||
|
||||
if (this.contentDiv != null) {
|
||||
this.contentDiv.innerHTML = this.contentHTML;
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @param {Boolean} firstTime Is this the first time the corners are being
|
||||
* rounded?
|
||||
*
|
||||
* update the rico corners according to the popup's
|
||||
* current relative postion
|
||||
*/
|
||||
setRicoCorners:function(firstTime) {
|
||||
|
||||
var corners = this.getCornersToRound(this.relativePosition);
|
||||
var options = {corners: corners,
|
||||
color: this.backgroundColor,
|
||||
bgColor: "transparent",
|
||||
blend: false};
|
||||
|
||||
if (firstTime) {
|
||||
Rico.Corner.round(this.div, options);
|
||||
} else {
|
||||
Rico.Corner.reRound(this.contentDiv, options);
|
||||
//set the popup color and opacity
|
||||
this.setBackgroundColor();
|
||||
this.setOpacity();
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* @private
|
||||
*
|
||||
* @returns The proper corners string ("tr tl bl br") for rico
|
||||
* to round
|
||||
* @type String
|
||||
*/
|
||||
getCornersToRound:function() {
|
||||
|
||||
var corners = ['tl', 'tr', 'bl', 'br'];
|
||||
|
||||
//we want to round all the corners _except_ the opposite one.
|
||||
var corner = OpenLayers.Bounds.oppositeQuadrant(this.relativePosition);
|
||||
corners.remove(corner);
|
||||
|
||||
return corners.join(" ");
|
||||
},
|
||||
|
||||
CLASS_NAME: "OpenLayers.Popup.AnchoredBubble"
|
||||
});
|
||||
5
public/lib/OpenLayers/SingleFile.js
Normal file
5
public/lib/OpenLayers/SingleFile.js
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
_OPENLAYERS_SFL_=true
|
||||
|
||||
85
public/lib/OpenLayers/Tile.js
Normal file
85
public/lib/OpenLayers/Tile.js
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
/*
|
||||
* OpenLayers.Tile
|
||||
*
|
||||
* @class This is a class designed to designate a single tile, however
|
||||
* it is explicitly designed to do relatively little. Tiles store information
|
||||
* about themselves -- such as the URL that they are related to, and their
|
||||
* size - but do not add themselves to the layer div automatically, for
|
||||
* example.
|
||||
*/
|
||||
OpenLayers.Tile = Class.create();
|
||||
OpenLayers.Tile.prototype = {
|
||||
|
||||
/** @type OpenLayers.Layer */
|
||||
layer: null,
|
||||
|
||||
/** @type String url of the request */
|
||||
url:null,
|
||||
|
||||
/** @type OpenLayers.Bounds */
|
||||
bounds:null,
|
||||
|
||||
/** @type OpenLayers.Size */
|
||||
size:null,
|
||||
|
||||
/** Top Left pixel of the tile
|
||||
* @type OpenLayers.Pixel */
|
||||
position:null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {OpenLayers.Layer} layer
|
||||
* @param {OpenLayers.Pixel} position
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {String} url
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
initialize: function(layer, position, bounds, url, size) {
|
||||
if (arguments.length > 0) {
|
||||
this.layer = layer;
|
||||
this.position = position;
|
||||
this.bounds = bounds;
|
||||
this.url = url;
|
||||
this.size = size;
|
||||
}
|
||||
},
|
||||
|
||||
/** nullify references to prevent circular references and memory leaks
|
||||
*/
|
||||
destroy:function() {
|
||||
this.layer = null;
|
||||
this.bounds = null;
|
||||
this.size = null;
|
||||
},
|
||||
|
||||
/**
|
||||
*/
|
||||
draw:function() {
|
||||
|
||||
// HACK HACK - should we make it a standard to put this sort of warning
|
||||
// message in functions that are supposed to be overridden?
|
||||
//
|
||||
// Log.warn(this.CLASS_NAME + ": draw() not implemented");
|
||||
|
||||
},
|
||||
|
||||
/** remove this tile from the ds
|
||||
*/
|
||||
remove:function() {
|
||||
},
|
||||
|
||||
/**
|
||||
* @type OpenLayers.Pixel
|
||||
*/
|
||||
getPosition: function() {
|
||||
return this.position;
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Tile"
|
||||
};
|
||||
|
||||
60
public/lib/OpenLayers/Tile/Image.js
Normal file
60
public/lib/OpenLayers/Tile/Image.js
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Tile.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Tile.Image = Class.create();
|
||||
OpenLayers.Tile.Image.prototype =
|
||||
Object.extend( new OpenLayers.Tile(), {
|
||||
|
||||
/** @type DOMElement img */
|
||||
imgDiv:null,
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {OpenLayers.Grid} layer
|
||||
* @param {OpenLayers.Pixel} position
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {String} url
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
initialize: function(layer, position, bounds, url, size) {
|
||||
OpenLayers.Tile.prototype.initialize.apply(this, arguments);
|
||||
},
|
||||
|
||||
destroy: function() {
|
||||
if ((this.imgDiv != null) && (this.imgDiv.parentNode == this.layer.div)) {
|
||||
this.layer.div.removeChild(this.imgDiv);
|
||||
}
|
||||
this.imgDiv = null;
|
||||
OpenLayers.Tile.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
*/
|
||||
draw:function(transparent) {
|
||||
if (false) { // don't actually use the alpha PNG hack right now
|
||||
// it has a fiercely bad effect on IE6's performance
|
||||
// if (transparent) {
|
||||
this.imgDiv = OpenLayers.Util.createAlphaImageDiv(null,
|
||||
this.position,
|
||||
this.size,
|
||||
this.url,
|
||||
"absolute");
|
||||
} else {
|
||||
this.imgDiv = OpenLayers.Util.createImage(null,
|
||||
this.position,
|
||||
this.size,
|
||||
this.url,
|
||||
"absolute");
|
||||
}
|
||||
this.layer.div.appendChild(this.imgDiv);
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Tile.Image"
|
||||
}
|
||||
);
|
||||
100
public/lib/OpenLayers/Tile/WFS.js
Normal file
100
public/lib/OpenLayers/Tile/WFS.js
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
/* Copyright (c) 2006 MetaCarta, Inc., published under the BSD license.
|
||||
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the full
|
||||
* text of the license. */
|
||||
// @require: OpenLayers/Tile.js
|
||||
/**
|
||||
* @class
|
||||
*/
|
||||
OpenLayers.Tile.WFS = Class.create();
|
||||
OpenLayers.Tile.WFS.prototype =
|
||||
Object.extend( new OpenLayers.Tile(), {
|
||||
|
||||
/** @type Array(OpenLayers.Feature)*/
|
||||
features: null,
|
||||
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
*
|
||||
* @param {OpenLayers.Layer} layer
|
||||
* @param {OpenLayers.Pixel} position
|
||||
* @param {OpenLayers.Bounds} bounds
|
||||
* @param {String} url
|
||||
* @param {OpenLayers.Size} size
|
||||
*/
|
||||
initialize: function(layer, position, bounds, url, size) {
|
||||
OpenLayers.Tile.prototype.initialize.apply(this, arguments);
|
||||
|
||||
this.features = new Array();
|
||||
},
|
||||
|
||||
/**
|
||||
*
|
||||
*/
|
||||
destroy: function() {
|
||||
for(var i=0; i < this.features.length; i++) {
|
||||
this.features[i].destroy();
|
||||
}
|
||||
OpenLayers.Tile.prototype.destroy.apply(this, arguments);
|
||||
},
|
||||
|
||||
/**
|
||||
*/
|
||||
draw:function() {
|
||||
this.loadFeaturesForRegion(this.requestSuccess);
|
||||
},
|
||||
|
||||
|
||||
/** get the full request string from the ds and the tile params
|
||||
* and call the AJAX loadURL().
|
||||
*
|
||||
* input are function pointers for what to do on success and failure.
|
||||
*
|
||||
* @param {function} success
|
||||
* @param {function} failure
|
||||
*/
|
||||
loadFeaturesForRegion:function(success, failure) {
|
||||
|
||||
if (!this.loaded) {
|
||||
|
||||
if (this.url != "") {
|
||||
|
||||
// TODO: Hmmm, this stops multiple loads of the data when a
|
||||
// result isn't immediately retrieved, but it's hacky.
|
||||
// Do it better.
|
||||
this.loaded = true;
|
||||
OpenLayers.loadURL(this.url, null, this, success, failure);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/** Return from AJAX request
|
||||
*
|
||||
* @param {} request
|
||||
*/
|
||||
requestSuccess:function(request) {
|
||||
var doc = request.responseXML;
|
||||
|
||||
if (!doc || request.fileType!="XML") {
|
||||
doc = OpenLayers.parseXMLString(request.responseText);
|
||||
}
|
||||
|
||||
var resultFeatures = doc.getElementsByTagName("featureMember");
|
||||
|
||||
//clear old featureList
|
||||
this.features = new Array();
|
||||
|
||||
for (var i=0; i < resultFeatures.length; i++) {
|
||||
|
||||
var feature = new this.layer.featureClass(this.layer,
|
||||
resultFeatures[i]);
|
||||
this.features.append(feature);
|
||||
}
|
||||
|
||||
},
|
||||
|
||||
/** @final @type String */
|
||||
CLASS_NAME: "OpenLayers.Tile.WFS"
|
||||
}
|
||||
);
|
||||
|
||||
1010
public/lib/OpenLayers/Util.js
Normal file
1010
public/lib/OpenLayers/Util.js
Normal file
File diff suppressed because it is too large
Load diff
1781
public/lib/Prototype.js
Normal file
1781
public/lib/Prototype.js
Normal file
File diff suppressed because it is too large
Load diff
232
public/lib/Rico/Color.js
Normal file
232
public/lib/Rico/Color.js
Normal file
|
|
@ -0,0 +1,232 @@
|
|||
Rico.Color = Class.create();
|
||||
|
||||
Rico.Color.prototype = {
|
||||
|
||||
initialize: function(red, green, blue) {
|
||||
this.rgb = { r: red, g : green, b : blue };
|
||||
},
|
||||
|
||||
setRed: function(r) {
|
||||
this.rgb.r = r;
|
||||
},
|
||||
|
||||
setGreen: function(g) {
|
||||
this.rgb.g = g;
|
||||
},
|
||||
|
||||
setBlue: function(b) {
|
||||
this.rgb.b = b;
|
||||
},
|
||||
|
||||
setHue: function(h) {
|
||||
|
||||
// get an HSB model, and set the new hue...
|
||||
var hsb = this.asHSB();
|
||||
hsb.h = h;
|
||||
|
||||
// convert back to RGB...
|
||||
this.rgb = Rico.Color.HSBtoRGB(hsb.h, hsb.s, hsb.b);
|
||||
},
|
||||
|
||||
setSaturation: function(s) {
|
||||
// get an HSB model, and set the new hue...
|
||||
var hsb = this.asHSB();
|
||||
hsb.s = s;
|
||||
|
||||
// convert back to RGB and set values...
|
||||
this.rgb = Rico.Color.HSBtoRGB(hsb.h, hsb.s, hsb.b);
|
||||
},
|
||||
|
||||
setBrightness: function(b) {
|
||||
// get an HSB model, and set the new hue...
|
||||
var hsb = this.asHSB();
|
||||
hsb.b = b;
|
||||
|
||||
// convert back to RGB and set values...
|
||||
this.rgb = Rico.Color.HSBtoRGB( hsb.h, hsb.s, hsb.b );
|
||||
},
|
||||
|
||||
darken: function(percent) {
|
||||
var hsb = this.asHSB();
|
||||
this.rgb = Rico.Color.HSBtoRGB(hsb.h, hsb.s, Math.max(hsb.b - percent,0));
|
||||
},
|
||||
|
||||
brighten: function(percent) {
|
||||
var hsb = this.asHSB();
|
||||
this.rgb = Rico.Color.HSBtoRGB(hsb.h, hsb.s, Math.min(hsb.b + percent,1));
|
||||
},
|
||||
|
||||
blend: function(other) {
|
||||
this.rgb.r = Math.floor((this.rgb.r + other.rgb.r)/2);
|
||||
this.rgb.g = Math.floor((this.rgb.g + other.rgb.g)/2);
|
||||
this.rgb.b = Math.floor((this.rgb.b + other.rgb.b)/2);
|
||||
},
|
||||
|
||||
isBright: function() {
|
||||
var hsb = this.asHSB();
|
||||
return this.asHSB().b > 0.5;
|
||||
},
|
||||
|
||||
isDark: function() {
|
||||
return ! this.isBright();
|
||||
},
|
||||
|
||||
asRGB: function() {
|
||||
return "rgb(" + this.rgb.r + "," + this.rgb.g + "," + this.rgb.b + ")";
|
||||
},
|
||||
|
||||
asHex: function() {
|
||||
return "#" + this.rgb.r.toColorPart() + this.rgb.g.toColorPart() + this.rgb.b.toColorPart();
|
||||
},
|
||||
|
||||
asHSB: function() {
|
||||
return Rico.Color.RGBtoHSB(this.rgb.r, this.rgb.g, this.rgb.b);
|
||||
},
|
||||
|
||||
toString: function() {
|
||||
return this.asHex();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
Rico.Color.createFromHex = function(hexCode) {
|
||||
if(hexCode.length==4) {
|
||||
var shortHexCode = hexCode;
|
||||
var hexCode = '#';
|
||||
for(var i=1;i<4;i++) hexCode += (shortHexCode.charAt(i) +
|
||||
shortHexCode.charAt(i));
|
||||
}
|
||||
if ( hexCode.indexOf('#') == 0 )
|
||||
hexCode = hexCode.substring(1);
|
||||
var red = hexCode.substring(0,2);
|
||||
var green = hexCode.substring(2,4);
|
||||
var blue = hexCode.substring(4,6);
|
||||
return new Rico.Color( parseInt(red,16), parseInt(green,16), parseInt(blue,16) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Factory method for creating a color from the background of
|
||||
* an HTML element.
|
||||
*/
|
||||
Rico.Color.createColorFromBackground = function(elem) {
|
||||
|
||||
var actualColor = RicoUtil.getElementsComputedStyle($(elem), "backgroundColor", "background-color");
|
||||
|
||||
if ( actualColor == "transparent" && elem.parentNode )
|
||||
return Rico.Color.createColorFromBackground(elem.parentNode);
|
||||
|
||||
if ( actualColor == null )
|
||||
return new Rico.Color(255,255,255);
|
||||
|
||||
if ( actualColor.indexOf("rgb(") == 0 ) {
|
||||
var colors = actualColor.substring(4, actualColor.length - 1 );
|
||||
var colorArray = colors.split(",");
|
||||
return new Rico.Color( parseInt( colorArray[0] ),
|
||||
parseInt( colorArray[1] ),
|
||||
parseInt( colorArray[2] ) );
|
||||
|
||||
}
|
||||
else if ( actualColor.indexOf("#") == 0 ) {
|
||||
return Rico.Color.createFromHex(actualColor);
|
||||
}
|
||||
else
|
||||
return new Rico.Color(255,255,255);
|
||||
}
|
||||
|
||||
Rico.Color.HSBtoRGB = function(hue, saturation, brightness) {
|
||||
|
||||
var red = 0;
|
||||
var green = 0;
|
||||
var blue = 0;
|
||||
|
||||
if (saturation == 0) {
|
||||
red = parseInt(brightness * 255.0 + 0.5);
|
||||
green = red;
|
||||
blue = red;
|
||||
}
|
||||
else {
|
||||
var h = (hue - Math.floor(hue)) * 6.0;
|
||||
var f = h - Math.floor(h);
|
||||
var p = brightness * (1.0 - saturation);
|
||||
var q = brightness * (1.0 - saturation * f);
|
||||
var t = brightness * (1.0 - (saturation * (1.0 - f)));
|
||||
|
||||
switch (parseInt(h)) {
|
||||
case 0:
|
||||
red = (brightness * 255.0 + 0.5);
|
||||
green = (t * 255.0 + 0.5);
|
||||
blue = (p * 255.0 + 0.5);
|
||||
break;
|
||||
case 1:
|
||||
red = (q * 255.0 + 0.5);
|
||||
green = (brightness * 255.0 + 0.5);
|
||||
blue = (p * 255.0 + 0.5);
|
||||
break;
|
||||
case 2:
|
||||
red = (p * 255.0 + 0.5);
|
||||
green = (brightness * 255.0 + 0.5);
|
||||
blue = (t * 255.0 + 0.5);
|
||||
break;
|
||||
case 3:
|
||||
red = (p * 255.0 + 0.5);
|
||||
green = (q * 255.0 + 0.5);
|
||||
blue = (brightness * 255.0 + 0.5);
|
||||
break;
|
||||
case 4:
|
||||
red = (t * 255.0 + 0.5);
|
||||
green = (p * 255.0 + 0.5);
|
||||
blue = (brightness * 255.0 + 0.5);
|
||||
break;
|
||||
case 5:
|
||||
red = (brightness * 255.0 + 0.5);
|
||||
green = (p * 255.0 + 0.5);
|
||||
blue = (q * 255.0 + 0.5);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return { r : parseInt(red), g : parseInt(green) , b : parseInt(blue) };
|
||||
}
|
||||
|
||||
Rico.Color.RGBtoHSB = function(r, g, b) {
|
||||
|
||||
var hue;
|
||||
var saturation;
|
||||
var brightness;
|
||||
|
||||
var cmax = (r > g) ? r : g;
|
||||
if (b > cmax)
|
||||
cmax = b;
|
||||
|
||||
var cmin = (r < g) ? r : g;
|
||||
if (b < cmin)
|
||||
cmin = b;
|
||||
|
||||
brightness = cmax / 255.0;
|
||||
if (cmax != 0)
|
||||
saturation = (cmax - cmin)/cmax;
|
||||
else
|
||||
saturation = 0;
|
||||
|
||||
if (saturation == 0)
|
||||
hue = 0;
|
||||
else {
|
||||
var redc = (cmax - r)/(cmax - cmin);
|
||||
var greenc = (cmax - g)/(cmax - cmin);
|
||||
var bluec = (cmax - b)/(cmax - cmin);
|
||||
|
||||
if (r == cmax)
|
||||
hue = bluec - greenc;
|
||||
else if (g == cmax)
|
||||
hue = 2.0 + redc - bluec;
|
||||
else
|
||||
hue = 4.0 + greenc - redc;
|
||||
|
||||
hue = hue / 6.0;
|
||||
if (hue < 0)
|
||||
hue = hue + 1.0;
|
||||
}
|
||||
|
||||
return { h : hue, s : saturation, b : brightness };
|
||||
}
|
||||
|
||||
314
public/lib/Rico/Corner.js
Normal file
314
public/lib/Rico/Corner.js
Normal file
|
|
@ -0,0 +1,314 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005 Sabre Airline Solutions
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
|
||||
* file except in compliance with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software distributed under the
|
||||
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
||||
* either express or implied. See the License for the specific language governing permissions
|
||||
* and limitations under the License.
|
||||
**/
|
||||
|
||||
|
||||
var Rico = new Object();
|
||||
Rico.Corner = {
|
||||
|
||||
round: function(e, options) {
|
||||
var e = $(e);
|
||||
this._setOptions(options);
|
||||
|
||||
var color = this.options.color;
|
||||
if ( this.options.color == "fromElement" )
|
||||
color = this._background(e);
|
||||
|
||||
var bgColor = this.options.bgColor;
|
||||
if ( this.options.bgColor == "fromParent" )
|
||||
bgColor = this._background(e.offsetParent);
|
||||
|
||||
this._roundCornersImpl(e, color, bgColor);
|
||||
},
|
||||
|
||||
/** This is a helper function to change the background
|
||||
* color of <div> that has had Rico rounded corners added.
|
||||
*
|
||||
* It seems we cannot just set the background color for the
|
||||
* outer <div> so each <span> element used to create the
|
||||
* corners must have its background color set individually.
|
||||
*
|
||||
* @param {DOM} theDiv - A child of the outer <div> that was
|
||||
* supplied to the `round` method.
|
||||
*
|
||||
* @param {str} newColor - The new background color to use.
|
||||
*/
|
||||
changeColor: function(theDiv, newColor) {
|
||||
|
||||
theDiv.style.backgroundColor = newColor;
|
||||
|
||||
var spanElements = theDiv.parentNode.getElementsByTagName("span");
|
||||
|
||||
for (var currIdx = 0; currIdx < spanElements.length; currIdx++) {
|
||||
spanElements[currIdx].style.backgroundColor = newColor;
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
/** This is a helper function to change the background
|
||||
* opacity of <div> that has had Rico rounded corners added.
|
||||
*
|
||||
* See changeColor (above) for algorithm explanation
|
||||
*
|
||||
* @param {DOM} theDiv A child of the outer <div> that was
|
||||
* supplied to the `round` method.
|
||||
*
|
||||
* @param {int} newOpacity The new opacity to use (0-1).
|
||||
*/
|
||||
changeOpacity: function(theDiv, newOpacity) {
|
||||
|
||||
var mozillaOpacity = newOpacity;
|
||||
var ieOpacity = 'alpha(opacity=' + newOpacity * 100 + ')';
|
||||
|
||||
theDiv.style.opacity = mozillaOpacity;
|
||||
theDiv.style.filter = ieOpacity;
|
||||
|
||||
var spanElements = theDiv.parentNode.getElementsByTagName("span");
|
||||
|
||||
for (var currIdx = 0; currIdx < spanElements.length; currIdx++) {
|
||||
spanElements[currIdx].style.opacity = mozillaOpacity;
|
||||
spanElements[currIdx].style.filter = ieOpacity;
|
||||
}
|
||||
|
||||
},
|
||||
|
||||
/** this function takes care of redoing the rico cornering
|
||||
*
|
||||
* you can't just call updateRicoCorners() again and pass it a
|
||||
* new options string. you have to first remove the divs that
|
||||
* rico puts on top and below the content div.
|
||||
*
|
||||
* @param {DOM} theDiv - A child of the outer <div> that was
|
||||
* supplied to the `round` method.
|
||||
*
|
||||
* @param {Array} options - list of options
|
||||
*/
|
||||
reRound: function(theDiv, options) {
|
||||
|
||||
var topRico = theDiv.parentNode.childNodes[0];
|
||||
//theDiv would be theDiv.parentNode.childNodes[1]
|
||||
var bottomRico = theDiv.parentNode.childNodes[2];
|
||||
|
||||
theDiv.parentNode.removeChild(topRico);
|
||||
theDiv.parentNode.removeChild(bottomRico);
|
||||
|
||||
this.round(theDiv.parentNode, options);
|
||||
},
|
||||
|
||||
_roundCornersImpl: function(e, color, bgColor) {
|
||||
if(this.options.border)
|
||||
this._renderBorder(e,bgColor);
|
||||
if(this._isTopRounded())
|
||||
this._roundTopCorners(e,color,bgColor);
|
||||
if(this._isBottomRounded())
|
||||
this._roundBottomCorners(e,color,bgColor);
|
||||
},
|
||||
|
||||
_renderBorder: function(el,bgColor) {
|
||||
var borderValue = "1px solid " + this._borderColor(bgColor);
|
||||
var borderL = "border-left: " + borderValue;
|
||||
var borderR = "border-right: " + borderValue;
|
||||
var style = "style='" + borderL + ";" + borderR + "'";
|
||||
el.innerHTML = "<div " + style + ">" + el.innerHTML + "</div>"
|
||||
},
|
||||
|
||||
_roundTopCorners: function(el, color, bgColor) {
|
||||
var corner = this._createCorner(bgColor);
|
||||
for(var i=0 ; i < this.options.numSlices ; i++ )
|
||||
corner.appendChild(this._createCornerSlice(color,bgColor,i,"top"));
|
||||
el.style.paddingTop = 0;
|
||||
el.insertBefore(corner,el.firstChild);
|
||||
},
|
||||
|
||||
_roundBottomCorners: function(el, color, bgColor) {
|
||||
var corner = this._createCorner(bgColor);
|
||||
for(var i=(this.options.numSlices-1) ; i >= 0 ; i-- )
|
||||
corner.appendChild(this._createCornerSlice(color,bgColor,i,"bottom"));
|
||||
el.style.paddingBottom = 0;
|
||||
el.appendChild(corner);
|
||||
},
|
||||
|
||||
_createCorner: function(bgColor) {
|
||||
var corner = document.createElement("div");
|
||||
corner.style.backgroundColor = (this._isTransparent() ? "transparent" : bgColor);
|
||||
return corner;
|
||||
},
|
||||
|
||||
_createCornerSlice: function(color,bgColor, n, position) {
|
||||
var slice = document.createElement("span");
|
||||
|
||||
var inStyle = slice.style;
|
||||
inStyle.backgroundColor = color;
|
||||
inStyle.display = "block";
|
||||
inStyle.height = "1px";
|
||||
inStyle.overflow = "hidden";
|
||||
inStyle.fontSize = "1px";
|
||||
|
||||
var borderColor = this._borderColor(color,bgColor);
|
||||
if ( this.options.border && n == 0 ) {
|
||||
inStyle.borderTopStyle = "solid";
|
||||
inStyle.borderTopWidth = "1px";
|
||||
inStyle.borderLeftWidth = "0px";
|
||||
inStyle.borderRightWidth = "0px";
|
||||
inStyle.borderBottomWidth = "0px";
|
||||
inStyle.height = "0px"; // assumes css compliant box model
|
||||
inStyle.borderColor = borderColor;
|
||||
}
|
||||
else if(borderColor) {
|
||||
inStyle.borderColor = borderColor;
|
||||
inStyle.borderStyle = "solid";
|
||||
inStyle.borderWidth = "0px 1px";
|
||||
}
|
||||
|
||||
if ( !this.options.compact && (n == (this.options.numSlices-1)) )
|
||||
inStyle.height = "2px";
|
||||
|
||||
this._setMargin(slice, n, position);
|
||||
this._setBorder(slice, n, position);
|
||||
return slice;
|
||||
},
|
||||
|
||||
_setOptions: function(options) {
|
||||
this.options = {
|
||||
corners : "all",
|
||||
color : "fromElement",
|
||||
bgColor : "fromParent",
|
||||
blend : true,
|
||||
border : false,
|
||||
compact : false
|
||||
}
|
||||
Object.extend(this.options, options || {});
|
||||
|
||||
this.options.numSlices = this.options.compact ? 2 : 4;
|
||||
if ( this._isTransparent() )
|
||||
this.options.blend = false;
|
||||
},
|
||||
|
||||
_whichSideTop: function() {
|
||||
if ( this._hasString(this.options.corners, "all", "top") )
|
||||
return "";
|
||||
|
||||
if ( this.options.corners.indexOf("tl") >= 0 && this.options.corners.indexOf("tr") >= 0 )
|
||||
return "";
|
||||
|
||||
if (this.options.corners.indexOf("tl") >= 0)
|
||||
return "left";
|
||||
else if (this.options.corners.indexOf("tr") >= 0)
|
||||
return "right";
|
||||
return "";
|
||||
},
|
||||
|
||||
_whichSideBottom: function() {
|
||||
if ( this._hasString(this.options.corners, "all", "bottom") )
|
||||
return "";
|
||||
|
||||
if ( this.options.corners.indexOf("bl")>=0 && this.options.corners.indexOf("br")>=0 )
|
||||
return "";
|
||||
|
||||
if(this.options.corners.indexOf("bl") >=0)
|
||||
return "left";
|
||||
else if(this.options.corners.indexOf("br")>=0)
|
||||
return "right";
|
||||
return "";
|
||||
},
|
||||
|
||||
_borderColor : function(color,bgColor) {
|
||||
if ( color == "transparent" )
|
||||
return bgColor;
|
||||
else if ( this.options.border )
|
||||
return this.options.border;
|
||||
else if ( this.options.blend )
|
||||
return this._blend( bgColor, color );
|
||||
else
|
||||
return "";
|
||||
},
|
||||
|
||||
|
||||
_setMargin: function(el, n, corners) {
|
||||
var marginSize = this._marginSize(n);
|
||||
var whichSide = corners == "top" ? this._whichSideTop() : this._whichSideBottom();
|
||||
|
||||
if ( whichSide == "left" ) {
|
||||
el.style.marginLeft = marginSize + "px"; el.style.marginRight = "0px";
|
||||
}
|
||||
else if ( whichSide == "right" ) {
|
||||
el.style.marginRight = marginSize + "px"; el.style.marginLeft = "0px";
|
||||
}
|
||||
else {
|
||||
el.style.marginLeft = marginSize + "px"; el.style.marginRight = marginSize + "px";
|
||||
}
|
||||
},
|
||||
|
||||
_setBorder: function(el,n,corners) {
|
||||
var borderSize = this._borderSize(n);
|
||||
var whichSide = corners == "top" ? this._whichSideTop() : this._whichSideBottom();
|
||||
if ( whichSide == "left" ) {
|
||||
el.style.borderLeftWidth = borderSize + "px"; el.style.borderRightWidth = "0px";
|
||||
}
|
||||
else if ( whichSide == "right" ) {
|
||||
el.style.borderRightWidth = borderSize + "px"; el.style.borderLeftWidth = "0px";
|
||||
}
|
||||
else {
|
||||
el.style.borderLeftWidth = borderSize + "px"; el.style.borderRightWidth = borderSize + "px";
|
||||
}
|
||||
if (this.options.border != false)
|
||||
el.style.borderLeftWidth = borderSize + "px"; el.style.borderRightWidth = borderSize + "px";
|
||||
},
|
||||
|
||||
_marginSize: function(n) {
|
||||
if ( this._isTransparent() )
|
||||
return 0;
|
||||
|
||||
var marginSizes = [ 5, 3, 2, 1 ];
|
||||
var blendedMarginSizes = [ 3, 2, 1, 0 ];
|
||||
var compactMarginSizes = [ 2, 1 ];
|
||||
var smBlendedMarginSizes = [ 1, 0 ];
|
||||
|
||||
if ( this.options.compact && this.options.blend )
|
||||
return smBlendedMarginSizes[n];
|
||||
else if ( this.options.compact )
|
||||
return compactMarginSizes[n];
|
||||
else if ( this.options.blend )
|
||||
return blendedMarginSizes[n];
|
||||
else
|
||||
return marginSizes[n];
|
||||
},
|
||||
|
||||
_borderSize: function(n) {
|
||||
var transparentBorderSizes = [ 5, 3, 2, 1 ];
|
||||
var blendedBorderSizes = [ 2, 1, 1, 1 ];
|
||||
var compactBorderSizes = [ 1, 0 ];
|
||||
var actualBorderSizes = [ 0, 2, 0, 0 ];
|
||||
|
||||
if ( this.options.compact && (this.options.blend || this._isTransparent()) )
|
||||
return 1;
|
||||
else if ( this.options.compact )
|
||||
return compactBorderSizes[n];
|
||||
else if ( this.options.blend )
|
||||
return blendedBorderSizes[n];
|
||||
else if ( this.options.border )
|
||||
return actualBorderSizes[n];
|
||||
else if ( this._isTransparent() )
|
||||
return transparentBorderSizes[n];
|
||||
return 0;
|
||||
},
|
||||
|
||||
_hasString: function(str) { for(var i=1 ; i<arguments.length ; i++) if (str.indexOf(arguments[i]) >= 0) return true; return false; },
|
||||
_blend: function(c1, c2) { var cc1 = Rico.Color.createFromHex(c1); cc1.blend(Rico.Color.createFromHex(c2)); return cc1; },
|
||||
_background: function(el) { try { return Rico.Color.createColorFromBackground(el).asHex(); } catch(err) { return "#ffffff"; } },
|
||||
_isTransparent: function() { return this.options.color == "transparent"; },
|
||||
_isTopRounded: function() { return this._hasString(this.options.corners, "all", "top", "tl", "tr"); },
|
||||
_isBottomRounded: function() { return this._hasString(this.options.corners, "all", "bottom", "bl", "br"); },
|
||||
_hasSingleTextChild: function(el) { return el.childNodes.length == 1 && el.childNodes[0].nodeType == 3; }
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue