diff --git a/build/OpenLayers.js b/build/OpenLayers.js index f60b58583d..7eb5fcba09 100644 --- a/build/OpenLayers.js +++ b/build/OpenLayers.js @@ -1,17 +1,27 @@ -/* - - OpenLayers.js -- OpenLayers Map Viewer Library - - Copyright 2005-2006 MetaCarta, Inc., released under the BSD License. - - - Includes compressed code under the following licenses: - - (For uncompressed versions of the code used please see the - OpenLayers SVN repository: ) - -*/ +//// +/// This blob sucks in all the files in uncompressed form for ease of use +/// +OpenLayers = new Object(); +OpenLayers._scriptName = "lib/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; +} /* Prototype JavaScript framework, version 1.4.0 * (c) 2005 Sam Stephenson * @@ -20,3858 +30,6426 @@ * /*--------------------------------------------------------------------------*/ +var Prototype = { + Version: '1.4.0', + ScriptFragment: '(?:)((\n|\r|.)*?)(?:<\/script>)', + + emptyFunction: function() {}, + K: function(x) {return x} +} + +var Class = { + create: function() { + return function() { + this.initialize.apply(this, arguments); + } + } +} + +var Abstract = new Object(); + +Object.extend = function(destination, source) { + for (property in source) { + destination[property] = source[property]; + } + return destination; +} + +Object.inspect = function(object) { + try { + if (object == undefined) return 'undefined'; + if (object == null) return 'null'; + return object.inspect ? object.inspect() : object.toString(); + } catch (e) { + if (e instanceof RangeError) return '...'; + throw e; + } +} + +Function.prototype.bind = function() { + var __method = this, args = $A(arguments), object = args.shift(); + return function() { + return __method.apply(object, args.concat($A(arguments))); + } +} + +Function.prototype.bindAsEventListener = function(object) { + var __method = this; + return function(event) { + return __method.call(object, event || window.event); + } +} + +Object.extend(Number.prototype, { + toColorPart: function() { + var digits = this.toString(16); + if (this < 16) return '0' + digits; + return digits; + }, + + succ: function() { + return this + 1; + }, + + times: function(iterator) { + $R(0, this, true).each(iterator); + return this; + } +}); + +var Try = { + these: function() { + var returnValue; + + for (var i = 0; i < arguments.length; i++) { + var lambda = arguments[i]; + try { + returnValue = lambda(); + break; + } catch (e) {} + } + + return returnValue; + } +} + +/*--------------------------------------------------------------------------*/ + +var PeriodicalExecuter = Class.create(); +PeriodicalExecuter.prototype = { + initialize: function(callback, frequency) { + this.callback = callback; + this.frequency = frequency; + this.currentlyExecuting = false; + + this.registerCallback(); + }, + + registerCallback: function() { + setInterval(this.onTimerEvent.bind(this), this.frequency * 1000); + }, + + onTimerEvent: function() { + if (!this.currentlyExecuting) { + try { + this.currentlyExecuting = true; + this.callback(); + } finally { + this.currentlyExecuting = false; + } + } + } +} + +/*--------------------------------------------------------------------------*/ + +function $() { + var elements = new Array(); + + for (var i = 0; i < arguments.length; i++) { + var element = arguments[i]; + if (typeof element == 'string') + element = document.getElementById(element); + + if (arguments.length == 1) + return element; + + elements.push(element); + } + + return elements; +} +Object.extend(String.prototype, { + stripTags: function() { + return this.replace(/<\/?[^>]+>/gi, ''); + }, + + stripScripts: function() { + return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), ''); + }, + + extractScripts: function() { + var matchAll = new RegExp(Prototype.ScriptFragment, 'img'); + var matchOne = new RegExp(Prototype.ScriptFragment, 'im'); + return (this.match(matchAll) || []).map(function(scriptTag) { + return (scriptTag.match(matchOne) || ['', ''])[1]; + }); + }, + + evalScripts: function() { + return this.extractScripts().map(eval); + }, + + escapeHTML: function() { + var div = document.createElement('div'); + var text = document.createTextNode(this); + div.appendChild(text); + return div.innerHTML; + }, + + unescapeHTML: function() { + var div = document.createElement('div'); + div.innerHTML = this.stripTags(); + return div.childNodes[0] ? div.childNodes[0].nodeValue : ''; + }, + + toQueryParams: function() { + var pairs = this.match(/^\??(.*)$/)[1].split('&'); + return pairs.inject({}, function(params, pairString) { + var pair = pairString.split('='); + params[pair[0]] = pair[1]; + return params; + }); + }, + + toArray: function() { + return this.split(''); + }, + + camelize: function() { + var oStringList = this.split('-'); + if (oStringList.length == 1) return oStringList[0]; + + var camelizedString = this.indexOf('-') == 0 + ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1) + : oStringList[0]; + + for (var i = 1, len = oStringList.length; i < len; i++) { + var s = oStringList[i]; + camelizedString += s.charAt(0).toUpperCase() + s.substring(1); + } + + return camelizedString; + }, + + inspect: function() { + return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'"; + } +}); + +String.prototype.parseQuery = String.prototype.toQueryParams; + +var $break = new Object(); +var $continue = new Object(); + +var Enumerable = { + each: function(iterator) { + var index = 0; + try { + this._each(function(value) { + try { + iterator(value, index++); + } catch (e) { + if (e != $continue) throw e; + } + }); + } catch (e) { + if (e != $break) throw e; + } + }, + + all: function(iterator) { + var result = true; + this.each(function(value, index) { + result = result && !!(iterator || Prototype.K)(value, index); + if (!result) throw $break; + }); + return result; + }, + + any: function(iterator) { + var result = true; + this.each(function(value, index) { + if (result = !!(iterator || Prototype.K)(value, index)) + throw $break; + }); + return result; + }, + + collect: function(iterator) { + var results = []; + this.each(function(value, index) { + results.push(iterator(value, index)); + }); + return results; + }, + + detect: function (iterator) { + var result; + this.each(function(value, index) { + if (iterator(value, index)) { + result = value; + throw $break; + } + }); + return result; + }, + + findAll: function(iterator) { + var results = []; + this.each(function(value, index) { + if (iterator(value, index)) + results.push(value); + }); + return results; + }, + + grep: function(pattern, iterator) { + var results = []; + this.each(function(value, index) { + var stringValue = value.toString(); + if (stringValue.match(pattern)) + results.push((iterator || Prototype.K)(value, index)); + }) + return results; + }, + + include: function(object) { + var found = false; + this.each(function(value) { + if (value == object) { + found = true; + throw $break; + } + }); + return found; + }, + + inject: function(memo, iterator) { + this.each(function(value, index) { + memo = iterator(memo, value, index); + }); + return memo; + }, + + invoke: function(method) { + var args = $A(arguments).slice(1); + return this.collect(function(value) { + return value[method].apply(value, args); + }); + }, + + max: function(iterator) { + var result; + this.each(function(value, index) { + value = (iterator || Prototype.K)(value, index); + if (value >= (result || value)) + result = value; + }); + return result; + }, + + min: function(iterator) { + var result; + this.each(function(value, index) { + value = (iterator || Prototype.K)(value, index); + if (value <= (result || value)) + result = value; + }); + return result; + }, + + partition: function(iterator) { + var trues = [], falses = []; + this.each(function(value, index) { + ((iterator || Prototype.K)(value, index) ? + trues : falses).push(value); + }); + return [trues, falses]; + }, + + pluck: function(property) { + var results = []; + this.each(function(value, index) { + results.push(value[property]); + }); + return results; + }, + + reject: function(iterator) { + var results = []; + this.each(function(value, index) { + if (!iterator(value, index)) + results.push(value); + }); + return results; + }, + + sortBy: function(iterator) { + return this.collect(function(value, index) { + return {value: value, criteria: iterator(value, index)}; + }).sort(function(left, right) { + var a = left.criteria, b = right.criteria; + return a < b ? -1 : a > b ? 1 : 0; + }).pluck('value'); + }, + + toArray: function() { + return this.collect(Prototype.K); + }, + + zip: function() { + var iterator = Prototype.K, args = $A(arguments); + if (typeof args.last() == 'function') + iterator = args.pop(); + + var collections = [this].concat(args).map($A); + return this.map(function(value, index) { + iterator(value = collections.pluck(index)); + return value; + }); + }, + + inspect: function() { + return '#'; + } +} + +Object.extend(Enumerable, { + map: Enumerable.collect, + find: Enumerable.detect, + select: Enumerable.findAll, + member: Enumerable.include, + entries: Enumerable.toArray +}); +var $A = Array.from = function(iterable) { + if (!iterable) return []; + if (iterable.toArray) { + return iterable.toArray(); + } else { + var results = []; + for (var i = 0; i < iterable.length; i++) + results.push(iterable[i]); + return results; + } +} + +Object.extend(Array.prototype, Enumerable); + +Array.prototype._reverse = Array.prototype.reverse; + +Object.extend(Array.prototype, { + _each: function(iterator) { + for (var i = 0; i < this.length; i++) + iterator(this[i]); + }, + + clear: function() { + this.length = 0; + return this; + }, + + first: function() { + return this[0]; + }, + + last: function() { + return this[this.length - 1]; + }, + + compact: function() { + return this.select(function(value) { + return value != undefined || value != null; + }); + }, + + flatten: function() { + return this.inject([], function(array, value) { + return array.concat(value.constructor == Array ? + value.flatten() : [value]); + }); + }, + + without: function() { + var values = $A(arguments); + return this.select(function(value) { + return !values.include(value); + }); + }, + + indexOf: function(object) { + for (var i = 0; i < this.length; i++) + if (this[i] == object) return i; + return -1; + }, + + reverse: function(inline) { + return (inline !== false ? this : this.toArray())._reverse(); + }, + + shift: function() { + var result = this[0]; + for (var i = 0; i < this.length - 1; i++) + this[i] = this[i + 1]; + this.length--; + return result; + }, + + inspect: function() { + return '[' + this.map(Object.inspect).join(', ') + ']'; + } +}); +var Hash = { + _each: function(iterator) { + for (key in this) { + var value = this[key]; + if (typeof value == 'function') continue; + + var pair = [key, value]; + pair.key = key; + pair.value = value; + iterator(pair); + } + }, + + keys: function() { + return this.pluck('key'); + }, + + values: function() { + return this.pluck('value'); + }, + + merge: function(hash) { + return $H(hash).inject($H(this), function(mergedHash, pair) { + mergedHash[pair.key] = pair.value; + return mergedHash; + }); + }, + + toQueryString: function() { + return this.map(function(pair) { + return pair.map(encodeURIComponent).join('='); + }).join('&'); + }, + + inspect: function() { + return '#'; + } +} + +function $H(object) { + var hash = Object.extend({}, object || {}); + Object.extend(hash, Enumerable); + Object.extend(hash, Hash); + return hash; +} +ObjectRange = Class.create(); +Object.extend(ObjectRange.prototype, Enumerable); +Object.extend(ObjectRange.prototype, { + initialize: function(start, end, exclusive) { + this.start = start; + this.end = end; + this.exclusive = exclusive; + }, + + _each: function(iterator) { + var value = this.start; + do { + iterator(value); + value = value.succ(); + } while (this.include(value)); + }, + + include: function(value) { + if (value < this.start) + return false; + if (this.exclusive) + return value < this.end; + return value <= this.end; + } +}); + +var $R = function(start, end, exclusive) { + return new ObjectRange(start, end, exclusive); +} + +var Ajax = { + getTransport: function() { + return Try.these( + function() {return new ActiveXObject('Msxml2.XMLHTTP')}, + function() {return new ActiveXObject('Microsoft.XMLHTTP')}, + function() {return new XMLHttpRequest()} + ) || false; + }, + + activeRequestCount: 0 +} + +Ajax.Responders = { + responders: [], + + _each: function(iterator) { + this.responders._each(iterator); + }, + + register: function(responderToAdd) { + if (!this.include(responderToAdd)) + this.responders.push(responderToAdd); + }, + + unregister: function(responderToRemove) { + this.responders = this.responders.without(responderToRemove); + }, + + dispatch: function(callback, request, transport, json) { + this.each(function(responder) { + if (responder[callback] && typeof responder[callback] == 'function') { + try { + responder[callback].apply(responder, [request, transport, json]); + } catch (e) {} + } + }); + } +}; + +Object.extend(Ajax.Responders, Enumerable); + +Ajax.Responders.register({ + onCreate: function() { + Ajax.activeRequestCount++; + }, + + onComplete: function() { + Ajax.activeRequestCount--; + } +}); + +Ajax.Base = function() {}; +Ajax.Base.prototype = { + setOptions: function(options) { + this.options = { + method: 'post', + asynchronous: true, + parameters: '' + } + Object.extend(this.options, options || {}); + }, + + responseIsSuccess: function() { + return this.transport.status == undefined + || this.transport.status == 0 + || (this.transport.status >= 200 && this.transport.status < 300); + }, + + responseIsFailure: function() { + return !this.responseIsSuccess(); + } +} + +Ajax.Request = Class.create(); +Ajax.Request.Events = + ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete']; + +Ajax.Request.prototype = Object.extend(new Ajax.Base(), { + initialize: function(url, options) { + this.transport = Ajax.getTransport(); + this.setOptions(options); + this.request(url); + }, + + request: function(url) { + var parameters = this.options.parameters || ''; + if (parameters.length > 0) parameters += '&_='; + + try { + this.url = url; + if (this.options.method == 'get' && parameters.length > 0) + this.url += (this.url.match(/\?/) ? '&' : '?') + parameters; + + Ajax.Responders.dispatch('onCreate', this, this.transport); + + this.transport.open(this.options.method, this.url, + this.options.asynchronous); + + if (this.options.asynchronous) { + this.transport.onreadystatechange = this.onStateChange.bind(this); + setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10); + } + + this.setRequestHeaders(); + + var body = this.options.postBody ? this.options.postBody : parameters; + this.transport.send(this.options.method == 'post' ? body : null); + + } catch (e) { + this.dispatchException(e); + } + }, + + setRequestHeaders: function() { + var requestHeaders = + ['X-Requested-With', 'XMLHttpRequest', + 'X-Prototype-Version', Prototype.Version]; + + if (this.options.method == 'post') { + requestHeaders.push('Content-type', + 'application/x-www-form-urlencoded'); + + /* Force "Connection: close" for Mozilla browsers to work around + * a bug where XMLHttpReqeuest sends an incorrect Content-length + * header. See Mozilla Bugzilla #246651. + */ + if (this.transport.overrideMimeType) + requestHeaders.push('Connection', 'close'); + } + + if (this.options.requestHeaders) + requestHeaders.push.apply(requestHeaders, this.options.requestHeaders); + + for (var i = 0; i < requestHeaders.length; i += 2) + this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]); + }, + + onStateChange: function() { + var readyState = this.transport.readyState; + if (readyState != 1) + this.respondToReadyState(this.transport.readyState); + }, + + header: function(name) { + try { + return this.transport.getResponseHeader(name); + } catch (e) {} + }, + + evalJSON: function() { + try { + return eval(this.header('X-JSON')); + } catch (e) {} + }, + + evalResponse: function() { + try { + return eval(this.transport.responseText); + } catch (e) { + this.dispatchException(e); + } + }, + + respondToReadyState: function(readyState) { + var event = Ajax.Request.Events[readyState]; + var transport = this.transport, json = this.evalJSON(); + + if (event == 'Complete') { + try { + (this.options['on' + this.transport.status] + || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')] + || Prototype.emptyFunction)(transport, json); + } catch (e) { + this.dispatchException(e); + } + + if ((this.header('Content-type') || '').match(/^text\/javascript/i)) + this.evalResponse(); + } + + try { + (this.options['on' + event] || Prototype.emptyFunction)(transport, json); + Ajax.Responders.dispatch('on' + event, this, transport, json); + } catch (e) { + this.dispatchException(e); + } + + /* Avoid memory leak in MSIE: clean up the oncomplete event handler */ + if (event == 'Complete') + this.transport.onreadystatechange = Prototype.emptyFunction; + }, + + dispatchException: function(exception) { + (this.options.onException || Prototype.emptyFunction)(this, exception); + Ajax.Responders.dispatch('onException', this, exception); + } +}); + +Ajax.Updater = Class.create(); + +Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), { + initialize: function(container, url, options) { + this.containers = { + success: container.success ? $(container.success) : $(container), + failure: container.failure ? $(container.failure) : + (container.success ? null : $(container)) + } + + this.transport = Ajax.getTransport(); + this.setOptions(options); + + var onComplete = this.options.onComplete || Prototype.emptyFunction; + this.options.onComplete = (function(transport, object) { + this.updateContent(); + onComplete(transport, object); + }).bind(this); + + this.request(url); + }, + + updateContent: function() { + var receiver = this.responseIsSuccess() ? + this.containers.success : this.containers.failure; + var response = this.transport.responseText; + + if (!this.options.evalScripts) + response = response.stripScripts(); + + if (receiver) { + if (this.options.insertion) { + new this.options.insertion(receiver, response); + } else { + Element.update(receiver, response); + } + } + + if (this.responseIsSuccess()) { + if (this.onComplete) + setTimeout(this.onComplete.bind(this), 10); + } + } +}); + +Ajax.PeriodicalUpdater = Class.create(); +Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), { + initialize: function(container, url, options) { + this.setOptions(options); + this.onComplete = this.options.onComplete; + + this.frequency = (this.options.frequency || 2); + this.decay = (this.options.decay || 1); + + this.updater = {}; + this.container = container; + this.url = url; + + this.start(); + }, + + start: function() { + this.options.onComplete = this.updateComplete.bind(this); + this.onTimerEvent(); + }, + + stop: function() { + this.updater.onComplete = undefined; + clearTimeout(this.timer); + (this.onComplete || Prototype.emptyFunction).apply(this, arguments); + }, + + updateComplete: function(request) { + if (this.options.decay) { + this.decay = (request.responseText == this.lastText ? + this.decay * this.options.decay : 1); + + this.lastText = request.responseText; + } + this.timer = setTimeout(this.onTimerEvent.bind(this), + this.decay * this.frequency * 1000); + }, + + onTimerEvent: function() { + this.updater = new Ajax.Updater(this.container, this.url, this.options); + } +}); +document.getElementsByClassName = function(className, parentElement) { + var children = ($(parentElement) || document.body).getElementsByTagName('*'); + return $A(children).inject([], function(elements, child) { + if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)"))) + elements.push(child); + return elements; + }); +} + +/*--------------------------------------------------------------------------*/ + +if (!window.Element) { + var Element = new Object(); +} + +Object.extend(Element, { + visible: function(element) { + return $(element).style.display != 'none'; + }, + + toggle: function() { + for (var i = 0; i < arguments.length; i++) { + var element = $(arguments[i]); + Element[Element.visible(element) ? 'hide' : 'show'](element); + } + }, + + hide: function() { + for (var i = 0; i < arguments.length; i++) { + var element = $(arguments[i]); + element.style.display = 'none'; + } + }, + + show: function() { + for (var i = 0; i < arguments.length; i++) { + var element = $(arguments[i]); + element.style.display = ''; + } + }, + + remove: function(element) { + element = $(element); + element.parentNode.removeChild(element); + }, + + update: function(element, html) { + $(element).innerHTML = html.stripScripts(); + setTimeout(function() {html.evalScripts()}, 10); + }, + + getHeight: function(element) { + element = $(element); + return element.offsetHeight; + }, + + classNames: function(element) { + return new Element.ClassNames(element); + }, + + hasClassName: function(element, className) { + if (!(element = $(element))) return; + return Element.classNames(element).include(className); + }, + + addClassName: function(element, className) { + if (!(element = $(element))) return; + return Element.classNames(element).add(className); + }, + + removeClassName: function(element, className) { + if (!(element = $(element))) return; + return Element.classNames(element).remove(className); + }, + + // removes whitespace-only text node children + cleanWhitespace: function(element) { + element = $(element); + for (var i = 0; i < element.childNodes.length; i++) { + var node = element.childNodes[i]; + if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) + Element.remove(node); + } + }, + + empty: function(element) { + return $(element).innerHTML.match(/^\s*$/); + }, + + scrollTo: function(element) { + element = $(element); + var x = element.x ? element.x : element.offsetLeft, + y = element.y ? element.y : element.offsetTop; + window.scrollTo(x, y); + }, + + getStyle: function(element, style) { + element = $(element); + var value = element.style[style.camelize()]; + if (!value) { + if (document.defaultView && document.defaultView.getComputedStyle) { + var css = document.defaultView.getComputedStyle(element, null); + value = css ? css.getPropertyValue(style) : null; + } else if (element.currentStyle) { + value = element.currentStyle[style.camelize()]; + } + } + + if (window.opera && ['left', 'top', 'right', 'bottom'].include(style)) + if (Element.getStyle(element, 'position') == 'static') value = 'auto'; + + return value == 'auto' ? null : value; + }, + + setStyle: function(element, style) { + element = $(element); + for (name in style) + element.style[name.camelize()] = style[name]; + }, + + getDimensions: function(element) { + element = $(element); + if (Element.getStyle(element, 'display') != 'none') + return {width: element.offsetWidth, height: element.offsetHeight}; + + // All *Width and *Height properties give 0 on elements with display none, + // so enable the element temporarily + var els = element.style; + var originalVisibility = els.visibility; + var originalPosition = els.position; + els.visibility = 'hidden'; + els.position = 'absolute'; + els.display = ''; + var originalWidth = element.clientWidth; + var originalHeight = element.clientHeight; + els.display = 'none'; + els.position = originalPosition; + els.visibility = originalVisibility; + return {width: originalWidth, height: originalHeight}; + }, + + makePositioned: function(element) { + element = $(element); + var pos = Element.getStyle(element, 'position'); + if (pos == 'static' || !pos) { + element._madePositioned = true; + element.style.position = 'relative'; + // Opera returns the offset relative to the positioning context, when an + // element is position relative but top and left have not been defined + if (window.opera) { + element.style.top = 0; + element.style.left = 0; + } + } + }, + + undoPositioned: function(element) { + element = $(element); + if (element._madePositioned) { + element._madePositioned = undefined; + element.style.position = + element.style.top = + element.style.left = + element.style.bottom = + element.style.right = ''; + } + }, + + makeClipping: function(element) { + element = $(element); + if (element._overflow) return; + element._overflow = element.style.overflow; + if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden') + element.style.overflow = 'hidden'; + }, + + undoClipping: function(element) { + element = $(element); + if (element._overflow) return; + element.style.overflow = element._overflow; + element._overflow = undefined; + } +}); + +var Toggle = new Object(); +Toggle.display = Element.toggle; + +/*--------------------------------------------------------------------------*/ + +Abstract.Insertion = function(adjacency) { + this.adjacency = adjacency; +} + +Abstract.Insertion.prototype = { + initialize: function(element, content) { + this.element = $(element); + this.content = content.stripScripts(); + + if (this.adjacency && this.element.insertAdjacentHTML) { + try { + this.element.insertAdjacentHTML(this.adjacency, this.content); + } catch (e) { + if (this.element.tagName.toLowerCase() == 'tbody') { + this.insertContent(this.contentFromAnonymousTable()); + } else { + throw e; + } + } + } else { + this.range = this.element.ownerDocument.createRange(); + if (this.initializeRange) this.initializeRange(); + this.insertContent([this.range.createContextualFragment(this.content)]); + } + + setTimeout(function() {content.evalScripts()}, 10); + }, + + contentFromAnonymousTable: function() { + var div = document.createElement('div'); + div.innerHTML = '' + this.content + '
'; + return $A(div.childNodes[0].childNodes[0].childNodes); + } +} + +var Insertion = new Object(); + +Insertion.Before = Class.create(); +Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), { + initializeRange: function() { + this.range.setStartBefore(this.element); + }, + + insertContent: function(fragments) { + fragments.each((function(fragment) { + this.element.parentNode.insertBefore(fragment, this.element); + }).bind(this)); + } +}); + +Insertion.Top = Class.create(); +Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), { + initializeRange: function() { + this.range.selectNodeContents(this.element); + this.range.collapse(true); + }, + + insertContent: function(fragments) { + fragments.reverse(false).each((function(fragment) { + this.element.insertBefore(fragment, this.element.firstChild); + }).bind(this)); + } +}); + +Insertion.Bottom = Class.create(); +Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), { + initializeRange: function() { + this.range.selectNodeContents(this.element); + this.range.collapse(this.element); + }, + + insertContent: function(fragments) { + fragments.each((function(fragment) { + this.element.appendChild(fragment); + }).bind(this)); + } +}); + +Insertion.After = Class.create(); +Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), { + initializeRange: function() { + this.range.setStartAfter(this.element); + }, + + insertContent: function(fragments) { + fragments.each((function(fragment) { + this.element.parentNode.insertBefore(fragment, + this.element.nextSibling); + }).bind(this)); + } +}); + +/*--------------------------------------------------------------------------*/ + +Element.ClassNames = Class.create(); +Element.ClassNames.prototype = { + initialize: function(element) { + this.element = $(element); + }, + + _each: function(iterator) { + this.element.className.split(/\s+/).select(function(name) { + return name.length > 0; + })._each(iterator); + }, + + set: function(className) { + this.element.className = className; + }, + + add: function(classNameToAdd) { + if (this.include(classNameToAdd)) return; + this.set(this.toArray().concat(classNameToAdd).join(' ')); + }, + + remove: function(classNameToRemove) { + if (!this.include(classNameToRemove)) return; + this.set(this.select(function(className) { + return className != classNameToRemove; + }).join(' ')); + }, + + toString: function() { + return this.toArray().join(' '); + } +} + +Object.extend(Element.ClassNames.prototype, Enumerable); +var Field = { + clear: function() { + for (var i = 0; i < arguments.length; i++) + $(arguments[i]).value = ''; + }, + + focus: function(element) { + $(element).focus(); + }, + + present: function() { + for (var i = 0; i < arguments.length; i++) + if ($(arguments[i]).value == '') return false; + return true; + }, + + select: function(element) { + $(element).select(); + }, + + activate: function(element) { + element = $(element); + element.focus(); + if (element.select) + element.select(); + } +} + +/*--------------------------------------------------------------------------*/ + +var Form = { + serialize: function(form) { + var elements = Form.getElements($(form)); + var queryComponents = new Array(); + + for (var i = 0; i < elements.length; i++) { + var queryComponent = Form.Element.serialize(elements[i]); + if (queryComponent) + queryComponents.push(queryComponent); + } + + return queryComponents.join('&'); + }, + + getElements: function(form) { + form = $(form); + var elements = new Array(); + + for (tagName in Form.Element.Serializers) { + var tagElements = form.getElementsByTagName(tagName); + for (var j = 0; j < tagElements.length; j++) + elements.push(tagElements[j]); + } + return elements; + }, + + getInputs: function(form, typeName, name) { + form = $(form); + var inputs = form.getElementsByTagName('input'); + + if (!typeName && !name) + return inputs; + + var matchingInputs = new Array(); + for (var i = 0; i < inputs.length; i++) { + var input = inputs[i]; + if ((typeName && input.type != typeName) || + (name && input.name != name)) + continue; + matchingInputs.push(input); + } + + return matchingInputs; + }, + + disable: function(form) { + var elements = Form.getElements(form); + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + element.blur(); + element.disabled = 'true'; + } + }, + + enable: function(form) { + var elements = Form.getElements(form); + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + element.disabled = ''; + } + }, + + findFirstElement: function(form) { + return Form.getElements(form).find(function(element) { + return element.type != 'hidden' && !element.disabled && + ['input', 'select', 'textarea'].include(element.tagName.toLowerCase()); + }); + }, + + focusFirstElement: function(form) { + Field.activate(Form.findFirstElement(form)); + }, + + reset: function(form) { + $(form).reset(); + } +} + +Form.Element = { + serialize: function(element) { + element = $(element); + var method = element.tagName.toLowerCase(); + var parameter = Form.Element.Serializers[method](element); + + if (parameter) { + var key = encodeURIComponent(parameter[0]); + if (key.length == 0) return; + + if (parameter[1].constructor != Array) + parameter[1] = [parameter[1]]; + + return parameter[1].map(function(value) { + return key + '=' + encodeURIComponent(value); + }).join('&'); + } + }, + + getValue: function(element) { + element = $(element); + var method = element.tagName.toLowerCase(); + var parameter = Form.Element.Serializers[method](element); + + if (parameter) + return parameter[1]; + } +} + +Form.Element.Serializers = { + input: function(element) { + switch (element.type.toLowerCase()) { + case 'submit': + case 'hidden': + case 'password': + case 'text': + return Form.Element.Serializers.textarea(element); + case 'checkbox': + case 'radio': + return Form.Element.Serializers.inputSelector(element); + } + return false; + }, + + inputSelector: function(element) { + if (element.checked) + return [element.name, element.value]; + }, + + textarea: function(element) { + return [element.name, element.value]; + }, + + select: function(element) { + return Form.Element.Serializers[element.type == 'select-one' ? + 'selectOne' : 'selectMany'](element); + }, + + selectOne: function(element) { + var value = '', opt, index = element.selectedIndex; + if (index >= 0) { + opt = element.options[index]; + value = opt.value; + if (!value && !('value' in opt)) + value = opt.text; + } + return [element.name, value]; + }, + + selectMany: function(element) { + var value = new Array(); + for (var i = 0; i < element.length; i++) { + var opt = element.options[i]; + if (opt.selected) { + var optValue = opt.value; + if (!optValue && !('value' in opt)) + optValue = opt.text; + value.push(optValue); + } + } + return [element.name, value]; + } +} + +/*--------------------------------------------------------------------------*/ + +var $F = Form.Element.getValue; + +/*--------------------------------------------------------------------------*/ + +Abstract.TimedObserver = function() {} +Abstract.TimedObserver.prototype = { + initialize: function(element, frequency, callback) { + this.frequency = frequency; + this.element = $(element); + this.callback = callback; + + this.lastValue = this.getValue(); + this.registerCallback(); + }, + + registerCallback: function() { + setInterval(this.onTimerEvent.bind(this), this.frequency * 1000); + }, + + onTimerEvent: function() { + var value = this.getValue(); + if (this.lastValue != value) { + this.callback(this.element, value); + this.lastValue = value; + } + } +} + +Form.Element.Observer = Class.create(); +Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), { + getValue: function() { + return Form.Element.getValue(this.element); + } +}); + +Form.Observer = Class.create(); +Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), { + getValue: function() { + return Form.serialize(this.element); + } +}); + +/*--------------------------------------------------------------------------*/ + +Abstract.EventObserver = function() {} +Abstract.EventObserver.prototype = { + initialize: function(element, callback) { + this.element = $(element); + this.callback = callback; + + this.lastValue = this.getValue(); + if (this.element.tagName.toLowerCase() == 'form') + this.registerFormCallbacks(); + else + this.registerCallback(this.element); + }, + + onElementEvent: function() { + var value = this.getValue(); + if (this.lastValue != value) { + this.callback(this.element, value); + this.lastValue = value; + } + }, + + registerFormCallbacks: function() { + var elements = Form.getElements(this.element); + for (var i = 0; i < elements.length; i++) + this.registerCallback(elements[i]); + }, + + registerCallback: function(element) { + if (element.type) { + switch (element.type.toLowerCase()) { + case 'checkbox': + case 'radio': + Event.observe(element, 'click', this.onElementEvent.bind(this)); + break; + case 'password': + case 'text': + case 'textarea': + case 'select-one': + case 'select-multiple': + Event.observe(element, 'change', this.onElementEvent.bind(this)); + break; + } + } + } +} + +Form.Element.EventObserver = Class.create(); +Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), { + getValue: function() { + return Form.Element.getValue(this.element); + } +}); + +Form.EventObserver = Class.create(); +Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), { + getValue: function() { + return Form.serialize(this.element); + } +}); +if (!window.Event) { + var Event = new Object(); +} + +Object.extend(Event, { + KEY_BACKSPACE: 8, + KEY_TAB: 9, + KEY_RETURN: 13, + KEY_ESC: 27, + KEY_LEFT: 37, + KEY_UP: 38, + KEY_RIGHT: 39, + KEY_DOWN: 40, + KEY_DELETE: 46, + + element: function(event) { + return event.target || event.srcElement; + }, + + isLeftClick: function(event) { + return (((event.which) && (event.which == 1)) || + ((event.button) && (event.button == 1))); + }, + + pointerX: function(event) { + return event.pageX || (event.clientX + + (document.documentElement.scrollLeft || document.body.scrollLeft)); + }, + + pointerY: function(event) { + return event.pageY || (event.clientY + + (document.documentElement.scrollTop || document.body.scrollTop)); + }, + + stop: function(event) { + if (event.preventDefault) { + event.preventDefault(); + event.stopPropagation(); + } else { + event.returnValue = false; + event.cancelBubble = true; + } + }, + + // find the first node with the given tagName, starting from the + // node the event was triggered on; traverses the DOM upwards + findElement: function(event, tagName) { + var element = Event.element(event); + while (element.parentNode && (!element.tagName || + (element.tagName.toUpperCase() != tagName.toUpperCase()))) + element = element.parentNode; + return element; + }, + + observers: false, + + _observeAndCache: function(element, name, observer, useCapture) { + if (!this.observers) this.observers = []; + if (element.addEventListener) { + this.observers.push([element, name, observer, useCapture]); + element.addEventListener(name, observer, useCapture); + } else if (element.attachEvent) { + this.observers.push([element, name, observer, useCapture]); + element.attachEvent('on' + name, observer); + } + }, + + unloadCache: function() { + if (!Event.observers) return; + for (var i = 0; i < Event.observers.length; i++) { + Event.stopObserving.apply(this, Event.observers[i]); + Event.observers[i][0] = null; + } + Event.observers = false; + }, + + observe: function(elementParam, name, observer, useCapture) { + var element = $(elementParam); + useCapture = useCapture || false; + + if (name == 'keypress' && + (navigator.appVersion.match(/Konqueror|Safari|KHTML/) + || element.attachEvent)) + name = 'keydown'; + + this._observeAndCache(element, name, observer, useCapture); + }, + + stopObserving: function(elementParam, name, observer, useCapture) { + var element = $(elementParam); + useCapture = useCapture || false; + + if (name == 'keypress' && + (navigator.appVersion.match(/Konqueror|Safari|KHTML/) + || element.detachEvent)) + name = 'keydown'; + + if (element.removeEventListener) { + element.removeEventListener(name, observer, useCapture); + } else if (element.detachEvent) { + element.detachEvent('on' + name, observer); + } + } +}); + +/* prevent memory leaks in IE */ +Event.observe(window, 'unload', Event.unloadCache, false); +var Position = { + // set to true if needed, warning: firefox performance problems + // NOT neeeded for page scrolling, only if draggable contained in + // scrollable elements + includeScrollOffsets: false, + + // must be called before calling withinIncludingScrolloffset, every time the + // page is scrolled + prepare: function() { + this.deltaX = window.pageXOffset + || document.documentElement.scrollLeft + || document.body.scrollLeft + || 0; + this.deltaY = window.pageYOffset + || document.documentElement.scrollTop + || document.body.scrollTop + || 0; + }, + + realOffset: function(element) { + var valueT = 0, valueL = 0; + do { + valueT += element.scrollTop || 0; + valueL += element.scrollLeft || 0; + element = element.parentNode; + } while (element); + return [valueL, valueT]; + }, + + cumulativeOffset: function(element) { + var valueT = 0, valueL = 0; + do { + valueT += element.offsetTop || 0; + valueL += element.offsetLeft || 0; + element = element.offsetParent; + } while (element); + return [valueL, valueT]; + }, + + positionedOffset: function(element) { + var valueT = 0, valueL = 0; + do { + valueT += element.offsetTop || 0; + valueL += element.offsetLeft || 0; + element = element.offsetParent; + if (element) { + p = Element.getStyle(element, 'position'); + if (p == 'relative' || p == 'absolute') break; + } + } while (element); + return [valueL, valueT]; + }, + + offsetParent: function(element) { + if (element.offsetParent) return element.offsetParent; + if (element == document.body) return element; + + while ((element = element.parentNode) && element != document.body) + if (Element.getStyle(element, 'position') != 'static') + return element; + + return document.body; + }, + + // caches x/y coordinate pair to use with overlap + within: function(element, x, y) { + if (this.includeScrollOffsets) + return this.withinIncludingScrolloffsets(element, x, y); + this.xcomp = x; + this.ycomp = y; + this.offset = this.cumulativeOffset(element); + + return (y >= this.offset[1] && + y < this.offset[1] + element.offsetHeight && + x >= this.offset[0] && + x < this.offset[0] + element.offsetWidth); + }, + + withinIncludingScrolloffsets: function(element, x, y) { + var offsetcache = this.realOffset(element); + + this.xcomp = x + offsetcache[0] - this.deltaX; + this.ycomp = y + offsetcache[1] - this.deltaY; + this.offset = this.cumulativeOffset(element); + + return (this.ycomp >= this.offset[1] && + this.ycomp < this.offset[1] + element.offsetHeight && + this.xcomp >= this.offset[0] && + this.xcomp < this.offset[0] + element.offsetWidth); + }, + + // within must be called directly before + overlap: function(mode, element) { + if (!mode) return 0; + if (mode == 'vertical') + return ((this.offset[1] + element.offsetHeight) - this.ycomp) / + element.offsetHeight; + if (mode == 'horizontal') + return ((this.offset[0] + element.offsetWidth) - this.xcomp) / + element.offsetWidth; + }, + + clone: function(source, target) { + source = $(source); + target = $(target); + target.style.position = 'absolute'; + var offsets = this.cumulativeOffset(source); + target.style.top = offsets[1] + 'px'; + target.style.left = offsets[0] + 'px'; + target.style.width = source.offsetWidth + 'px'; + target.style.height = source.offsetHeight + 'px'; + }, + + page: function(forElement) { + var valueT = 0, valueL = 0; + + var element = forElement; + do { + valueT += element.offsetTop || 0; + valueL += element.offsetLeft || 0; + + // Safari fix + if (element.offsetParent==document.body) + if (Element.getStyle(element,'position')=='absolute') break; + + } while (element = element.offsetParent); + + element = forElement; + do { + valueT -= element.scrollTop || 0; + valueL -= element.scrollLeft || 0; + } while (element = element.parentNode); + + return [valueL, valueT]; + }, + + clone: function(source, target) { + var options = Object.extend({ + setLeft: true, + setTop: true, + setWidth: true, + setHeight: true, + offsetTop: 0, + offsetLeft: 0 + }, arguments[2] || {}) + + // find page position of source + source = $(source); + var p = Position.page(source); + + // find coordinate system to use + target = $(target); + var delta = [0, 0]; + var parent = null; + // delta [0,0] will do fine with position: fixed elements, + // position:absolute needs offsetParent deltas + if (Element.getStyle(target,'position') == 'absolute') { + parent = Position.offsetParent(target); + delta = Position.page(parent); + } + + // correct by body offsets (fixes Safari) + if (parent == document.body) { + delta[0] -= document.body.offsetLeft; + delta[1] -= document.body.offsetTop; + } + + // set position + if(options.setLeft) target.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px'; + if(options.setTop) target.style.top = (p[1] - delta[1] + options.offsetTop) + 'px'; + if(options.setWidth) target.style.width = source.offsetWidth + 'px'; + if(options.setHeight) target.style.height = source.offsetHeight + 'px'; + }, + + absolutize: function(element) { + element = $(element); + if (element.style.position == 'absolute') return; + Position.prepare(); + + var offsets = Position.positionedOffset(element); + var top = offsets[1]; + var left = offsets[0]; + var width = element.clientWidth; + var height = element.clientHeight; + + element._originalLeft = left - parseFloat(element.style.left || 0); + element._originalTop = top - parseFloat(element.style.top || 0); + element._originalWidth = element.style.width; + element._originalHeight = element.style.height; + + element.style.position = 'absolute'; + element.style.top = top + 'px';; + element.style.left = left + 'px';; + element.style.width = width + 'px';; + element.style.height = height + 'px';; + }, + + relativize: function(element) { + element = $(element); + if (element.style.position == 'relative') return; + Position.prepare(); + + element.style.position = 'relative'; + var top = parseFloat(element.style.top || 0) - (element._originalTop || 0); + var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0); + + element.style.top = top + 'px'; + element.style.left = left + 'px'; + element.style.height = element._originalHeight; + element.style.width = element._originalWidth; + } +} + +// Safari returns margins on body which is incorrect if the child is absolutely +// positioned. For performance reasons, redefine Position.cumulativeOffset for +// KHTML/WebKit only. +if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) { + Position.cumulativeOffset = function(element) { + var valueT = 0, valueL = 0; + do { + valueT += element.offsetTop || 0; + valueL += element.offsetLeft || 0; + if (element.offsetParent == document.body) + if (Element.getStyle(element, 'position') == 'absolute') break; + + element = element.offsetParent; + } while (element); + + return [valueL, valueT]; + } +} /** * -* Contains portions of Rico -* * 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 +* 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. +* 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
that has had Rico rounded corners added. + * + * It seems we cannot just set the background color for the + * outer
so each element used to create the + * corners must have its background color set individually. + * + * @param {DOM} theDiv - A child of the outer
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
that has had Rico rounded corners added. + * + * See changeColor (above) for algorithm explanation + * + * @param {DOM} theDiv A child of the outer
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
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 = "
" + el.innerHTML + "
" + }, + + _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= 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; } +} +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 }; +} + +/** +* @class +*/ +OpenLayers.Util = new Object(); + + + + +/** +* @class This class represents a screen coordinate, in x and y coordinates +*/ +OpenLayers.Pixel = Class.create(); +OpenLayers.Pixel.prototype = { + + /** @type float */ + x: 0.0, + + /** @type float */ + y: 0.0, + + /** + * @constructor + * + * @param {float} x + * @param {float} y + */ + initialize: function(x, y) { + this.x = x; + this.y = y; + }, + + /** + * @return string representation of Pixel. ex: "x=200.4,y=242.2" + * @type str + */ + toString:function() { + return ("x=" + this.x + ",y=" + this.y); + }, + + /** + * @type OpenLayers.Pixel + */ + copyOf:function() { + return new OpenLayers.Pixel(this.x, this.y); + }, + + /** + * @param {OpenLayers.Pixel} px + * + * @return whether or not the point passed in as parameter is equal to this + * @type bool + */ + equals:function(px) { + return ((this.x == px.x) && (this.y == px.y)); + }, + + /** + * @param {int} x + * @param {int} y + * + * @return a new Pixel with this pixel's x&y augmented by the + * values passed in. + * @type OpenLayers.Pixel + */ + add:function(x, y) { + return new OpenLayers.Pixel(this.x + x, this.y + y); + }, + + /** + * @param {OpenLayers.Pixel} px + * + * @return a new Pixel with this pixel's x&y augmented by the + * x&y values of the pixel passed in. + * @type OpenLayers.Pixel + */ + offset:function(px) { + return this.add(px.x, px.y); + }, + + /** @final @type str */ + CLASS_NAME: "OpenLayers.Pixel" +}; + + +/** +* @class This class represents a width and height pair +*/ +OpenLayers.Size = Class.create(); +OpenLayers.Size.prototype = { + + /** @type float */ + w: 0.0, + + /** @type float */ + h: 0.0, + + + /** + * @constructor + * + * @param {float} w + * @param {float} h + */ + initialize: function(w, h) { + this.w = w; + this.h = h; + }, + + /** + * @return String representation of OpenLayers.Size object. + * (ex. "w=55,h=66") + * @type String + */ + toString:function() { + return ("w=" + this.w + ",h=" + this.h); + }, + + /** + * @return New OpenLayers.Size object with the same w and h values + * @type OpenLayers.Size + */ + copyOf:function() { + return new OpenLayers.Size(this.w, this.h); + }, + + /** + * @param {OpenLayers.Size} sz + * @returns Boolean value indicating whether the passed-in OpenLayers.Size + * object has the same w and h components as this + * + * @type bool + */ + equals:function(sz) { + return ((this.w == sz.w) && (this.h == sz.h)); + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.Size" +}; + +/** +* @class This class represents a longitude and latitude pair +*/ +OpenLayers.LonLat = Class.create(); +OpenLayers.LonLat.prototype = { + + /** @type float */ + lon: 0.0, + + /** @type float */ + lat: 0.0, + + /** + * @constructor + * + * @param {float} lon + * @param {float} lat + */ + initialize: function(lon, lat) { + this.lon = lon; + this.lat = lat; + }, + + /** + * @return String representation of OpenLayers.LonLat object. + * (ex. "lon=5,lat=42") + * @type String + */ + toString:function() { + return ("lon=" + this.lon + ",lat=" + this.lat); + }, + + /** + * @return Shortened String representation of OpenLayers.LonLat object. + * (ex. "5, 42") + * @type String + */ + toShortString:function() { + return (this.lon + ", " + this.lat); + }, + + /** + * @return New OpenLayers.LonLat object with the same lon and lat values + * @type OpenLayers.LonLat + */ + copyOf:function() { + return new OpenLayers.LonLat(this.lon, this.lat); + }, + + /** + * @param {float} lon + * @param {float} lat + * + * @return A new OpenLayers.LonLat object with the lon and lat passed-in + * added to this's. + * @type OpenLayers.Pixel + */ + add:function(lon, lat) { + return new OpenLayers.LonLat(this.lon + lon, this.lat + lat); + }, + + /** + * @param {OpenLayers.LonLat} ll + * @returns Boolean value indicating whether the passed-in OpenLayers.LonLat + * object has the same lon and lat components as this + * + * @type bool + */ + equals:function(ll) { + return ((this.lon == ll.lon) && (this.lat == ll.lat)); + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.LonLat" +}; + +/** Alternative constructor that builds a new OpenLayers.LonLat from a +* parameter string +* +* @constructor +* +* @param {String} str Comma-separated Lon,Lat coordinate string. +* (ex. "5,40") * -**/ +* @returns New OpenLayers.LonLat object built from the passed-in String. +* @type OpenLayers.LonLat +*/ +OpenLayers.LonLat.fromString = function(str) { + var pair = str.split(","); + return new OpenLayers.LonLat(parseFloat(pair[0]), + parseFloat(pair[1])); +}; -var Prototype={Version:"1.4.0",ScriptFragment:"(?:)((\n|\r|.)*?)(?:)",emptyFunction:function(){ -},K:function(x){ -return x; -}}; -var Class={create:function(){ -return function(){ -this.initialize.apply(this,arguments); -}; -}}; -var Abstract=new Object(); -Object.extend=function(_2,_3){ -for(property in _3){ -_2[property]=_3[property]; -} -return _2; -}; -Object.inspect=function(_4){ -try{ -if(_4==undefined){ -return "undefined"; -} -if(_4==null){ -return "null"; -} -return _4.inspect?_4.inspect():_4.toString(); -} -catch(e){ -if(e instanceof RangeError){ -return "..."; -} -throw e; -} -}; -Function.prototype.bind=function(){ -var _5=this,args=$A(arguments),object=args.shift(); -return function(){ -return _5.apply(object,args.concat($A(arguments))); -}; -}; -Function.prototype.bindAsEventListener=function(_6){ -var _7=this; -return function(_8){ -return _7.call(_6,_8||window.event); -}; -}; -Object.extend(Number.prototype,{toColorPart:function(){ -var _9=this.toString(16); -if(this<16){ -return "0"+_9; -} -return _9; -},succ:function(){ -return this+1; -},times:function(_a){ -$R(0,this,true).each(_a); -return this; -}}); -var Try={these:function(){ -var _b; -for(var i=0;i]+>/gi,""); -},stripScripts:function(){ -return this.replace(new RegExp(Prototype.ScriptFragment,"img"),""); -},extractScripts:function(){ -var _13=new RegExp(Prototype.ScriptFragment,"img"); -var _14=new RegExp(Prototype.ScriptFragment,"im"); -return (this.match(_13)||[]).map(function(_15){ -return (_15.match(_14)||["",""])[1]; -}); -},evalScripts:function(){ -return this.extractScripts().map(eval); -},escapeHTML:function(){ -var div=document.createElement("div"); -var _17=document.createTextNode(this); -div.appendChild(_17); -return div.innerHTML; -},unescapeHTML:function(){ -var div=document.createElement("div"); -div.innerHTML=this.stripTags(); -return div.childNodes[0]?div.childNodes[0].nodeValue:""; -},toQueryParams:function(){ -var _19=this.match(/^\??(.*)$/)[1].split("&"); -return _19.inject({},function(_1a,_1b){ -var _1c=_1b.split("="); -_1a[_1c[0]]=_1c[1]; -return _1a; -}); -},toArray:function(){ -return this.split(""); -},camelize:function(){ -var _1d=this.split("-"); -if(_1d.length==1){ -return _1d[0]; -} -var _1e=this.indexOf("-")==0?_1d[0].charAt(0).toUpperCase()+_1d[0].substring(1):_1d[0]; -for(var i=1,len=_1d.length;i=(_49||_4a)){ -_49=_4a; -} -}); -return _49; -},min:function(_4c){ -var _4d; -this.each(function(_4e,_4f){ -_4e=(_4c||Prototype.K)(_4e,_4f); -if(_4e<=(_4d||_4e)){ -_4d=_4e; -} -}); -return _4d; -},partition:function(_50){ -var _51=[],falses=[]; -this.each(function(_52,_53){ -((_50||Prototype.K)(_52,_53)?_51:falses).push(_52); -}); -return [_51,falses]; -},pluck:function(_54){ -var _55=[]; -this.each(function(_56,_57){ -_55.push(_56[_54]); -}); -return _55; -},reject:function(_58){ -var _59=[]; -this.each(function(_5a,_5b){ -if(!_58(_5a,_5b)){ -_59.push(_5a); -} -}); -return _59; -},sortBy:function(_5c){ -return this.collect(function(_5d,_5e){ -return {value:_5d,criteria:_5c(_5d,_5e)}; -}).sort(function(_5f,_60){ -var a=_5f.criteria,b=_60.criteria; -return ab?1:0; -}).pluck("value"); -},toArray:function(){ -return this.collect(Prototype.K); -},zip:function(){ -var _62=Prototype.K,args=$A(arguments); -if(typeof args.last()=="function"){ -_62=args.pop(); -} -var _63=[this].concat(args).map($A); -return this.map(function(_64,_65){ -_62(_64=_63.pluck(_65)); -return _64; -}); -},inspect:function(){ -return "#"; -}}; -Object.extend(Enumerable,{map:Enumerable.collect,find:Enumerable.detect,select:Enumerable.findAll,member:Enumerable.include,entries:Enumerable.toArray}); -var $A=Array.from=function(_66){ -if(!_66){ -return []; -} -if(_66.toArray){ -return _66.toArray(); -}else{ -var _67=[]; -for(var i=0;i<_66.length;i++){ -_67.push(_66[i]); -} -return _67; -} -}; -Object.extend(Array.prototype,Enumerable); -Array.prototype._reverse=Array.prototype.reverse; -Object.extend(Array.prototype,{_each:function(_69){ -for(var i=0;i"; -}}; -function $H(_7d){ -var _7e=Object.extend({},_7d||{}); -Object.extend(_7e,Enumerable); -Object.extend(_7e,Hash); -return _7e; -} -ObjectRange=Class.create(); -Object.extend(ObjectRange.prototype,Enumerable); -Object.extend(ObjectRange.prototype,{initialize:function(_7f,end,_81){ -this.start=_7f; -this.end=end; -this.exclusive=_81; -},_each:function(_82){ -var _83=this.start; -do{ -_82(_83); -_83=_83.succ(); -}while(this.include(_83)); -},include:function(_84){ -if(_84=200&&this.transport.status<300); -},responseIsFailure:function(){ -return !this.responseIsSuccess(); -}}; -Ajax.Request=Class.create(); -Ajax.Request.Events=["Uninitialized","Loading","Loaded","Interactive","Complete"]; -Ajax.Request.prototype=Object.extend(new Ajax.Base(),{initialize:function(url,_92){ -this.transport=Ajax.getTransport(); -this.setOptions(_92); -this.request(url); -},request:function(url){ -var _94=this.options.parameters||""; -if(_94.length>0){ -_94+="&_="; -} -try{ -this.url=url; -if(this.options.method=="get"&&_94.length>0){ -this.url+=(this.url.match(/\?/)?"&":"?")+_94; -} -Ajax.Responders.dispatch("onCreate",this,this.transport); -this.transport.open(this.options.method,this.url,this.options.asynchronous); -if(this.options.asynchronous){ -this.transport.onreadystatechange=this.onStateChange.bind(this); -setTimeout((function(){ -this.respondToReadyState(1); -}).bind(this),10); -} -this.setRequestHeaders(); -var _95=this.options.postBody?this.options.postBody:_94; -this.transport.send(this.options.method=="post"?_95:null); -} -catch(e){ -this.dispatchException(e); -} -},setRequestHeaders:function(){ -var _96=["X-Requested-With","XMLHttpRequest","X-Prototype-Version",Prototype.Version]; -if(this.options.method=="post"){ -_96.push("Content-type","application/x-www-form-urlencoded"); -if(this.transport.overrideMimeType){ -_96.push("Connection","close"); -} -} -if(this.options.requestHeaders){ -_96.push.apply(_96,this.options.requestHeaders); -} -for(var i=0;i<_96.length;i+=2){ -this.transport.setRequestHeader(_96[i],_96[i+1]); -} -},onStateChange:function(){ -var _98=this.transport.readyState; -if(_98!=1){ -this.respondToReadyState(this.transport.readyState); -} -},header:function(_99){ -try{ -return this.transport.getResponseHeader(_99); -} -catch(e){ -} -},evalJSON:function(){ -try{ -return eval(this.header("X-JSON")); -} -catch(e){ -} -},evalResponse:function(){ -try{ -return eval(this.transport.responseText); -} -catch(e){ -this.dispatchException(e); -} -},respondToReadyState:function(_9a){ -var _9b=Ajax.Request.Events[_9a]; -var _9c=this.transport,json=this.evalJSON(); -if(_9b=="Complete"){ -try{ -(this.options["on"+this.transport.status]||this.options["on"+(this.responseIsSuccess()?"Success":"Failure")]||Prototype.emptyFunction)(_9c,json); -} -catch(e){ -this.dispatchException(e); -} -if((this.header("Content-type")||"").match(/^text\/javascript/i)){ -this.evalResponse(); -} -} -try{ -(this.options["on"+_9b]||Prototype.emptyFunction)(_9c,json); -Ajax.Responders.dispatch("on"+_9b,this,_9c,json); -} -catch(e){ -this.dispatchException(e); -} -if(_9b=="Complete"){ -this.transport.onreadystatechange=Prototype.emptyFunction; -} -},dispatchException:function(_9d){ -(this.options.onException||Prototype.emptyFunction)(this,_9d); -Ajax.Responders.dispatch("onException",this,_9d); -}}); -Ajax.Updater=Class.create(); -Object.extend(Object.extend(Ajax.Updater.prototype,Ajax.Request.prototype),{initialize:function(_9e,url,_a0){ -this.containers={success:_9e.success?$(_9e.success):$(_9e),failure:_9e.failure?$(_9e.failure):(_9e.success?null:$(_9e))}; -this.transport=Ajax.getTransport(); -this.setOptions(_a0); -var _a1=this.options.onComplete||Prototype.emptyFunction; -this.options.onComplete=(function(_a2,_a3){ -this.updateContent(); -_a1(_a2,_a3); -}).bind(this); -this.request(url); -},updateContent:function(){ -var _a4=this.responseIsSuccess()?this.containers.success:this.containers.failure; -var _a5=this.transport.responseText; -if(!this.options.evalScripts){ -_a5=_a5.stripScripts(); -} -if(_a4){ -if(this.options.insertion){ -new this.options.insertion(_a4,_a5); -}else{ -Element.update(_a4,_a5); -} -} -if(this.responseIsSuccess()){ -if(this.onComplete){ -setTimeout(this.onComplete.bind(this),10); -} -} -}}); -Ajax.PeriodicalUpdater=Class.create(); -Ajax.PeriodicalUpdater.prototype=Object.extend(new Ajax.Base(),{initialize:function(_a6,url,_a8){ -this.setOptions(_a8); -this.onComplete=this.options.onComplete; -this.frequency=(this.options.frequency||2); -this.decay=(this.options.decay||1); -this.updater={}; -this.container=_a6; -this.url=url; -this.start(); -},start:function(){ -this.options.onComplete=this.updateComplete.bind(this); -this.onTimerEvent(); -},stop:function(){ -this.updater.onComplete=undefined; -clearTimeout(this.timer); -(this.onComplete||Prototype.emptyFunction).apply(this,arguments); -},updateComplete:function(_a9){ -if(this.options.decay){ -this.decay=(_a9.responseText==this.lastText?this.decay*this.options.decay:1); -this.lastText=_a9.responseText; -} -this.timer=setTimeout(this.onTimerEvent.bind(this),this.decay*this.frequency*1000); -},onTimerEvent:function(){ -this.updater=new Ajax.Updater(this.container,this.url,this.options); -}}); -document.getElementsByClassName=function(_aa,_ab){ -var _ac=($(_ab)||document.body).getElementsByTagName("*"); -return $A(_ac).inject([],function(_ad,_ae){ -if(_ae.className.match(new RegExp("(^|\\s)"+_aa+"(\\s|$)"))){ -_ad.push(_ae); -} -return _ad; -}); -}; -if(!window.Element){ -var Element=new Object(); -} -Object.extend(Element,{visible:function(_af){ -return $(_af).style.display!="none"; -},toggle:function(){ -for(var i=0;i"; -return $A(div.childNodes[0].childNodes[0].childNodes); -}}; -var Insertion=new Object(); -Insertion.Before=Class.create(); -Insertion.Before.prototype=Object.extend(new Abstract.Insertion("beforeBegin"),{initializeRange:function(){ -this.range.setStartBefore(this.element); -},insertContent:function(_dc){ -_dc.each((function(_dd){ -this.element.parentNode.insertBefore(_dd,this.element); -}).bind(this)); -}}); -Insertion.Top=Class.create(); -Insertion.Top.prototype=Object.extend(new Abstract.Insertion("afterBegin"),{initializeRange:function(){ -this.range.selectNodeContents(this.element); -this.range.collapse(true); -},insertContent:function(_de){ -_de.reverse(false).each((function(_df){ -this.element.insertBefore(_df,this.element.firstChild); -}).bind(this)); -}}); -Insertion.Bottom=Class.create(); -Insertion.Bottom.prototype=Object.extend(new Abstract.Insertion("beforeEnd"),{initializeRange:function(){ -this.range.selectNodeContents(this.element); -this.range.collapse(this.element); -},insertContent:function(_e0){ -_e0.each((function(_e1){ -this.element.appendChild(_e1); -}).bind(this)); -}}); -Insertion.After=Class.create(); -Insertion.After.prototype=Object.extend(new Abstract.Insertion("afterEnd"),{initializeRange:function(){ -this.range.setStartAfter(this.element); -},insertContent:function(_e2){ -_e2.each((function(_e3){ -this.element.parentNode.insertBefore(_e3,this.element.nextSibling); -}).bind(this)); -}}); -Element.ClassNames=Class.create(); -Element.ClassNames.prototype={initialize:function(_e4){ -this.element=$(_e4); -},_each:function(_e5){ -this.element.className.split(/\s+/).select(function(_e6){ -return _e6.length>0; -})._each(_e5); -},set:function(_e7){ -this.element.className=_e7; -},add:function(_e8){ -if(this.include(_e8)){ -return; -} -this.set(this.toArray().concat(_e8).join(" ")); -},remove:function(_e9){ -if(!this.include(_e9)){ -return; -} -this.set(this.select(function(_ea){ -return _ea!=_e9; -}).join(" ")); -},toString:function(){ -return this.toArray().join(" "); -}}; -Object.extend(Element.ClassNames.prototype,Enumerable); -var Field={clear:function(){ -for(var i=0;i=0){ -opt=_118.options[index]; -_119=opt.value; -if(!_119&&!("value" in opt)){ -_119=opt.text; -} -} -return [_118.name,_119]; -},selectMany:function(_11a){ -var _11b=new Array(); -for(var i=0;i<_11a.length;i++){ -var opt=_11a.options[i]; -if(opt.selected){ -var _11e=opt.value; -if(!_11e&&!("value" in opt)){ -_11e=opt.text; -} -_11b.push(_11e); -} -} -return [_11a.name,_11b]; -}}; -var $F=Form.Element.getValue; -Abstract.TimedObserver=function(){ -}; -Abstract.TimedObserver.prototype={initialize:function(_11f,_120,_121){ -this.frequency=_120; -this.element=$(_11f); -this.callback=_121; -this.lastValue=this.getValue(); -this.registerCallback(); -},registerCallback:function(){ -setInterval(this.onTimerEvent.bind(this),this.frequency*1000); -},onTimerEvent:function(){ -var _122=this.getValue(); -if(this.lastValue!=_122){ -this.callback(this.element,_122); -this.lastValue=_122; -} -}}; -Form.Element.Observer=Class.create(); -Form.Element.Observer.prototype=Object.extend(new Abstract.TimedObserver(),{getValue:function(){ -return Form.Element.getValue(this.element); -}}); -Form.Observer=Class.create(); -Form.Observer.prototype=Object.extend(new Abstract.TimedObserver(),{getValue:function(){ -return Form.serialize(this.element); -}}); -Abstract.EventObserver=function(){ -}; -Abstract.EventObserver.prototype={initialize:function(_123,_124){ -this.element=$(_123); -this.callback=_124; -this.lastValue=this.getValue(); -if(this.element.tagName.toLowerCase()=="form"){ -this.registerFormCallbacks(); -}else{ -this.registerCallback(this.element); -} -},onElementEvent:function(){ -var _125=this.getValue(); -if(this.lastValue!=_125){ -this.callback(this.element,_125); -this.lastValue=_125; -} -},registerFormCallbacks:function(){ -var _126=Form.getElements(this.element); -for(var i=0;i<_126.length;i++){ -this.registerCallback(_126[i]); -} -},registerCallback:function(_128){ -if(_128.type){ -switch(_128.type.toLowerCase()){ -case "checkbox": -case "radio": -Event.observe(_128,"click",this.onElementEvent.bind(this)); -break; -case "password": -case "text": -case "textarea": -case "select-one": -case "select-multiple": -Event.observe(_128,"change",this.onElementEvent.bind(this)); -break; -} -} -}}; -Form.Element.EventObserver=Class.create(); -Form.Element.EventObserver.prototype=Object.extend(new Abstract.EventObserver(),{getValue:function(){ -return Form.Element.getValue(this.element); -}}); -Form.EventObserver=Class.create(); -Form.EventObserver.prototype=Object.extend(new Abstract.EventObserver(),{getValue:function(){ -return Form.serialize(this.element); -}}); -if(!window.Event){ -var Event=new Object(); -} -Object.extend(Event,{KEY_BACKSPACE:8,KEY_TAB:9,KEY_RETURN:13,KEY_ESC:27,KEY_LEFT:37,KEY_UP:38,KEY_RIGHT:39,KEY_DOWN:40,KEY_DELETE:46,element:function(_129){ -return _129.target||_129.srcElement; -},isLeftClick:function(_12a){ -return (((_12a.which)&&(_12a.which==1))||((_12a.button)&&(_12a.button==1))); -},pointerX:function(_12b){ -return _12b.pageX||(_12b.clientX+(document.documentElement.scrollLeft||document.body.scrollLeft)); -},pointerY:function(_12c){ -return _12c.pageY||(_12c.clientY+(document.documentElement.scrollTop||document.body.scrollTop)); -},stop:function(_12d){ -if(_12d.preventDefault){ -_12d.preventDefault(); -_12d.stopPropagation(); -}else{ -_12d.returnValue=false; -_12d.cancelBubble=true; -} -},findElement:function(_12e,_12f){ -var _130=Event.element(_12e); -while(_130.parentNode&&(!_130.tagName||(_130.tagName.toUpperCase()!=_12f.toUpperCase()))){ -_130=_130.parentNode; -} -return _130; -},observers:false,_observeAndCache:function(_131,name,_133,_134){ -if(!this.observers){ -this.observers=[]; -} -if(_131.addEventListener){ -this.observers.push([_131,name,_133,_134]); -_131.addEventListener(name,_133,_134); -}else{ -if(_131.attachEvent){ -this.observers.push([_131,name,_133,_134]); -_131.attachEvent("on"+name,_133); -} -} -},unloadCache:function(){ -if(!Event.observers){ -return; -} -for(var i=0;i=this.offset[1]&&y=this.offset[0]&&x=this.offset[1]&&this.ycomp=this.offset[0]&&this.xcomp"+el.innerHTML+"
"; -},_roundTopCorners:function(el,_184,_185){ -var _186=this._createCorner(_185); -for(var i=0;i=0;i--){ -_18b.appendChild(this._createCornerSlice(_189,_18a,i,"bottom")); -} -el.style.paddingBottom=0; -el.appendChild(_18b); -},_createCorner:function(_18d){ -var _18e=document.createElement("div"); -_18e.style.backgroundColor=(this._isTransparent()?"transparent":_18d); -return _18e; -},_createCornerSlice:function(_18f,_190,n,_192){ -var _193=document.createElement("span"); -var _194=_193.style; -_194.backgroundColor=_18f; -_194.display="block"; -_194.height="1px"; -_194.overflow="hidden"; -_194.fontSize="1px"; -var _195=this._borderColor(_18f,_190); -if(this.options.border&&n==0){ -_194.borderTopStyle="solid"; -_194.borderTopWidth="1px"; -_194.borderLeftWidth="0px"; -_194.borderRightWidth="0px"; -_194.borderBottomWidth="0px"; -_194.height="0px"; -_194.borderColor=_195; -}else{ -if(_195){ -_194.borderColor=_195; -_194.borderStyle="solid"; -_194.borderWidth="0px 1px"; -} -} -if(!this.options.compact&&(n==(this.options.numSlices-1))){ -_194.height="2px"; -} -this._setMargin(_193,n,_192); -this._setBorder(_193,n,_192); -return _193; -},_setOptions:function(_196){ -this.options={corners:"all",color:"fromElement",bgColor:"fromParent",blend:true,border:false,compact:false}; -Object.extend(this.options,_196||{}); -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(_197,_198){ -if(_197=="transparent"){ -return _198; -}else{ -if(this.options.border){ -return this.options.border; -}else{ -if(this.options.blend){ -return this._blend(_198,_197); -}else{ -return ""; -} -} -} -},_setMargin:function(el,n,_19b){ -var _19c=this._marginSize(n); -var _19d=_19b=="top"?this._whichSideTop():this._whichSideBottom(); -if(_19d=="left"){ -el.style.marginLeft=_19c+"px"; -el.style.marginRight="0px"; -}else{ -if(_19d=="right"){ -el.style.marginRight=_19c+"px"; -el.style.marginLeft="0px"; -}else{ -el.style.marginLeft=_19c+"px"; -el.style.marginRight=_19c+"px"; -} -} -},_setBorder:function(el,n,_1a0){ -var _1a1=this._borderSize(n); -var _1a2=_1a0=="top"?this._whichSideTop():this._whichSideBottom(); -if(_1a2=="left"){ -el.style.borderLeftWidth=_1a1+"px"; -el.style.borderRightWidth="0px"; -}else{ -if(_1a2=="right"){ -el.style.borderRightWidth=_1a1+"px"; -el.style.borderLeftWidth="0px"; -}else{ -el.style.borderLeftWidth=_1a1+"px"; -el.style.borderRightWidth=_1a1+"px"; -} -} -if(this.options.border!=false){ -el.style.borderLeftWidth=_1a1+"px"; -} -el.style.borderRightWidth=_1a1+"px"; -},_marginSize:function(n){ -if(this._isTransparent()){ -return 0; -} -var _1a4=[5,3,2,1]; -var _1a5=[3,2,1,0]; -var _1a6=[2,1]; -var _1a7=[1,0]; -if(this.options.compact&&this.options.blend){ -return _1a7[n]; -}else{ -if(this.options.compact){ -return _1a6[n]; -}else{ -if(this.options.blend){ -return _1a5[n]; -}else{ -return _1a4[n]; -} -} -} -},_borderSize:function(n){ -var _1a9=[5,3,2,1]; -var _1aa=[2,1,1,1]; -var _1ab=[1,0]; -var _1ac=[0,2,0,0]; -if(this.options.compact&&(this.options.blend||this._isTransparent())){ -return 1; -}else{ -if(this.options.compact){ -return _1ab[n]; -}else{ -if(this.options.blend){ -return _1aa[n]; -}else{ -if(this.options.border){ -return _1ac[n]; -}else{ -if(this._isTransparent()){ -return _1a9[n]; -} -} -} -} -} -return 0; -},_hasString:function(str){ -for(var i=1;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; -}}; -_OPENLAYERS_SFL_=true; -OpenLayers=new Object(); -OpenLayers._scriptName="lib/OpenLayers.js"; -OpenLayers._getScriptLocation=function(){ -var _1b4=""; -var _1b5=OpenLayers._scriptName; -var _1b6=document.getElementsByTagName("script"); -for(var i=0;i<_1b6.length;i++){ -var src=_1b6[i].getAttribute("src"); -if(src){ -var _1b9=src.lastIndexOf(_1b5); -if((_1b9>-1)&&(_1b9+_1b5.length==src.length)){ -_1b4=src.slice(0,-_1b5.length); -break; -} -} -} -return _1b4; -}; -if(typeof (_OPENLAYERS_SFL_)=="undefined"){ -(function(){ -var _1ba=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/Grid.js","OpenLayers/Layer/Markers.js","OpenLayers/Layer/Text.js","OpenLayers/Layer/WMS.js","OpenLayers/Layer/WFS.js","OpenLayers/Popup/Anchored.js","OpenLayers/Popup/AnchoredBubble.js","OpenLayers/Control.js","OpenLayers/Control/MouseDefaults.js","OpenLayers/Control/KeyboardDefaults.js","OpenLayers/Control/PanZoom.js","OpenLayers/Control/PanZoomBar.js","OpenLayers/Control/LayerSwitcher.js"); -var _1bb=""; -var host=OpenLayers._getScriptLocation()+"lib/"; -var _1bd=1; -try{ -x=Prototype; -} -catch(e){ -_1bd=0; -} -for(var i=_1bd;i<_1ba.length;i++){ -var _1bf=""; -_1bb+=_1bf; -} -document.write(_1bb); -})(); -} -OpenLayers.ProxyHost="/viewer/Crossbrowser/blindproxy.py?url="; -OpenLayers.nullHandler=function(_1c0){ -}; -OpenLayers.loadURL=function(uri,_1c2,_1c3,_1c4,_1c5){ -if(OpenLayers.ProxyHost&&uri.startsWith("http")){ -uri=OpenLayers.ProxyHost+escape(uri); -if(!_1c2){ -_1c2=""; -} -_1c2+="&cachehack="+new Date().getTime(); -} -var _1c6; -var _1c7; -var _1c8=null; -var _1c9=null; -if(_1c4){ -_1c6=_1c3.handlers[_1c4]; -_1c8=_1c3; -}else{ -_1c6=OpenLayers.nullHandler; -} -if(_1c5){ -_1c7=_1c3.handlers[_1c5]; -_1c9=_1c3; -}else{ -_1c7=OpenLayers.nullHandler; -} -new Ajax.Request(uri,{method:"get",parameters:_1c2,onComplete:_1c6.bind(_1c8),onFailure:_1c7.bind(_1c9)}); -}; -OpenLayers.parseXMLString=function(text){ -var _1cb=text.indexOf("<"); -if(_1cb>0){ -text=text.substring(_1cb); -} -var _1cc=Try.these(function(){ -var _1cd=new ActiveXObject("Microsoft.XMLDOM"); -_1cd.loadXML(text); -return _1cd; -},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 _1cc; -}; -OpenLayers.Control=Class.create(); -OpenLayers.Control.prototype={map:null,div:null,position:null,initialize:function(_1cf){ -Object.extend(this,_1cf); -},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; -},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(){ -this.map=null; -},CLASS_NAME:"OpenLayers.Control"}; -OpenLayers.Events=Class.create(); -OpenLayers.Events.prototype={BROWSER_EVENTS:["mouseover","mouseout","mousedown","mouseup","mousemove","click","dblclick","resize","focus","blur"],listeners:null,object:null,div:null,eventTypes:null,initialize:function(_1d2,div,_1d4){ -this.listeners={}; -this.object=_1d2; -this.div=div; -this.eventTypes=_1d4; -if(_1d4){ -for(var i=0;i0){ -var data=this.processXMLNode(_1ec); -_1ed=new Array(_1eb,data.lonlat,data,data.id); -} -OpenLayers.Feature.prototype.initialize.apply(this,_1ed); -if(arguments.length>0){ -this.createMarker(); -this.layer.addMarker(this.marker); -} -},processXMLNode:function(_1ef){ -},CLASS_NAME:"OpenLayers.Feature.WFS"}); -OpenLayers.Icon=Class.create(); -OpenLayers.Icon.prototype={url:null,size:null,offset:null,calculateOffset:null,imageDiv:null,px:null,initialize:function(url,size,_1f2,_1f3){ -this.url=url; -this.size=(size)?size:new OpenLayers.Size(20,20); -this.offset=(_1f2)?_1f2:new OpenLayers.Pixel(0,0); -this.calculateOffset=_1f3; -this.imageDiv=OpenLayers.Util.createAlphaImageDiv(); -},clone:function(){ -return new OpenLayers.Icon(this.size,this.url,this.offset); -},setSize:function(size){ -if(size!=null){ -this.size=size; -} -this.draw(); -},draw:function(px){ -OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv,null,null,this.size,this.url,"absolute"); -this.moveTo(px); -return this.imageDiv; -},moveTo:function(px){ -if(px!=null){ -this.px=px; -} -if((this.px!=null)&&(this.imageDiv!=null)){ -if(this.calculateOffset){ -this.offset=this.calculateOffset(this.size); -} -var _1f7=this.px.offset(this.offset); -OpenLayers.Util.modifyAlphaImageDiv(this.imageDiv,null,_1f7); -} -},CLASS_NAME:"OpenLayers.Icon"}; -OpenLayers.Layer=Class.create(); -OpenLayers.Layer.prototype={name:null,div:null,map:null,projection:null,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:function(){ -this.map=null; -},moveTo:function(_1f9,_1fa){ -return; -},getVisibility:function(){ -return (this.div.style.display!="none"); -},setVisibility:function(_1fb){ -this.div.style.display=(_1fb)?"block":"none"; -if((_1fb)&&(this.map!=null)){ -this.moveTo(this.map.getExtent()); -} -},CLASS_NAME:"OpenLayers.Layer"}; -OpenLayers.Marker=Class.create(); -OpenLayers.Marker.prototype={icon:null,lonlat:null,events:null,map:null,initialize:function(_1fc,icon){ -this.lonlat=_1fc; -this.icon=(icon)?icon:OpenLayers.Marker.defaultIcon(); -this.events=new OpenLayers.Events(this,this.icon.imageDiv,null); -},draw:function(px){ -return this.icon.draw(px); -},moveTo:function(px){ -if((px!=null)&&(this.icon!=null)){ -this.icon.moveTo(px); -} -},inflate:function(_200){ -if(this.icon){ -var _201=new OpenLayers.Size(this.icon.size.w*_200,this.icon.size.h*_200); -this.icon.setSize(_201); -} -},CLASS_NAME:"OpenLayers.Marker"}; -OpenLayers.Marker.defaultIcon=function(){ -var url=OpenLayers.Util.getImagesLocation()+"marker.png"; -var size=new OpenLayers.Size(21,25); -var _204=function(size){ -return new OpenLayers.Pixel(-(size.w/2),-size.h); -}; -return new OpenLayers.Icon(url,size,null,_204); -}; -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={events:null,id:"",lonlat:null,div:null,size:null,contentHTML:"",backgroundColor:"",opacity:"",border:"",map:null,initialize:function(id,_207,size,_209){ -OpenLayers.Popup.count+=1; -this.id=(id!=null)?id:"Popup"+OpenLayers.Popup.count; -this.lonlat=_207; -this.size=(size!=null)?size:new OpenLayers.Size(OpenLayers.Popup.WIDTH,OpenLayers.Popup.HEIGHT); -if(_209!=null){ -this.contentHTML=_209; -} -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.div)&&(this.div.parentNode)){ -this.div.parentNode.removeChild(this.div); -} -this.div=null; -this.map=null; -},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; -},updatePosition:function(){ -if((this.lonlat)&&(this.map)){ -var px=this.map.getLayerPxFromLonLat(this.lonlat); -this.moveTo(px); -} -},moveTo:function(px){ -if((px!=null)&&(this.div!=null)){ -this.div.style.left=px.x+"px"; -this.div.style.top=px.y+"px"; -} -},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); -},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; -} -},setBackgroundColor:function(_20e){ -if(_20e!=undefined){ -this.backgroundColor=_20e; -} -if(this.div!=null){ -this.div.style.backgroundColor=this.backgroundColor; -} -},setOpacity:function(_20f){ -if(_20f!=undefined){ -this.opacity=_20f; -} -if(this.div!=null){ -this.div.style.opacity=this.opacity; -this.div.style.filter="alpha(opacity="+this.opacity*100+")"; -} -},setBorder:function(_210){ -if(_210!=undefined){ -this.border=_210; -} -if(this.div!=null){ -this.div.style.border=this.border; -} -},setContentHTML:function(_211){ -if(_211!=null){ -this.contentHTML=_211; -} -if(this.div!=null){ -this.div.innerHTML=this.contentHTML; -} -},CLASS_NAME:"OpenLayers.Popup"}; -OpenLayers.Tile=Class.create(); -OpenLayers.Tile.prototype={layer:null,url:null,bounds:null,size:null,position:null,initialize:function(_212,_213,_214,url,size){ -if(arguments.length>0){ -this.layer=_212; -this.position=_213; -this.bounds=_214; -this.url=url; -this.size=size; -} -},destroy:function(){ -this.layer=null; -this.bounds=null; -this.size=null; -},draw:function(){ -},remove:function(){ -},getPosition:function(){ -return this.position; -},CLASS_NAME:"OpenLayers.Tile"}; -OpenLayers.Util=new Object(); -OpenLayers.Pixel=Class.create(); -OpenLayers.Pixel.prototype={x:0,y:0,initialize:function(x,y){ -this.x=x; -this.y=y; -},toString:function(){ -return ("x="+this.x+",y="+this.y); -},copyOf:function(){ -return new OpenLayers.Pixel(this.x,this.y); -},equals:function(px){ -return ((this.x==px.x)&&(this.y==px.y)); -},add:function(x,y){ -return new OpenLayers.Pixel(this.x+x,this.y+y); -},offset:function(px){ -return this.add(px.x,px.y); -},CLASS_NAME:"OpenLayers.Pixel"}; -OpenLayers.Size=Class.create(); -OpenLayers.Size.prototype={w:0,h:0,initialize:function(w,h){ -this.w=w; -this.h=h; -},toString:function(){ -return ("w="+this.w+",h="+this.h); -},copyOf:function(){ -return new OpenLayers.Size(this.w,this.h); -},equals:function(sz){ -return ((this.w==sz.w)&&(this.h==sz.h)); -},CLASS_NAME:"OpenLayers.Size"}; -OpenLayers.LonLat=Class.create(); -OpenLayers.LonLat.prototype={lon:0,lat:0,initialize:function(lon,lat){ -this.lon=lon; -this.lat=lat; -},toString:function(){ -return ("lon="+this.lon+",lat="+this.lat); -},toShortString:function(){ -return (this.lon+", "+this.lat); -},copyOf:function(){ -return new OpenLayers.LonLat(this.lon,this.lat); -},add:function(lon,lat){ -return new OpenLayers.LonLat(this.lon+lon,this.lat+lat); -},equals:function(ll){ -return ((this.lon==ll.lon)&&(this.lat==ll.lat)); -},CLASS_NAME:"OpenLayers.LonLat"}; -OpenLayers.LonLat.fromString=function(str){ -var pair=str.split(","); -return new OpenLayers.LonLat(parseFloat(pair[0]),parseFloat(pair[1])); -}; -OpenLayers.Bounds=Class.create(); -OpenLayers.Bounds.prototype={left:0,bottom:0,right:0,top:0,initialize:function(left,_228,_229,top){ -this.left=left; -this.bottom=_228; -this.right=_229; -this.top=top; -},copyOf:function(){ -return new OpenLayers.Bounds(this.left,this.bottom,this.right,this.top); -},equals:function(_22b){ -return ((this.left==_22b.left)&&(this.right==_22b.right)&&(this.top==_22b.top)&&(this.bottom==_22b.bottom)); -},toString:function(){ -return ("left-bottom=("+this.left+","+this.bottom+")"+" right-top=("+this.right+","+this.top+")"); -},toBBOX:function(){ -return (this.left+","+this.bottom+","+this.right+","+this.top); -},getWidth:function(){ -return (this.right-this.left); -},getHeight:function(){ -return (this.top-this.bottom); -},getSize:function(){ -return new OpenLayers.Size(this.getWidth(),this.getHeight()); -},getCenterPixel:function(){ -return new OpenLayers.Pixel(this.left+(this.getWidth()/2),this.bottom+(this.getHeight()/2)); -},getCenterLonLat:function(){ -return new OpenLayers.LonLat(this.left+(this.getWidth()/2),this.bottom+(this.getHeight()/2)); -},add:function(x,y){ -return new OpenLayers.Box(this.left+x,this.bottom+y,this.right+x,this.top+y); -},contains:function(x,y,_230){ -if(_230==null){ -_230=true; -} -var _231=false; -if(_230){ -_231=((x>=this.left)&&(x<=this.right)&&(y>=this.bottom)&&(y<=this.top)); -}else{ -_231=((x>this.left)&&(xthis.bottom)&&(y=this.left)&&(_232.left<=this.right); -_236=(_232.top>=this.bottom)&&(_232.top<=this.top); -_237=(_232.right>=this.left)&&(_232.right<=this.right); -_238=(_232.bottom>=this.bottom)&&(_232.bottom<=this.top); -}else{ -_235=(_232.left>this.left)&&(_232.leftthis.bottom)&&(_232.topthis.left)&&(_232.rightthis.bottom)&&(_232.bottom=5.5)&&(_262<7)); -}; -OpenLayers.Util.modifyAlphaImageDiv=function(div,id,px,sz,_267,_268,_269,_26a){ -OpenLayers.Util.modifyDOMElement(div,id,px,sz); -var img=div.childNodes[0]; -if(_267){ -img.src=_267; -} -OpenLayers.Util.modifyDOMElement(img,div.id+"_innerImage",null,sz,"relative",_269); -if(OpenLayers.Util.alphaHack()){ -div.style.display="inline-block"; -if(_26a==null){ -_26a="scale"; -} -div.style.filter="progid:DXImageTransform.Microsoft"+".AlphaImageLoader(src='"+img.src+"', "+"sizingMethod='"+_26a+"')"; -img.style.filter="progid:DXImageTransform.Microsoft"+".Alpha(opacity=0)"; -} -}; -OpenLayers.Util.createAlphaImageDiv=function(id,px,sz,_26f,_270,_271,_272){ -var div=OpenLayers.Util.createDiv(); -var img=OpenLayers.Util.createImage(); -div.appendChild(img); -OpenLayers.Util.modifyAlphaImageDiv(div,id,px,sz,_26f,_270,_271,_272); -return div; -}; -OpenLayers.Util.getParameterString=function(_275){ -paramsArray=new Array(); -for(var key in _275){ -var _277=_275[key]; -if(typeof _277=="function"){ -continue; -} -paramsArray.push(key+"="+_277); -} -return paramsArray.join("&"); -}; -OpenLayers.Util.getImagesLocation=function(){ -return OpenLayers._getScriptLocation()+"img/"; -}; -OpenLayers.Util.applyDefaults=function(to,from){ -for(var key in from){ -if(to[key]==null){ -to[key]=from[key]; -} -} -return to; -}; -OpenLayers.Util.getNodes=function(p,_27c){ -var _27d=Try.these(function(){ -return OpenLayers.Util._getNodes(p.documentElement.childNodes,_27c); -},function(){ -return OpenLayers.Util._getNodes(p.childNodes,_27c); -}); -return _27d; -}; -OpenLayers.Util._getNodes=function(_27e,_27f){ -var _280=new Array(); -for(var i=0;i<_27e.length;i++){ -if(_27e[i].nodeName==_27f){ -_280.push(_27e[i]); -} -} -return _280; -}; -OpenLayers.Util.getTagText=function(_282,item,_284){ -var _285=OpenLayers.Util.getNodes(_282,item); -if(_285&&(_285.length>0)){ -if(!_284){ -_284=0; -} -if(_285[_284].childNodes.length>1){ -return _285.childNodes[1].nodeValue; -}else{ -if(_285[_284].childNodes.length==1){ -return _285[_284].firstChild.nodeValue; -} -} -}else{ -return ""; -} -}; -OpenLayers.Util.mouseLeft=function(evt,div){ -var _288=(evt.relatedTarget)?evt.relatedTarget:evt.toElement; -while(_288!=div&&_288!=null){ -_288=_288.parentNode; -} -return (_288!=div); -}; -Rico.Color=Class.create(); -Rico.Color.prototype={initialize:function(red,_28a,blue){ -this.rgb={r:red,g:_28a,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){ -var hsb=this.asHSB(); -hsb.h=h; -this.rgb=Rico.Color.HSBtoRGB(hsb.h,hsb.s,hsb.b); -},setSaturation:function(s){ -var hsb=this.asHSB(); -hsb.s=s; -this.rgb=Rico.Color.HSBtoRGB(hsb.h,hsb.s,hsb.b); -},setBrightness:function(b){ -var hsb=this.asHSB(); -hsb.b=b; -this.rgb=Rico.Color.HSBtoRGB(hsb.h,hsb.s,hsb.b); -},darken:function(_295){ -var hsb=this.asHSB(); -this.rgb=Rico.Color.HSBtoRGB(hsb.h,hsb.s,Math.max(hsb.b-_295,0)); -},brighten:function(_297){ -var hsb=this.asHSB(); -this.rgb=Rico.Color.HSBtoRGB(hsb.h,hsb.s,Math.min(hsb.b+_297,1)); -},blend:function(_299){ -this.rgb.r=Math.floor((this.rgb.r+_299.rgb.r)/2); -this.rgb.g=Math.floor((this.rgb.g+_299.rgb.g)/2); -this.rgb.b=Math.floor((this.rgb.b+_299.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(_29b){ -if(_29b.length==4){ -var _29c=_29b; -var _29d="#"; -for(var i=1;i<4;i++){ -_29d+=(_29c.charAt(i)+_29c.charAt(i)); -} -} -if(_29d.indexOf("#")==0){ -_29d=_29d.substring(1); -} -var red=_29d.substring(0,2); -var _2a0=_29d.substring(2,4); -var blue=_29d.substring(4,6); -return new Rico.Color(parseInt(red,16),parseInt(_2a0,16),parseInt(blue,16)); -}; -Rico.Color.createColorFromBackground=function(elem){ -var _2a3=RicoUtil.getElementsComputedStyle($(elem),"backgroundColor","background-color"); -if(_2a3=="transparent"&&elem.parentNode){ -return Rico.Color.createColorFromBackground(elem.parentNode); -} -if(_2a3==null){ -return new Rico.Color(255,255,255); -} -if(_2a3.indexOf("rgb(")==0){ -var _2a4=_2a3.substring(4,_2a3.length-1); -var _2a5=_2a4.split(","); -return new Rico.Color(parseInt(_2a5[0]),parseInt(_2a5[1]),parseInt(_2a5[2])); -}else{ -if(_2a3.indexOf("#")==0){ -return Rico.Color.createFromHex(_2a3); -}else{ -return new Rico.Color(255,255,255); -} -} -}; -Rico.Color.HSBtoRGB=function(hue,_2a7,_2a8){ -var red=0; -var _2aa=0; -var blue=0; -if(_2a7==0){ -red=parseInt(_2a8*255+0.5); -_2aa=red; -blue=red; -}else{ -var h=(hue-Math.floor(hue))*6; -var f=h-Math.floor(h); -var p=_2a8*(1-_2a7); -var q=_2a8*(1-_2a7*f); -var t=_2a8*(1-(_2a7*(1-f))); -switch(parseInt(h)){ -case 0: -red=(_2a8*255+0.5); -_2aa=(t*255+0.5); -blue=(p*255+0.5); -break; -case 1: -red=(q*255+0.5); -_2aa=(_2a8*255+0.5); -blue=(p*255+0.5); -break; -case 2: -red=(p*255+0.5); -_2aa=(_2a8*255+0.5); -blue=(t*255+0.5); -break; -case 3: -red=(p*255+0.5); -_2aa=(q*255+0.5); -blue=(_2a8*255+0.5); -break; -case 4: -red=(t*255+0.5); -_2aa=(p*255+0.5); -blue=(_2a8*255+0.5); -break; -case 5: -red=(_2a8*255+0.5); -_2aa=(p*255+0.5); -blue=(q*255+0.5); -break; -} -} -return {r:parseInt(red),g:parseInt(_2aa),b:parseInt(blue)}; -}; -Rico.Color.RGBtoHSB=function(r,g,b){ -var hue; -var _2b5; -var _2b6; -var cmax=(r>g)?r:g; -if(b>cmax){ -cmax=b; -} -var cmin=(r=this.left)&&(x<=this.right)&&(y>=this.bottom)&&(y<=this.top)); -}else{ -_2d4=((x>this.left)&&(xthis.bottom)&&(y=this.left)&&(_2d5.left<=this.right); -_2d9=(_2d5.top>=this.bottom)&&(_2d5.top<=this.top); -_2da=(_2d5.right>=this.left)&&(_2d5.right<=this.right); -_2db=(_2d5.bottom>=this.bottom)&&(_2d5.bottom<=this.top); -}else{ -_2d8=(_2d5.left>this.left)&&(_2d5.leftthis.bottom)&&(_2d5.topthis.left)&&(_2d5.rightthis.bottom)&&(_2d5.bottom=5.5)&&(_2fc<7)&&(document.body.filters)); -}; -OpenLayers.Util.createAlphaImage=function(img,sz,xy,_300,id,_302){ -if(OpenLayers.Util.alphaHack()){ -var _303=ol.Util.createImage(img,sz,new OpenLayers.Pixel(0,0),id+"img",_302); -var div=OpenLayers.Util.createDiv(id,xy,sz); -div.appendChild(_303); -div.style.display="inline-block"; -div.style.filter="progid:DXImageTransform.Microsoft"+".AlphaImageLoader(src='"+img+"')"; -_303.style.filter="progid:DXImageTransform.Microsoft"+".Alpha(opacity=0)"; -return div; -}else{ -var _305=ol.Util.createImage(img,sz,xy,id+"img",_302); -return _305; -} -}; -OpenLayers.Util.getParameterString=function(_306){ -paramsArray=new Array(); -for(var key in _306){ -var _308=_306[key]; -if(typeof _308=="function"){ -continue; -} -paramsArray.push(key+"="+_308); -} -return paramsArray.join("&"); -}; -OpenLayers.Util.getImagesLocation=function(){ -return OpenLayers._getScriptLocation()+"img/"; -}; -OpenLayers.Util.applyDefaults=function(to,from){ -for(var key in from){ -if(to[key]==null){ -to[key]=from[key]; -} -} -return to; -}; -OpenLayers.Util.getNodes=function(p,_30d){ -var _30e=Try.these(function(){ -return OpenLayers.Util._getNodes(p.documentElement.childNodes,_30d); -},function(){ -return OpenLayers.Util._getNodes(p.childNodes,_30d); -}); -return _30e; -}; -OpenLayers.Util._getNodes=function(_30f,_310){ -var _311=new Array(); -for(var i=0;i<_30f.length;i++){ -if(_30f[i].nodeName==_310){ -_311.push(_30f[i]); -} -} -return _311; -}; -OpenLayers.Util.getTagText=function(_313,item,_315){ -var _316=OpenLayers.Util.getNodes(_313,item); -if(_316&&(_316.length>0)){ -if(!_315){ -_315=0; -} -if(_316[_315].childNodes.length>1){ -return _316.childNodes[1].nodeValue; -}else{ -if(_316[_315].childNodes.length==1){ -return _316[_315].firstChild.nodeValue; -} -} -}else{ -return ""; -} -}; -OpenLayers.Util.mouseLeft=function(evt,div){ -var _319=(evt.relatedTarget)?evt.relatedTarget:evt.toElement; -while(_319!=div&&_319!=null){ -_319=_319.parentNode; -} -return (_319!=div); -}; -OpenLayers.Control.PanZoom=Class.create(); -OpenLayers.Control.PanZoom.X=4; -OpenLayers.Control.PanZoom.Y=4; -OpenLayers.Control.PanZoom.prototype=Object.extend(new OpenLayers.Control(),{buttons:null,initialize:function(){ -OpenLayers.Control.prototype.initialize.apply(this,arguments); -this.position=new OpenLayers.Pixel(OpenLayers.Control.PanZoom.X,OpenLayers.Control.PanZoom.Y); -},draw:function(px){ -OpenLayers.Control.prototype.draw.apply(this,arguments); -px=this.position; -this.buttons=new Array(); -var sz=new OpenLayers.Size(18,18); -var _31c=new OpenLayers.Pixel(px.x+sz.w/2,px.y); -this._addButton("panup","north-mini.png",_31c,sz); -px.y=_31c.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",_31c.add(0,sz.h*2),sz); -this._addButton("zoomin","zoom-plus-mini.png",_31c.add(0,sz.h*3+5),sz); -this._addButton("zoomout","zoom-minus-mini.png",_31c.add(0,sz.h*5+5),sz); -return this.div; -},_addButton:function(id,img,xy,sz){ -var _321=OpenLayers.Util.getImagesLocation()+img; -var btn=OpenLayers.Util.createAlphaImageDiv("OpenLayers_Control_PanZoom_"+id,xy,sz,_321,"absolute"); -this.div.appendChild(btn); -btn.onmousedown=this.buttonDown.bindAsEventListener(btn); -btn.ondblclick=this.doubleClick.bindAsEventListener(btn); -btn.action=id; -btn.map=this.map; -this.buttons.push(btn); -return btn; -},doubleClick:function(evt){ -Event.stop(evt); -},buttonDown:function(evt){ -switch(this.action){ -case "panup": -var _325=this.map.getResolution(); -var _326=this.map.getCenter(); -this.map.setCenter(new OpenLayers.LonLat(_326.lon,_326.lat+(_325*50))); -break; -case "pandown": -var _327=this.map.getResolution(); -var _328=this.map.getCenter(); -this.map.setCenter(new OpenLayers.LonLat(_328.lon,_328.lat-(_327*50))); -break; -case "panleft": -var _329=this.map.getResolution(); -var _32a=this.map.getCenter(); -this.map.setCenter(new OpenLayers.LonLat(_32a.lon-(_329*50),_32a.lat)); -break; -case "panright": -var _32b=this.map.getResolution(); -var _32c=this.map.getCenter(); -this.map.setCenter(new OpenLayers.LonLat(_32c.lon+(_32b*50),_32c.lat)); -break; -case "zoomin": -this.map.zoomIn(); -break; -case "zoomout": -this.map.zoomOut(); -break; -case "zoomworld": -this.map.zoomExtent(); -break; -} -Event.stop(evt); -},destroy:function(){ -OpenLayers.Control.prototype.destroy.apply(this,arguments); -for(i=0;i0){ -_372=[name]; -} -OpenLayers.Layer.prototype.initialize.apply(this,_372); -this.url=url; -this.params=_371; -this.tileSize=new OpenLayers.Size(OpenLayers.Layer.Grid.TILE_WIDTH,OpenLayers.Layer.Grid.TILE_HEIGHT); -},setTileSize:function(size){ -this.tileSize=size.copyOf(); -},moveTo:function(_374,_375){ -if(!this.getVisibility()){ -if(_375){ -this.grid=null; -} -return; -} -if(!this.grid||_375){ -this._initTiles(); -}else{ -var i=0; -while(this.getGridBounds().bottom>_374.bottom){ -this.insertRow(false); -} -while(this.getGridBounds().left>_374.left){ -this.insertColumn(true); -} -while(this.getGridBounds().top<_374.top){ -this.insertRow(true); -} -while(this.getGridBounds().right<_374.right){ -this.insertColumn(false); -} -} -},getGridBounds:function(){ -var _377=this.grid[0][0]; -var _378=this.grid[this.grid.length-1][this.grid[0].length-1]; -return new OpenLayers.Bounds(_377.bounds.left,_378.bounds.bottom,_378.bounds.right,_377.bounds.top); -},_initTiles:function(){ -this.div.innerHTML=""; -this.clearGrid(); -this.grid=new Array(); -var _379=this.map.getSize(); -var _37a=this.map.getExtent(); -var _37b=this.map.getFullExtent(); -var _37c=this.map.getResolution(); -var _37d=_37c*this.tileSize.w; -var _37e=_37c*this.tileSize.h; -var _37f=_37a.left-_37b.left; -var _380=Math.floor(_37f/_37d); -var _381=_37f/_37d-_380; -var _382=-_381*this.tileSize.w; -var _383=_37b.left+_380*_37d; -var _384=_37a.top-(_37b.bottom+_37e); -var _385=Math.ceil(_384/_37e); -var _386=_385-_384/_37e; -var _387=-_386*this.tileSize.h; -var _388=_37b.bottom+_385*_37e; -_382=Math.round(_382); -_387=Math.round(_387); -this.origin=new OpenLayers.Pixel(_382,_387); -var _389=_382; -var _38a=_383; -do{ -var row=new Array(); -this.grid.append(row); -_383=_38a; -_382=_389; -do{ -var _38c=new OpenLayers.Bounds(_383,_388,_383+_37d,_388+_37e); -var tile=this.addTile(_38c,new OpenLayers.Pixel(_382,_387)); -row.append(tile); -_383+=_37d; -_382+=this.tileSize.w; -}while(_383<_37a.right); -_388-=_37e; -_387+=this.tileSize.h; -}while(_388>_37a.bottom-_37e); -},insertRow:function(_38e){ -var _38f=(_38e)?0:(this.grid.length-1); -var _390=this.grid[_38f]; -var _391=new Array(); -var _392=this.map.getResolution(); -var _393=(_38e)?-this.tileSize.h:this.tileSize.h; -var _394=_392*-_393; -for(var i=0;i<_390.length;i++){ -var _396=_390[i]; -var _397=_396.bounds.copyOf(); -var _398=_396.position.copyOf(); -_397.bottom=_397.bottom+_394; -_397.top=_397.top+_394; -_398.y=_398.y+_393; -var _399=this.addTile(_397,_398); -_391.append(_399); -} -if(_391.length>0){ -if(_38e){ -this.grid.prepend(_391); -}else{ -this.grid.append(_391); -} -} -},insertColumn:function(_39a){ -var _39b; -var _39c=(_39a)?-this.tileSize.w:this.tileSize.w; -var _39d=this.map.getResolution(); -var _39e=_39d*_39c; -for(var i=0;i0){ -var row=this.grid[0]; -while(row.length>0){ -var tile=row[0]; -tile.destroy(); -row.remove(tile); -} -this.grid.remove(row); -} -} -}}); -OpenLayers.Layer.Markers=Class.create(); -OpenLayers.Layer.Markers.prototype=Object.extend(new OpenLayers.Layer(),{markers:null,initialize:function(name){ -OpenLayers.Layer.prototype.initialize.apply(this,arguments); -this.markers=new Array(); -},moveTo:function(_3ae,_3af){ -if(_3af){ -this.redraw(); -} -},addMarker:function(_3b0){ -this.markers.append(_3b0); -if(this.map&&this.map.getExtent()){ -this.drawMarker(_3b0); -} -},redraw:function(){ -for(i=0;i_3ca?_3c9/size.w:_3ca/size.h); -var zoom=Math.log(this.maxResolution/_3cb)/Math.log(2); -return Math.floor(Math.max(zoom,0)); -},getScreenPxFromLayerPx:function(_3cd){ -var _3ce=_3cd.copyOf(); -_3ce.x+=parseInt(this.layerContainerDiv.style.left); -_3ce.y+=parseInt(this.layerContainerDiv.style.top); -return _3ce; -},getLayerPxFromScreenPx:function(_3cf){ -var _3d0=_3cf.copyOf(); -_3d0.x-=parseInt(this.layerContainerDiv.style.left); -_3d0.y-=parseInt(this.layerContainerDiv.style.top); -return _3d0; -},getLonLatFromLayerPx:function(px){ -px=this.getScreenPxFromLayerPx(px); -return this.getLonLatFromScreenPx(px); -},getLonLatFromScreenPx:function(_3d2){ -var _3d3=this.getCenter(); -var res=this.getResolution(); -var size=this.getSize(); -var _3d6=_3d2.x-(size.w/2); -var _3d7=_3d2.y-(size.h/2); -return new OpenLayers.LonLat(_3d3.lon+_3d6*res,_3d3.lat-_3d7*res); -},getLayerPxFromLonLat:function(_3d8){ -var px=this.getScreenPxFromLonLat(_3d8); -return this.getLayerPxFromScreenPx(px); -},getScreenPxFromLonLat:function(_3da){ -var _3db=this.getResolution(); -var _3dc=this.getExtent(); -return new OpenLayers.Pixel(Math.round(1/_3db*(_3da.lon-_3dc.left)),Math.round(1/_3db*(_3dc.top-_3da.lat))); -},setCenter:function(_3dd,zoom){ -if(this.center){ -this.moveLayerContainer(_3dd); -} -this.center=_3dd.copyOf(); -var _3df=null; -if(zoom!=null&&zoom!=this.zoom&&zoom>=0&&zoom<=this.getZoomLevels()){ -_3df=(this.zoom==null?0:this.zoom); -this.zoom=zoom; -} -this.events.triggerEvent("movestart"); -this.moveToNewExtent(_3df); -this.events.triggerEvent("moveend"); -},moveToNewExtent:function(_3e0){ -if(_3e0!=null){ -this.layerContainerDiv.style.left="0px"; -this.layerContainerDiv.style.top="0px"; -for(var i=0;i=0&&zoom<=this.getZoomLevels()){ -var _3e5=this.zoom; -this.zoom=zoom; -this.moveToNewExtent(_3e5); -} -},zoomOut:function(){ -if(this.zoom!=null&&this.zoom>0){ -this.zoomTo(this.zoom-1); -} -},zoomExtent:function(){ -var _3e6=this.getFullExtent(); -var _3e7=this.zoom; -this.setCenter(new OpenLayers.LonLat((_3e6.left+_3e6.right)/2,(_3e6.bottom+_3e6.top)/2),0); -},moveLayerContainer:function(_3e8){ -var _3e9=this.layerContainerDiv; -var _3ea=this.getResolution(); -var _3eb=Math.round((this.center.lon-_3e8.lon)/_3ea); -var _3ec=Math.round((this.center.lat-_3e8.lat)/_3ea); -var _3ed=parseInt(_3e9.style.left); -var _3ee=parseInt(_3e9.style.top); -_3e9.style.left=(_3ed+_3eb)+"px"; -_3e9.style.top=(_3ee-_3ec)+"px"; -},CLASS_NAME:"OpenLayers.Map"}; -OpenLayers.Popup.Anchored=Class.create(); -OpenLayers.Popup.Anchored.prototype=Object.extend(new OpenLayers.Popup(),{relativePosition:null,anchor:null,initialize:function(id,_3f0,size,_3f2,_3f3){ -var _3f4=new Array(id,_3f0,size,_3f2); -OpenLayers.Popup.prototype.initialize.apply(this,_3f4); -this.anchor=(_3f3!=null)?_3f3:{size:new OpenLayers.Size(0,0),offset:new OpenLayers.Pixel(0,0)}; -},draw:function(px){ -if(px==null){ -if((this.lonlat!=null)&&(this.map!=null)){ -px=this.map.getLayerPxFromLonLat(this.lonlat); -} -} -this.relativePosition=this.calculateRelativePosition(px); -return OpenLayers.Popup.prototype.draw.apply(this,arguments); -},calculateRelativePosition:function(px){ -var _3f7=this.map.getLonLatFromLayerPx(px); -var _3f8=this.map.getExtent(); -var _3f9=_3f8.determineQuadrant(_3f7); -return OpenLayers.Bounds.oppositeQuadrant(_3f9); -},moveTo:function(px){ -var _3fb=this.calculateNewPx(px); -var _3fc=new Array(_3fb); -OpenLayers.Popup.prototype.moveTo.apply(this,_3fc); -},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); -} -},calculateNewPx:function(px){ -var _400=px.offset(this.anchor.offset); -var top=(this.relativePosition.charAt(0)=="t"); -_400.y+=(top)?-this.size.h:this.anchor.size.h; -var left=(this.relativePosition.charAt(1)=="l"); -_400.x+=(left)?-this.size.w:this.anchor.size.w; -return _400; -},CLASS_NAME:"OpenLayers.Popup.Anchored"}); -OpenLayers.Tile.Image=Class.create(); -OpenLayers.Tile.Image.prototype=Object.extend(new OpenLayers.Tile(),{img:null,initialize:function(_403,_404,_405,url,size){ -OpenLayers.Tile.prototype.initialize.apply(this,arguments); -},draw:function(){ -OpenLayers.Tile.prototype.draw.apply(this,arguments); -this.img=OpenLayers.Util.createImage(null,this.position,this.size,this.url,"absolute"); -},CLASS_NAME:"OpenLayers.Tile.Image"}); -OpenLayers.Tile.WFS=Class.create(); -OpenLayers.Tile.WFS.prototype=Object.extend(new OpenLayers.Tile(),{handlers:null,features:null,initialize:function(_408,_409,_40a,url,size){ -OpenLayers.Tile.prototype.initialize.apply(this,arguments); -this.features=new Array(); -this.handlers=new Array(); -this.handlers["requestSuccess"]=this.requestSuccess; -},draw:function(){ -OpenLayers.Tile.prototype.draw.apply(this,arguments); -this.loadFeaturesForRegion("requestSuccess"); -},loadFeaturesForRegion:function(_40d,_40e){ -if(!this.loaded){ -if(this.url!=""){ -this.loaded=true; -OpenLayers.loadURL(this.url,null,this,_40d,_40e); -} -} -},requestSuccess:function(_40f){ -var doc=_40f.responseXML; -if(!doc||_40f.fileType!="XML"){ -doc=OpenLayers.parseXMLString(_40f.responseText); -} -var _411=OpenLayers.Util.getNodes(doc,"gml:featureMember"); -this.features=new Array(); -for(var i=0;i<_411.length;i++){ -var _413=new this.layer.featureClass(this.layer,_411[i]); -this.features.append(_413); -} -},CLASS_NAME:"OpenLayers.Tile.WFS"}); -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(),{buttons:null,zoomStopWidth:18,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); -},draw:function(px){ -OpenLayers.Control.prototype.draw.apply(this,arguments); -px=this.position; -this.buttons=new Array(); -var sz=new OpenLayers.Size(18,18); -var _416=new OpenLayers.Pixel(px.x+sz.w/2,px.y); -this._addButton("panup","north-mini.png",_416,sz); -px.y=_416.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",_416.add(0,sz.h*2),sz); -this._addButton("zoomin","zoom-plus-mini.png",_416.add(0,sz.h*3+5),sz); -_416=this._addZoomBar(_416.add(0,sz.h*4+5)); -this._addButton("zoomout","zoom-minus-mini.png",_416,sz); -return this.div; -},_addZoomBar:function(_417){ -var _418=OpenLayers.Util.getImagesLocation(); -var id="OpenLayers_Control_PanZoomBar_Slider"+this.map.id; -var _41a=OpenLayers.Util.createAlphaImageDiv(id,_417.add(-1,(this.map.getZoomLevels())*this.zoomStopHeight),new OpenLayers.Size(20,9),_418+"slider.png","absolute"); -_41a.style.zIndex=this.div.zIndex+5; -this.slider=_41a; -this.sliderEvents=new OpenLayers.Events(this,_41a); -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); -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,_417,new OpenLayers.Size(sz.w,this.zoomStopHeight),_418+"zoombar.png","absolute",null,"crop"); -div.style.height=sz.h; -}else{ -div=OpenLayers.Util.createDiv("OpenLayers_Control_PanZoomBar_Zoombar"+this.map.id,_417,sz,_418+"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.div.appendChild(div); -this.startTop=parseInt(div.style.top); -this.div.appendChild(_41a); -this.map.events.register("zoomend",this,this.moveZoomBar); -_417=_417.add(0,this.zoomStopHeight*(this.map.getZoomLevels()+1)); -return _417; -},passEventToSlider:function(evt){ -this.sliderEvents.handleBrowserEvent(evt); -},divClick:function(evt){ -var y=evt.xy.y; -var top=Position.page(evt.object)[1]; -var _421=Math.floor((y-top)/this.zoomStopHeight); -this.map.zoomTo(this.map.getZoomLevels()-_421); -Event.stop(evt); -},zoomBarDown:function(evt){ -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); -},zoomBarDrag:function(evt){ -if(this.mouseDragStart!=null){ -var _424=this.mouseDragStart.y-evt.xy.y; -var _425=Position.page(this.zoombarDiv); -if((evt.clientY-_425[1])>0&&(evt.clientY-_425[1])

"+description+"

"; -} -var _43d=new OpenLayers.Feature(this,_433,data); -var _43e=_43d.createMarker(); -_43e.events.register("click",_43d,this.markerClick); -this.addMarker(_43e); -} -} -} -} -},markerClick:function(evt){ -sameMarkerClicked=(this==this.layer.selectedFeature); -this.layer.selectedFeature=(!sameMarkerClicked)?this:null; -for(var i=0;i0){ -_445.push(name,url,_443); -} -OpenLayers.Layer.Grid.prototype.initialize.apply(this,_445); -OpenLayers.Layer.Markers.prototype.initialize.apply(this,_445); -if(arguments.length>0){ -OpenLayers.Util.applyDefaults(this.params,this.DEFAULT_PARAMS); -} -},moveTo:function(_446,_447){ -OpenLayers.Layer.Grid.prototype.moveTo.apply(this,arguments); -OpenLayers.Layer.Markers.prototype.moveTo.apply(this,arguments); -},clone:function(name,_449){ -var _44a={}; -Object.extend(_44a,this.params); -Object.extend(_44a,_449); -var obj=new OpenLayers.Layer.WFS(name,this.url,_44a); -obj.setTileSize(this.tileSize); -return obj; -},addTile:function(_44c,_44d){ -url=this.getFullRequestString({bbox:_44c.toBBOX()}); -var tile=new OpenLayers.Tile.WFS(this,_44d,_44c,url,this.tileSize); -tile.draw(); -return tile; -},CLASS_NAME:"OpenLayers.Layer.WFS"})); -OpenLayers.Layer.WMS=Class.create(); -OpenLayers.Layer.WMS.prototype=Object.extend(new OpenLayers.Layer.Grid(),{DEFAULT_PARAMS:{service:"WMS",version:"1.1.1",request:"GetMap",styles:"",exceptions:"application/vnd.ogc.se_inimage",format:"image/jpeg"},initialize:function(name,url,_451){ -OpenLayers.Layer.Grid.prototype.initialize.apply(this,arguments); -OpenLayers.Util.applyDefaults(this.params,this.DEFAULT_PARAMS); -},clone:function(name,_453){ -var _454={}; -Object.extend(_454,this.params); -Object.extend(_454,_453); -var obj=new OpenLayers.Layer.WMS(name,this.url,_454); -obj.setTileSize(this.tileSize); -return obj; -},addTile:function(_456,_457){ -url=this.getFullRequestString({bbox:_456.toBBOX(),width:this.tileSize.w,height:this.tileSize.h}); -var tile=new OpenLayers.Tile.Image(this,_457,_456,url,this.tileSize); -tile.draw(); -this.div.appendChild(tile.img); -return tile; -},CLASS_NAME:"OpenLayers.Layer.WMS"}); -OpenLayers.Popup.AnchoredBubble=Class.create(); -OpenLayers.Popup.AnchoredBubble.CORNER_SIZE=5; -OpenLayers.Popup.AnchoredBubble.prototype=Object.extend(new OpenLayers.Popup.Anchored(),{contentDiv:null,initialize:function(id,_45a,size,_45c,_45d){ -OpenLayers.Popup.Anchored.prototype.initialize.apply(this,arguments); -},draw:function(px){ -OpenLayers.Popup.Anchored.prototype.draw.apply(this,arguments); -var _45f=this.size.copyOf(); -_45f.h-=(2*OpenLayers.Popup.AnchoredBubble.CORNER_SIZE); -var id=this.div.id+"-contentDiv"; -this.contentDiv=OpenLayers.Util.createDiv(id,null,_45f,null,"relative",null,"auto"); -this.div.appendChild(this.contentDiv); -this.setContentHTML(); -this.setRicoCorners(true); -this.setBackgroundColor(); -this.setOpacity(); -return this.div; -},setSize:function(size){ -OpenLayers.Popup.Anchored.prototype.setSize.apply(this,arguments); -if(this.contentDiv!=null){ -var _462=this.size.copyOf(); -_462.h-=(2*OpenLayers.Popup.AnchoredBubble.CORNER_SIZE); -this.contentDiv.style.height=_462.h+"px"; -this.setRicoCorners(false); -} -},setBackgroundColor:function(_463){ -if(_463!=undefined){ -this.backgroundColor=_463; -} -if(this.div!=null){ -if(this.contentDiv!=null){ -this.div.style.background="transparent"; -Rico.Corner.changeColor(this.contentDiv,this.backgroundColor); -} -} -},setOpacity:function(_464){ -if(_464!=undefined){ -this.opacity=_464; -} -if(this.div!=null){ -if(this.contentDiv!=null){ -Rico.Corner.changeOpacity(this.contentDiv,this.opacity); -} -} -},setBorder:function(_465){ -this.border=0; -},setContentHTML:function(_466){ -if(_466!=null){ -this.contentHTML=_466; -} -if(this.contentDiv!=null){ -this.contentDiv.innerHTML=this.contentHTML; -} -},setRicoCorners:function(_467){ -var _468=this.getCornersToRound(this.relativePosition); -var _469={corners:_468,color:this.backgroundColor,bgColor:"transparent",blend:false}; -if(_467){ -Rico.Corner.round(this.div,_469); -}else{ -Rico.Corner.reRound(this.contentDiv,_469); -this.setBackgroundColor(); -this.setOpacity(); -} -},getCornersToRound:function(){ -var _46a=["tl","tr","bl","br"]; -var _46b=OpenLayers.Bounds.oppositeQuadrant(this.relativePosition); -_46a.remove(_46b); -return _46a.join(" "); -},CLASS_NAME:"OpenLayers.Popup.AnchoredBubble"}); + + + +/** +* @class This class represents a bounding box. +* Data stored as left, bottom, right, top floats +*/ +OpenLayers.Bounds = Class.create(); +OpenLayers.Bounds.prototype = { + + /** @type float */ + left: 0.0, + + /** @type float */ + bottom: 0.0, + + /** @type float */ + right: 0.0, + + /** @type float */ + top: 0.0, + + /** + * @constructor + * + * @param {float} left + * @param {float} bottom + * @param {float} right + * @param {float} top + * + */ + initialize: function(left, bottom, right, top) { + this.left = left; + this.bottom = bottom; + this.right = right; + this.top = top; + }, + + /** + * @returns A fresh copy of the bounds + * @type OpenLayers.Bounds + */ + copyOf:function() { + return new OpenLayers.Bounds(this.left, this.bottom, + this.right, this.top); + }, + + /** + * @param {OpenLayers.Bounds} bounds + * @returns Boolean value indicating whether the passed-in OpenLayers.Bounds + * object has the same left, right, top, bottom components as this + * + * @type bool + */ + equals:function(bounds) { + return ((this.left == bounds.left) && (this.right == bounds.right) && + (this.top == bounds.top) && (this.bottom == bounds.bottom)); + }, + + /** + * @return String representation of OpenLayers.Bounds object. + * (ex."left-bottom=(5,42) right-top=(10,45)") + * @type String + */ + toString:function(){ + return ( "left-bottom=(" + this.left + "," + this.bottom + ")" + + " right-top=(" + this.right + "," + this.top + ")" ); + }, + + /** + * @return Simple String representation of OpenLayers.Bounds object. + * (ex. "5,42,10,45") + * @type String + */ + toBBOX:function() { + return (this.left + "," + this.bottom + "," + + this.right + "," + this.top); + }, + + /** + * @returns The width of the bounds + * @type float + */ + getWidth:function() { + return (this.right - this.left); + }, + + /** + * @returns The height of the bounds + * @type float + */ + getHeight:function() { + return (this.top - this.bottom); + }, + + /** + * @returns An OpenLayers.Size which represents the size of the box + * @type OpenLayers.Size + */ + getSize:function() { + return new OpenLayers.Size(this.getWidth(), this.getHeight()); + }, + + /** + * @returns An OpenLayers.Pixel which represents the center of the bounds + * @type OpenLayers.Pixel + */ + getCenterPixel:function() { + return new OpenLayers.Pixel(this.left + (this.getWidth() / 2), + this.bottom + (this.getHeight() / 2)); + }, + + /** + * @returns An OpenLayers.LonLat which represents the center of the bounds + * @type OpenLayers.LonLat + */ + getCenterLonLat:function() { + return new OpenLayers.LonLat(this.left + (this.getWidth() / 2), + this.bottom + (this.getHeight() / 2)); + }, + + /** + * @param {float} x + * @param {float} y + * + * @returns A new OpenLayers.Bounds whose coordinates are the same as this, + * but shifted by the passed-in x and y values + * @type OpenLayers.Bounds + */ + add:function(x, y){ + return new OpenLayers.Box(this.left + x, this.bottom + y, + this.right + x, this.top + y); + }, + + /** + * @param {float} x + * @param {float} y + * @param {Boolean} inclusive Whether or not to include the border. + * Default is true + * + * @return Whether or not the passed-in coordinates are within this bounds + * @type Boolean + */ + contains:function(x, y, inclusive) { + + //set default + if (inclusive == null) { + inclusive = true; + } + + var contains = false; + if (inclusive) { + contains = ((x >= this.left) && (x <= this.right) && + (y >= this.bottom) && (y <= this.top)); + } else { + contains = ((x > this.left) && (x < this.right) && + (y > this.bottom) && (y < this.top)); + } + return contains; + }, + + /** + * @param {OpenLayers.Bounds} bounds + * @param {Boolean} partial If true, only part of passed-in + * OpenLayers.Bounds needs be within this bounds. + * If false, the entire passed-in bounds must be + * within. Default is false + * @param {Boolean} inclusive Whether or not to include the border. + * Default is true + * + * @return Whether or not the passed-in OpenLayers.Bounds object is + * contained within this bounds. + * @type Boolean + */ + containsBounds:function(bounds, partial, inclusive) { + + //set defaults + if (partial == null) { + partial = false; + } + if (inclusive == null) { + inclusive = true; + } + + var inLeft; + var inTop; + var inRight; + var inBottom; + + if (inclusive) { + inLeft = (bounds.left >= this.left) && (bounds.left <= this.right); + inTop = (bounds.top >= this.bottom) && (bounds.top <= this.top); + inRight= (bounds.right >= this.left) && (bounds.right <= this.right); + inBottom = (bounds.bottom >= this.bottom) && (bounds.bottom <= this.top); + } else { + inLeft = (bounds.left > this.left) && (bounds.left < this.right); + inTop = (bounds.top > this.bottom) && (bounds.top < this.top); + inRight= (bounds.right > this.left) && (bounds.right < this.right); + inBottom = (bounds.bottom > this.bottom) && (bounds.bottom < this.top); + } + + return (partial) ? (inTop || inBottom) && (inLeft || inRight ) + : (inTop && inLeft && inBottom && inRight); + }, + + /** + * @param {OpenLayers.LonLat} lonlat + * + * @returns The quadrant ("br" "tr" "tl" "bl") of the bounds in which + * the coordinate lies. + * @type String + */ + determineQuadrant: function(lonlat) { + + var quadrant = ""; + var center = this.getCenterLonLat(); + + quadrant += (lonlat.lat < center.lat) ? "b" : "t"; + quadrant += (lonlat.lon < center.lon) ? "l" : "r"; + + return quadrant; + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.Bounds" +}; + +/** Alternative constructor that builds a new OpenLayers.Bounds from a +* parameter string +* +* @constructor +* +* @param {String} str Comma-separated bounds string. (ex. "5,42,10,45") +* +* @returns New OpenLayers.Bounds object built from the passed-in String. +* @type OpenLayers.Bounds +*/ +OpenLayers.Bounds.fromString = function(str) { + var bounds = str.split(","); + return new OpenLayers.Bounds(parseFloat(bounds[0]), + parseFloat(bounds[1]), + parseFloat(bounds[2]), + parseFloat(bounds[3])); +}; + + +/** + * @param {String} quadrant + * + * @returns The opposing quadrant ("br" "tr" "tl" "bl"). For Example, if + * you pass in "bl" it returns "tr", if you pass in "br" it + * returns "tl", etc. + * @type String + */ +OpenLayers.Bounds.oppositeQuadrant = function(quadrant) { + var opp = ""; + + opp += (quadrant.charAt(0) == 't') ? 'b' : 't'; + opp += (quadrant.charAt(1) == 'l') ? 'r' : 'l'; + + return opp; +}; + +// Some other helpful things + +/** +* @param {String} sStart +* +* @returns Whether or not this string starts with the string passed in. +* @type Boolean +*/ +String.prototype.startsWith = function(sStart){ + return (this.substr(0,sStart.length) == sStart); +}; + +/** +* @returns A trimmed version of the string - all leading and +* trailing spaces removed +* @type String +*/ +String.prototype.trim = function() { + + var b = 0; + while(this.substr(b,1) == " ") { + b++; + } + + var e = this.length - 1; + while(this.substr(e,1) == " ") { + e--; + } + + return this.substring(b, e+1); +}; + +/** Remove an object from an array. Iterates through the array +* to find the item, then removes it. +* +* @param {Object} item +* +* @returns A reference to the array +* @type Array +*/ +Array.prototype.remove = function(item) { + for(var i=0; i < this.length; i++) { + if(this[i] == item) { + this.splice(i,1); + //break;more than once?? + } + } + return this; +} + +/** +* @returns A fresh copy of the array +* @type Array +*/ +Array.prototype.copyOf = function() { + var copy = new Array(); + for (var i = 0; i < this.length; i++) { + copy[i] = this[i]; + } + return copy; +}; + +/** +* @param {Object} item +*/ +Array.prototype.prepend = function(item) { + this.splice(0, 0, item); +}; + +/** +* @param {Object} item +*/ +Array.prototype.append = function(item){ + this[this.length] = item; +}; + +/** +*/ +Array.prototype.clear = function() { + this.length = 0; +}; + +/** +* @param {Object} element +* +* @returns The first index of the element in the array if found. Else returns -1 +* @type int +*/ +Array.prototype.indexOf = function(element) { + var index = -1; + for(var i=0; i < this.length; i++) { + if (this[i] == element) { + index = i; + break; + } + } + return index; +} + +/** + * @param {String} id + * @param {OpenLayers.Pixel} px + * @param {OpenLayers.Size} sz + * @param {String} position + * @param {String} border + * @param {String} overflow + */ +OpenLayers.Util.modifyDOMElement = function(element, id, px, sz, position, + border, overflow) { + + if (id) { + element.id = id; + } + if (px) { + element.style.left = px.x; + element.style.top = px.y; + } + if (sz) { + element.style.width = sz.w + "px"; + element.style.height = sz.h + "px"; + } + if (position) { + element.style.position = position; + } + if (border) { + element.style.border = border; + } + if (overflow) { + element.style.overflow = overflow; + } +}; + +/** +* zIndex is NOT set +* +* @param {String} id +* @param {OpenLayers.Pixel} px +* @param {OpenLayers.Size} sz +* @param {String} imgURL +* @param {String} position +* @param {String} border +* @param {String} overflow +* +* @returns A DOM Div created with the specified attributes. +* @type DOMElement +*/ +OpenLayers.Util.createDiv = function(id, px, sz, imgURL, position, + border, overflow) { + + var dom = document.createElement('div'); + + //set specific properties + dom.style.padding = "0"; + dom.style.margin = "0"; + dom.style.cursor = "inherit"; + if (imgURL) { + dom.style.backgroundImage = 'url(' + imgURL + ')'; + } + + //set generic properties + if (!id) { + id = "OpenLayersDiv" + (Math.random() * 10000 % 10000); + } + if (!position) { + position = "absolute"; + } + OpenLayers.Util.modifyDOMElement(dom, id, px, sz, + position, border, overflow); + + return dom; +}; + +/** +* @param {String} id +* @param {OpenLayers.Pixel} px +* @param {OpenLayers.Size} sz +* @param {String} imgURL +* @param {String} position +* @param {String} border +* +* @returns A DOM Image created with the specified attributes. +* @type DOMElement +*/ +OpenLayers.Util.createImage = function(id, px, sz, imgURL, position, border) { + + image = document.createElement("img"); + + //set special properties + image.style.alt = id; + image.style.cursor = "inherit"; + image.galleryImg = "no"; + if (imgURL) { + image.src = imgURL; + } + + //set generic properties + if (!id) { + id = "OpenLayersDiv" + (Math.random() * 10000 % 10000); + } + if (!position) { + position = "relative"; + } + OpenLayers.Util.modifyDOMElement(image, id, px, sz, position, border); + + return image; +}; + +OpenLayers.Util.alphaHack = function() { + var arVersion = navigator.appVersion.split("MSIE"); + var version = parseFloat(arVersion[1]); + + return ( (document.body.filters) && + (version >= 5.5) && (version < 7) ); +} + +/** +* @param {DOMElement} div Div containing Alpha-adjusted Image +* @param {String} id +* @param {OpenLayers.Pixel} px +* @param {OpenLayers.Size} sz +* @param {String} imgURL +* @param {String} position +* @param {String} border +* @param {String} sizing 'crop', 'scale', or 'image'. Default is "scale" +*/ +OpenLayers.Util.modifyAlphaImageDiv = function(div, id, px, sz, imgURL, + position, border, sizing) { + + OpenLayers.Util.modifyDOMElement(div, id, px, sz); + + var img = div.childNodes[0]; + + if (imgURL) { + img.src = imgURL; + } + OpenLayers.Util.modifyDOMElement(img, div.id + "_innerImage", null, sz, + "relative", border); + + if (OpenLayers.Util.alphaHack()) { + div.style.display = "inline-block"; + if (sizing == null) { + sizing = "scale"; + } + div.style.filter = "progid:DXImageTransform.Microsoft" + + ".AlphaImageLoader(src='" + img.src + "', " + + "sizingMethod='" + sizing + "')"; + img.style.filter = "progid:DXImageTransform.Microsoft" + + ".Alpha(opacity=0)"; + } +}; + +/** +* @param {String} id +* @param {OpenLayers.Pixel} px +* @param {OpenLayers.Size} sz +* @param {String} imgURL +* @param {String} position +* @param {String} border +* @param {String} sizing 'crop', 'scale', or 'image'. Default is "scale" +* +* @returns A DOM Div created with a DOM Image inside it. If the hack is +* needed for transparency in IE, it is added. +* @type DOMElement +*/ +OpenLayers.Util.createAlphaImageDiv = function(id, px, sz, imgURL, + position, border, sizing) { + + var div = OpenLayers.Util.createDiv(); + var img = OpenLayers.Util.createImage(); + div.appendChild(img); + + OpenLayers.Util.modifyAlphaImageDiv(div, id, px, sz, imgURL, + position, border, sizing); + + return div; +}; + +/** +* @param {Object} params +* +* @returns a concatenation of the properties of an object in +* http parameter notation. +* (ex. "key1=value1&key2=value2&key3=value3") +* @type String +*/ +OpenLayers.Util.getParameterString = function(params) { + paramsArray = new Array(); + + for (var key in params) { + var value = params[key]; + //skip functions + if (typeof value == 'function') continue; + + paramsArray.push(key + "=" + value); + } + + return paramsArray.join("&"); +}; + +/** +* @returns The fully formatted image location string +* @type String +*/ +OpenLayers.Util.getImagesLocation = function() { + return OpenLayers._getScriptLocation() + "img/"; +}; + +/** Takes a hash and copies any keys that don't exist from +* another hash, by analogy with Object.extend() from +* Prototype.js. +* +* @param {Object} to +* @param {Object} from +* +* @type Object +*/ +OpenLayers.Util.applyDefaults = function (to, from) { + for (var key in from) { + if (to[key] == null) { + to[key] = from[key]; + } + } + return to; +}; + + + +/** These could/should be made namespace aware? +* +* @param {} p +* @param {str} tagName +* +* @return {Array} +*/ +OpenLayers.Util.getNodes=function(p, tagName) { + var nodes = Try.these( + function () { + return OpenLayers.Util._getNodes(p.documentElement.childNodes, + tagName); + }, + function () { + return OpenLayers.Util._getNodes(p.childNodes, tagName); + } + ); + return nodes; +}; + +/** +* @param {Array} nodes +* @param {str} tagName +* +* @return {Array} +*/ +OpenLayers.Util._getNodes=function(nodes, tagName) { + var retArray = new Array(); + for (var i=0;i 0)) + { + if (!index) { + index=0; + } + if (result[index].childNodes.length > 1) { + return result.childNodes[1].nodeValue; + } + else if (result[index].childNodes.length == 1) { + return result[index].firstChild.nodeValue; + } + } else { + return ""; + } +}; + +/** +* @param {Event} evt +* @param {HTMLDivElement} div +* +* @return {boolean} +*/ +OpenLayers.Util.mouseLeft = function (evt, div) { + // start with the element to which the mouse has moved + var target = (evt.relatedTarget) ? evt.relatedTarget : evt.toElement; + // walk up the DOM tree. + while (target != div && target != null) { + target = target.parentNode; + } + // if the target we stop at isn't the div, then we've left the div. + return (target != div); +}; + +OpenLayers.ProxyHost = "/viewer/Crossbrowser/blindproxy.py?url="; +//OpenLayers.ProxyHost = "examples/proxy.cgi?url="; + +/** +* Ajax reader for OpenLayers +* +* Pay close attention to how this works: +* +*@uri url to do remote XML http get +*@param 'get' format params (x=y&a=b...) +*@who object which is providing a specific callbacks for this request +*@complete the name of the function which must be defined in the callers.handler[] array +*@failure the name of the function which must be defined in the callers.handler[] array +* +* example usage from a caller: +* +* this.handlers["caps"] = function(request){..} +* 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) { +// ol.Log.warn("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(); + } + +// ol.Log.debug("loadURL [" + uri + "]"); + + var successx; + var failurex; + var bind1 = null; + var bind2 = null; + + if (onComplete) { + successx = caller.handlers[onComplete]; + bind1 = caller; + } else { + successx = OpenLayers.nullHandler; + } + + if (onFailure) { + failurex = caller.handlers[onFailure]; + bind2=caller; + } else { + failurex = OpenLayers.nullHandler; + } + + // from prototype.js + new Ajax.Request(uri, + { method: 'get', + parameters: params, + onComplete: successx.bind(bind1), + onFailure: failurex.bind(bind2) + } + ); +}; + +/** 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; +};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) { + var listeners = this.listeners[type]; + listeners.push( func.bindAsEventListener(obj) ); + }, + + 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; + + var listeners = this.listeners[type]; + for (var i = 0; i < listeners.length; i++) { + var callback = listeners[i]; + callback(evt); + } + } +}; +// @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", + + // float + maxResolution: null, // degrees per pixel + + // 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, + + /** + * @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 = 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)); + }, + + /** + */ + 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, zIndex) { + layer.map = this; + layer.projection = this.projection; + layer.div.style.overflow = ""; + if (zIndex) { + layer.div.style.zIndex = zIndex; + } else { + layer.div.style.zIndex = this.Z_INDEX_BASE['Layer'] + this.layers.length; + } + this.layerContainerDiv.appendChild(layer.div); + this.layers.push(layer); + this.events.triggerEvent("addlayer"); + }, + + /** + * @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); + } + }, + + /** + * @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; + }, + + 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) { + 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.max(zoom, 0)); + }, + + /** + * @param {OpenLayers.Pixel} layerPx + * + * @returns px translated into screen pixel coordinates + * @type OpenLayers.Pixel + */ + getScreenPxFromLayerPx:function(layerPx) { + var screenPx = layerPx.copyOf(); + + screenPx.x += parseInt(this.layerContainerDiv.style.left); + screenPx.y += parseInt(this.layerContainerDiv.style.top); + + return screenPx; + }, + + /** + * @param {OpenLayers.Pixel} screenPx + * + * @returns px translated into screen pixel coordinates + * @type OpenLayers.Pixel + */ + getLayerPxFromScreenPx:function(screenPx) { + var layerPx = screenPx.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.getScreenPxFromLayerPx(px); + return this.getLonLatFromScreenPx(px); + }, + + /** + * @param {OpenLayers.Pixel} screenPx + * + * @returns An OpenLayers.LonLat which is the passed-in screen + * OpenLayers.Pixel, translated into lon/lat given the + * current extent and resolution + * @type OpenLayers.LonLat + */ + getLonLatFromScreenPx: function (screenPx) { + var center = this.getCenter(); //map center lon/lat + var res = this.getResolution(); + var size = this.getSize(); + + var delta_x = screenPx.x - (size.w / 2); + var delta_y = screenPx.y - (size.h / 2); + + return new OpenLayers.LonLat(center.lon + delta_x * res , + center.lat - delta_y * res); + }, + + /** + * @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.getScreenPxFromLonLat(lonlat); + return this.getLayerPxFromScreenPx(px); + }, + + /** + * @param {OpenLayers.LonLat} lonlat + * + * @returns An OpenLayers.Pixel which is the passed-in OpenLayers.LonLat, + * translated into screen pixels given the current extent + * and resolution + * @type OpenLayers.Pixel + */ + getScreenPxFromLonLat: 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)) + ); + }, + + /** + * @param {OpenLayers.LonLat} lonlat + * @param {int} zoom + */ + setCenter: function (lonlat, zoom) { + 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; + } + + this.events.triggerEvent("movestart"); + this.moveToNewExtent(zoomChanged); + this.events.triggerEvent("moveend"); + }, + + moveToNewExtent: function (zoomChanged) { + 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)); + } + this.events.triggerEvent("move"); + if (zoomChanged != null) + this.events.triggerEvent("zoomend", + {oldZoom: zoomChanged, newZoom: this.zoom}); + }, + + /** + * zoomIn + * Increase zoom level by one. + */ + zoomIn: function() { + if (this.zoom != null && this.zoom <= this.getZoomLevels()) { + this.zoomTo( this.zoom += 1 ); + } + + }, + + /** + * zoomTo + * Set Zoom To int + */ + 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. + */ + zoomOut: function() { + if (this.zoom != null && this.zoom > 0) { + this.zoomTo( this.zoom - 1 ); + } + }, + + zoomExtent: function() { + var fullExtent = this.getFullExtent(); + var oldZoom = this.zoom; + this.setCenter( + new OpenLayers.LonLat((fullExtent.left+fullExtent.right)/2, + (fullExtent.bottom+fullExtent.top)/2), + 0 + ); + }, + + /** + * @param {OpenLayers.LonLat} lonlat + */ + 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" +}; +OpenLayers.Layer = Class.create(); + +OpenLayers.Layer.prototype = { + + // str + name: null, + + // DOMElement + div: null, + + /** This variable is set in map.addLayer, not within the layer itself + * @type OpenLayers.Map */ + map: null, + + // str -- projection for use in WFS, WMS, etc. + projection: null, + + /** + * @param {str} 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() { + this.map = null; + }, + + /** + * @params {OpenLayers.Bounds} bound + * @params {bool} 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; + }, + + /** + * @return {bool} + */ + 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" +}; +/** +* @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(); + }, + + /** + * @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" +};/** +* @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); + }, + + /** + * @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); + } + }, + + /** + * @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); +}; + + +/** +* @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.div) && (this.div.parentNode)) { + this.div.parentNode.removeChild(this.div); + } + 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" +}; +/* + * 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? + // + // ol.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" +}; + +/** + * @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() { + this.layer = 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" +}; +/** + * @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); + } + }, + + /** + * @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 + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.Feature.WFS" +}); + + + + + +// @require: OpenLayers/Tile.js +/** +* @class +*/ +OpenLayers.Tile.Image = Class.create(); +OpenLayers.Tile.Image.prototype = + Object.extend( new OpenLayers.Tile(), { + + /** @type DOMElement img */ + img: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); + }, + + /** + */ + draw:function() { + OpenLayers.Tile.prototype.draw.apply(this, arguments); + this.img = OpenLayers.Util.createImage(null, + this.position, + this.size, + this.url, + "absolute"); + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.Tile.Image" + } +); +// @require: OpenLayers/Tile.js +/** +* @class +*/ +OpenLayers.Tile.WFS = Class.create(); +OpenLayers.Tile.WFS.prototype = + Object.extend( new OpenLayers.Tile(), { + + /** @type Array of Function */ + handlers: null, + + /** @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(); + + this.handlers = new Array(); + this.handlers["requestSuccess"] = this.requestSuccess; + }, + + /** + */ + draw:function() { + OpenLayers.Tile.prototype.draw.apply(this, arguments); + this.loadFeaturesForRegion("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; +// ol.Log.info("request string: " + this.url); + 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 = OpenLayers.Util.getNodes(doc, "gml:featureMember"); +// ol.Log.info(this.layer.name + " found " + +// resultFeatures.length + " features"); + + //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" + } +); + +// @require: OpenLayers/Layer.js + +OpenLayers.Layer.Google = Class.create(); +OpenLayers.Layer.Google.prototype = Object.extend( new OpenLayers.Layer(), { + // gmap stores the Google Map element + gmap:null, + initialize: function(name) { + OpenLayers.Layer.prototype.initialize.apply(this, [name]); + this.gmap = new GMap2(this.div); + }, + moveTo: function() { + center = this.map.getCenter(); + this.gmap.setCenter( + new GLatLng(center.lat, center.lon), + this.map.getZoom() + ); + } + +}); +// @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); + }, + + 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, + tileoffsety) + ); + 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); + 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 0) { + var row = this.grid[0]; + while(row.length > 0) { + var tile = row[0]; + tile.destroy(); + row.remove(tile); + } + this.grid.remove(row); + } + } + } + +}); +// @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(); + }, + + /** + * @param {OpenLayers.Bounds} bounds + * @param {Boolean} zoomChanged + */ + moveTo: function(bounds, zoomChanged) { + if (zoomChanged) { + this.redraw(); + } + }, + + /** + * @param {OpenLayers.Marker} marker + */ + addMarker: function(marker) { + this.markers.append(marker); + if (this.map && this.map.getExtent()) { + this.drawMarker(marker); + } + }, + + + /** 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 screen 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" +}); +// @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 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; + new Ajax.Request(location, + { method: 'get', onComplete:this.parseData.bind(this) } ); + }, + + /** + * @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'] = '

'+title+'

'+description+'

'; + } + var feature = new OpenLayers.Feature(this, location, data); + 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); + } +}); + + +// @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) { + OpenLayers.Layer.Grid.prototype.initialize.apply(this, arguments); + OpenLayers.Util.applyDefaults(this.params, this.DEFAULT_PARAMS); + }, + + /** + * @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}); + var tile = new OpenLayers.Tile.Image(this, position, bounds, + url, this.tileSize); + tile.draw(); + this.div.appendChild(tile.img); + return tile; + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.Layer.WMS" +}); +// @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: null, + + /** @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) { + this.featureClass = featureClass; + + var newArguments = new Array(); + if (arguments.length > 0) { + 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, this.DEFAULT_PARAMS); + } + }, + + /** + * @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); + }, + + /** + * @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() }); + var tile = new OpenLayers.Tile.WFS(this, position, bounds, + url, this.tileSize); + tile.draw(); + return tile; + }, + + /** @final @type String */ + CLASS_NAME: "OpenLayers.Layer.WFS" +} +) +); +// @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" +}); +// @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, + "auto"); + 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" +}); +/** +* @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" +}; +// @require: OpenLayers/Control.js +OpenLayers.Control.MouseDefaults = Class.create(); +OpenLayers.Control.MouseDefaults.prototype = + Object.extend( new OpenLayers.Control(), { + + initialize: function() { + OpenLayers.Control.prototype.initialize.apply(this, arguments); + }, + + draw: function() { + 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 ); + }, + + /** + * @param {Event} evt + */ + defaultDblClick: function (evt) { + var newCenter = this.map.getLonLatFromScreenPx( evt.xy ); + this.map.setCenter(newCenter, this.map.zoom + 1); + }, + + /** + * @param {Event} evt + */ + defaultMouseDown: function (evt) { + this.mouseDragStart = evt.xy.copyOf(); + 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); + } else { + this.map.div.style.cursor = "move"; + } + 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.getLonLatFromScreenPx( newXY ); + this.map.setCenter(newCenter); + this.mouseDragStart = evt.xy.copyOf(); + } + } + }, + + /** + * @param {Event} evt + */ + defaultMouseUp: function (evt) { + if (this.zoomBox) { + var start = this.map.getLonLatFromScreenPx( this.mouseDragStart ); + var end = this.map.getLonLatFromScreenPx( 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.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); + } + } +}); + +// @require: OpenLayers/Control.js + +OpenLayers.Control.KeyboardDefaults = Class.create(); +OpenLayers.Control.KeyboardDefaults.prototype = + Object.extend( new OpenLayers.Control(), { + + initialize: function() { + OpenLayers.Control.prototype.initialize.apply(this, arguments); + }, + + draw: function() { + Event.observe(document, 'keypress', this.defaultKeyDown.bind(this.map)); + }, + + /** + * @param {Event} evt + */ + defaultKeyDown: function (evt) { + var i = 0; + switch(evt.keyCode) { + case Event.KEY_LEFT: + var resolution = this.getResolution(); + var center = this.getCenter(); + this.setCenter( + new OpenLayers.LonLat(center.lon - (resolution * 50), + center.lat) + ); + Event.stop(evt); + break; + case Event.KEY_RIGHT: + var resolution = this.getResolution(); + var center = this.getCenter(); + this.setCenter( + new OpenLayers.LonLat(center.lon + (resolution * 50), + center.lat) + ); + Event.stop(evt); + break; + case Event.KEY_UP: + var resolution = this.getResolution(); + var center = this.getCenter(); + this.setCenter( + new OpenLayers.LonLat(center.lon, + center.lat + (resolution * 50)) + ); + Event.stop(evt); + break; + case Event.KEY_DOWN: + var resolution = this.getResolution(); + var center = this.getCenter(); + this.setCenter( + new OpenLayers.LonLat(center.lon, + center.lat - (resolution * 50)) + ); + Event.stop(evt); + break; + } + } + +}); +// @require: OpenLayers/Control.js +// +// 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 Array(...) */ + buttons: null, + + 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 + */ + 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; + }, + _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.action = id; + btn.map = this.map; + + //we want to remember/reference the outer div + this.buttons.push(btn); + return btn; + }, + + doubleClick: function (evt) { + Event.stop(evt); + }, + + buttonDown: function (evt) { + switch (this.action) { + case "panup": + var resolution = this.map.getResolution(); + var center = this.map.getCenter(); + this.map.setCenter( + new OpenLayers.LonLat(center.lon, + center.lat + (resolution * 50)) + ); + break; + case "pandown": + var resolution = this.map.getResolution(); + var center = this.map.getCenter(); + this.map.setCenter( + new OpenLayers.LonLat(center.lon, + center.lat - (resolution * 50)) + ); + break; + case "panleft": + var resolution = this.map.getResolution(); + var center = this.map.getCenter(); + this.map.setCenter( + new OpenLayers.LonLat(center.lon - (resolution * 50), + center.lat) + ); + break; + case "panright": + var resolution = this.map.getResolution(); + var center = this.map.getCenter(); + this.map.setCenter( + new OpenLayers.LonLat(center.lon + (resolution * 50), + center.lat) + ); + break; + case "zoomin": this.map.zoomIn(); break; + case "zoomout": this.map.zoomOut(); break; + case "zoomworld": this.map.zoomExtent(); break; + } + Event.stop(evt); + }, + destroy: function() { + OpenLayers.Control.prototype.destroy.apply(this, arguments); + for(i=0; i 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 (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" +}); +// @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); + 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); + 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); + }, + + /** + * @param {event} evt + */ + doubleClick: function(evt) { + Event.stop(evt); + }, + + /** + * @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"; + + // 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 + backdropLabel.ondblclick = this.doubleClick.bindAsEventListener(this); + backdropLabel.onmousedown = this.singleClick.bindAsEventListener(this); + + + // 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}); + + this.setTabActivation(backdropLabel, layer.getVisibility()); + }, + + + + /** + * @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" +});