/*

  OpenLayers.js -- OpenLayers Map Viewer Library

  Copyright (c) 2006-2012 by OpenLayers Contributors
  Published under the 2-clause BSD license.
  See http://openlayers.org/dev/license.txt for the full text of the license, and http://openlayers.org/dev/authors.txt for full list of contributors.

  Includes compressed code under the following licenses:

  (For uncompressed versions of the code used, please see the
  OpenLayers Github repository: <https://github.com/openlayers/openlayers>)

*/

/**
 * Contains XMLHttpRequest.js <http://code.google.com/p/xmlhttprequest/>
 * Copyright 2007 Sergey Ilinsky (http://www.ilinsky.com)
 *
 * 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
 */

/**
 * OpenLayers.Util.pagePosition is based on Yahoo's getXY method, which is
 * Copyright (c) 2006, Yahoo! Inc.
 * All rights reserved.
 *
 * Redistribution and use of this software in source and binary forms, with or
 * without modification, are permitted provided that the following conditions
 * are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * * Neither the name of Yahoo! Inc. nor the names of its contributors may be
 *   used to endorse or promote products derived from this software without
 *   specific prior written permission of Yahoo! Inc.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
var OpenLayers = {
  VERSION_NUMBER: "Release 2.12",
  singleFile: true,
  _getScriptLocation: (function() {
    var r = new RegExp("(^|(.*?\\/))(OpenLayers[^\\/]*?\\.js)(\\?|$)"),
      s = document.getElementsByTagName("script"),
      src,
      m,
      l = "";
    for (var i = 0, len = s.length; i < len; i++) {
      src = s[i].getAttribute("src");
      if (src) {
        m = src.match(r);
        if (m) {
          l = m[1];
          break;
        }
      }
    }
    return function() {
      return l;
    };
  })(),
  ImgPath: ""
};
OpenLayers.Class = function() {
  var len = arguments.length;
  var P = arguments[0];
  var F = arguments[len - 1];
  var C =
    typeof F.initialize == "function"
      ? F.initialize
      : function() {
          P.prototype.initialize.apply(this, arguments);
        };
  if (len > 1) {
    var newArgs = [C, P].concat(
      Array.prototype.slice.call(arguments).slice(1, len - 1),
      F
    );
    OpenLayers.inherit.apply(null, newArgs);
  } else {
    C.prototype = F;
  }
  return C;
};
OpenLayers.inherit = function(C, P) {
  var F = function() {};
  F.prototype = P.prototype;
  C.prototype = new F();
  var i, l, o;
  for (i = 2, l = arguments.length; i < l; i++) {
    o = arguments[i];
    if (typeof o === "function") {
      o = o.prototype;
    }
    OpenLayers.Util.extend(C.prototype, o);
  }
};
OpenLayers.Util = OpenLayers.Util || {};
OpenLayers.Util.extend = function(destination, source) {
  destination = destination || {};
  if (source) {
    for (var property in source) {
      var value = source[property];
      if (value !== undefined) {
        destination[property] = value;
      }
    }
    var sourceIsEvt =
      typeof window.Event == "function" && source instanceof window.Event;
    if (
      !sourceIsEvt &&
      source.hasOwnProperty &&
      source.hasOwnProperty("toString")
    ) {
      destination.toString = source.toString;
    }
  }
  return destination;
};
OpenLayers.Pixel = OpenLayers.Class({
  x: 0.0,
  y: 0.0,
  initialize: function(x, y) {
    this.x = parseFloat(x);
    this.y = parseFloat(y);
  },
  toString: function() {
    return "x=" + this.x + ",y=" + this.y;
  },
  clone: function() {
    return new OpenLayers.Pixel(this.x, this.y);
  },
  equals: function(px) {
    var equals = false;
    if (px != null) {
      equals =
        (this.x == px.x && this.y == px.y) ||
        (isNaN(this.x) && isNaN(this.y) && isNaN(px.x) && isNaN(px.y));
    }
    return equals;
  },
  distanceTo: function(px) {
    return Math.sqrt(Math.pow(this.x - px.x, 2) + Math.pow(this.y - px.y, 2));
  },
  add: function(x, y) {
    if (x == null || y == null) {
      throw new TypeError("Pixel.add cannot receive null values");
    }
    return new OpenLayers.Pixel(this.x + x, this.y + y);
  },
  offset: function(px) {
    var newPx = this.clone();
    if (px) {
      newPx = this.add(px.x, px.y);
    }
    return newPx;
  },
  CLASS_NAME: "OpenLayers.Pixel"
});
OpenLayers.String = {
  startsWith: function(str, sub) {
    return str.indexOf(sub) == 0;
  },
  contains: function(str, sub) {
    return str.indexOf(sub) != -1;
  },
  trim: function(str) {
    return str.replace(/^\s\s*/, "").replace(/\s\s*$/, "");
  },
  camelize: function(str) {
    var oStringList = str.split("-");
    var camelizedString = 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;
  },
  format: function(template, context, args) {
    if (!context) {
      context = window;
    }
    var replacer = function(str, match) {
      var replacement;
      var subs = match.split(/\.+/);
      for (var i = 0; i < subs.length; i++) {
        if (i == 0) {
          replacement = context;
        }
        replacement = replacement[subs[i]];
      }
      if (typeof replacement == "function") {
        replacement = args ? replacement.apply(null, args) : replacement();
      }
      if (typeof replacement == "undefined") {
        return "undefined";
      } else {
        return replacement;
      }
    };
    return template.replace(OpenLayers.String.tokenRegEx, replacer);
  },
  tokenRegEx: /\$\{([\w.]+?)\}/g,
  numberRegEx: /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/,
  isNumeric: function(value) {
    return OpenLayers.String.numberRegEx.test(value);
  },
  numericIf: function(value) {
    return OpenLayers.String.isNumeric(value) ? parseFloat(value) : value;
  }
};
OpenLayers.Number = {
  decimalSeparator: ".",
  thousandsSeparator: ",",
  limitSigDigs: function(num, sig) {
    var fig = 0;
    if (sig > 0) {
      fig = parseFloat(num.toPrecision(sig));
    }
    return fig;
  },
  format: function(num, dec, tsep, dsep) {
    dec = typeof dec != "undefined" ? dec : 0;
    tsep =
      typeof tsep != "undefined" ? tsep : OpenLayers.Number.thousandsSeparator;
    dsep =
      typeof dsep != "undefined" ? dsep : OpenLayers.Number.decimalSeparator;
    if (dec != null) {
      num = parseFloat(num.toFixed(dec));
    }
    var parts = num.toString().split(".");
    if (parts.length == 1 && dec == null) {
      dec = 0;
    }
    var integer = parts[0];
    if (tsep) {
      var thousands = /(-?[0-9]+)([0-9]{3})/;
      while (thousands.test(integer)) {
        integer = integer.replace(thousands, "$1" + tsep + "$2");
      }
    }
    var str;
    if (dec == 0) {
      str = integer;
    } else {
      var rem = parts.length > 1 ? parts[1] : "0";
      if (dec != null) {
        rem = rem + new Array(dec - rem.length + 1).join("0");
      }
      str = integer + dsep + rem;
    }
    return str;
  }
};
OpenLayers.Function = {
  bind: function(func, object) {
    var args = Array.prototype.slice.apply(arguments, [2]);
    return function() {
      var newArgs = args.concat(Array.prototype.slice.apply(arguments, [0]));
      return func.apply(object, newArgs);
    };
  },
  bindAsEventListener: function(func, object) {
    return function(event) {
      return func.call(object, event || window.event);
    };
  },
  False: function() {
    return false;
  },
  True: function() {
    return true;
  },
  Void: function() {}
};
OpenLayers.Array = {
  filter: function(array, callback, caller) {
    var selected = [];
    if (Array.prototype.filter) {
      selected = array.filter(callback, caller);
    } else {
      var len = array.length;
      if (typeof callback != "function") {
        throw new TypeError();
      }
      for (var i = 0; i < len; i++) {
        if (i in array) {
          var val = array[i];
          if (callback.call(caller, val, i, array)) {
            selected.push(val);
          }
        }
      }
    }
    return selected;
  }
};
OpenLayers.Bounds = OpenLayers.Class({
  left: null,
  bottom: null,
  right: null,
  top: null,
  centerLonLat: null,
  initialize: function(left, bottom, right, top) {
    if (OpenLayers.Util.isArray(left)) {
      top = left[3];
      right = left[2];
      bottom = left[1];
      left = left[0];
    }
    if (left != null) {
      this.left = OpenLayers.Util.toFloat(left);
    }
    if (bottom != null) {
      this.bottom = OpenLayers.Util.toFloat(bottom);
    }
    if (right != null) {
      this.right = OpenLayers.Util.toFloat(right);
    }
    if (top != null) {
      this.top = OpenLayers.Util.toFloat(top);
    }
  },
  clone: function() {
    return new OpenLayers.Bounds(this.left, this.bottom, this.right, this.top);
  },
  equals: function(bounds) {
    var equals = false;
    if (bounds != null) {
      equals =
        this.left == bounds.left &&
        this.right == bounds.right &&
        this.top == bounds.top &&
        this.bottom == bounds.bottom;
    }
    return equals;
  },
  toString: function() {
    return [this.left, this.bottom, this.right, this.top].join(",");
  },
  toArray: function(reverseAxisOrder) {
    if (reverseAxisOrder === true) {
      return [this.bottom, this.left, this.top, this.right];
    } else {
      return [this.left, this.bottom, this.right, this.top];
    }
  },
  toBBOX: function(decimal, reverseAxisOrder) {
    if (decimal == null) {
      decimal = 6;
    }
    var mult = Math.pow(10, decimal);
    var xmin = Math.round(this.left * mult) / mult;
    var ymin = Math.round(this.bottom * mult) / mult;
    var xmax = Math.round(this.right * mult) / mult;
    var ymax = Math.round(this.top * mult) / mult;
    if (reverseAxisOrder === true) {
      return ymin + "," + xmin + "," + ymax + "," + xmax;
    } else {
      return xmin + "," + ymin + "," + xmax + "," + ymax;
    }
  },
  toGeometry: function() {
    return new OpenLayers.Geometry.Polygon([
      new OpenLayers.Geometry.LinearRing([
        new OpenLayers.Geometry.Point(this.left, this.bottom),
        new OpenLayers.Geometry.Point(this.right, this.bottom),
        new OpenLayers.Geometry.Point(this.right, this.top),
        new OpenLayers.Geometry.Point(this.left, 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.right) / 2,
      (this.bottom + this.top) / 2
    );
  },
  getCenterLonLat: function() {
    if (!this.centerLonLat) {
      this.centerLonLat = new OpenLayers.LonLat(
        (this.left + this.right) / 2,
        (this.bottom + this.top) / 2
      );
    }
    return this.centerLonLat;
  },
  scale: function(ratio, origin) {
    if (origin == null) {
      origin = this.getCenterLonLat();
    }
    var origx, origy;
    if (origin.CLASS_NAME == "OpenLayers.LonLat") {
      origx = origin.lon;
      origy = origin.lat;
    } else {
      origx = origin.x;
      origy = origin.y;
    }
    var left = (this.left - origx) * ratio + origx;
    var bottom = (this.bottom - origy) * ratio + origy;
    var right = (this.right - origx) * ratio + origx;
    var top = (this.top - origy) * ratio + origy;
    return new OpenLayers.Bounds(left, bottom, right, top);
  },
  add: function(x, y) {
    if (x == null || y == null) {
      throw new TypeError("Bounds.add cannot receive null values");
    }
    return new OpenLayers.Bounds(
      this.left + x,
      this.bottom + y,
      this.right + x,
      this.top + y
    );
  },
  extend: function(object) {
    var bounds = null;
    if (object) {
      switch (object.CLASS_NAME) {
        case "OpenLayers.LonLat":
          bounds = new OpenLayers.Bounds(
            object.lon,
            object.lat,
            object.lon,
            object.lat
          );
          break;
        case "OpenLayers.Geometry.Point":
          bounds = new OpenLayers.Bounds(
            object.x,
            object.y,
            object.x,
            object.y
          );
          break;
        case "OpenLayers.Bounds":
          bounds = object;
          break;
      }
      if (bounds) {
        this.centerLonLat = null;
        if (this.left == null || bounds.left < this.left) {
          this.left = bounds.left;
        }
        if (this.bottom == null || bounds.bottom < this.bottom) {
          this.bottom = bounds.bottom;
        }
        if (this.right == null || bounds.right > this.right) {
          this.right = bounds.right;
        }
        if (this.top == null || bounds.top > this.top) {
          this.top = bounds.top;
        }
      }
    }
  },
  containsLonLat: function(ll, options) {
    if (typeof options === "boolean") {
      options = { inclusive: options };
    }
    options = options || {};
    var contains = this.contains(ll.lon, ll.lat, options.inclusive),
      worldBounds = options.worldBounds;
    if (worldBounds && !contains) {
      var worldWidth = worldBounds.getWidth();
      var worldCenterX = (worldBounds.left + worldBounds.right) / 2;
      var worldsAway = Math.round((ll.lon - worldCenterX) / worldWidth);
      contains = this.containsLonLat(
        { lon: ll.lon - worldsAway * worldWidth, lat: ll.lat },
        { inclusive: options.inclusive }
      );
    }
    return contains;
  },
  containsPixel: function(px, inclusive) {
    return this.contains(px.x, px.y, inclusive);
  },
  contains: function(x, y, inclusive) {
    if (inclusive == null) {
      inclusive = true;
    }
    if (x == null || y == null) {
      return false;
    }
    x = OpenLayers.Util.toFloat(x);
    y = OpenLayers.Util.toFloat(y);
    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;
  },
  intersectsBounds: function(bounds, options) {
    if (typeof options === "boolean") {
      options = { inclusive: options };
    }
    options = options || {};
    if (options.worldBounds) {
      var self = this.wrapDateLine(options.worldBounds);
      bounds = bounds.wrapDateLine(options.worldBounds);
    } else {
      self = this;
    }
    if (options.inclusive == null) {
      options.inclusive = true;
    }
    var intersects = false;
    var mightTouch =
      self.left == bounds.right ||
      self.right == bounds.left ||
      self.top == bounds.bottom ||
      self.bottom == bounds.top;
    if (options.inclusive || !mightTouch) {
      var inBottom =
        (bounds.bottom >= self.bottom && bounds.bottom <= self.top) ||
        (self.bottom >= bounds.bottom && self.bottom <= bounds.top);
      var inTop =
        (bounds.top >= self.bottom && bounds.top <= self.top) ||
        (self.top > bounds.bottom && self.top < bounds.top);
      var inLeft =
        (bounds.left >= self.left && bounds.left <= self.right) ||
        (self.left >= bounds.left && self.left <= bounds.right);
      var inRight =
        (bounds.right >= self.left && bounds.right <= self.right) ||
        (self.right >= bounds.left && self.right <= bounds.right);
      intersects = (inBottom || inTop) && (inLeft || inRight);
    }
    if (options.worldBounds && !intersects) {
      var world = options.worldBounds;
      var width = world.getWidth();
      var selfCrosses = !world.containsBounds(self);
      var boundsCrosses = !world.containsBounds(bounds);
      if (selfCrosses && !boundsCrosses) {
        bounds = bounds.add(-width, 0);
        intersects = self.intersectsBounds(bounds, {
          inclusive: options.inclusive
        });
      } else if (boundsCrosses && !selfCrosses) {
        self = self.add(-width, 0);
        intersects = bounds.intersectsBounds(self, {
          inclusive: options.inclusive
        });
      }
    }
    return intersects;
  },
  containsBounds: function(bounds, partial, inclusive) {
    if (partial == null) {
      partial = false;
    }
    if (inclusive == null) {
      inclusive = true;
    }
    var bottomLeft = this.contains(bounds.left, bounds.bottom, inclusive);
    var bottomRight = this.contains(bounds.right, bounds.bottom, inclusive);
    var topLeft = this.contains(bounds.left, bounds.top, inclusive);
    var topRight = this.contains(bounds.right, bounds.top, inclusive);
    return partial
      ? bottomLeft || bottomRight || topLeft || topRight
      : bottomLeft && bottomRight && topLeft && topRight;
  },
  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;
  },
  transform: function(source, dest) {
    this.centerLonLat = null;
    var ll = OpenLayers.Projection.transform(
      { x: this.left, y: this.bottom },
      source,
      dest
    );
    var lr = OpenLayers.Projection.transform(
      { x: this.right, y: this.bottom },
      source,
      dest
    );
    var ul = OpenLayers.Projection.transform(
      { x: this.left, y: this.top },
      source,
      dest
    );
    var ur = OpenLayers.Projection.transform(
      { x: this.right, y: this.top },
      source,
      dest
    );
    this.left = Math.min(ll.x, ul.x);
    this.bottom = Math.min(ll.y, lr.y);
    this.right = Math.max(lr.x, ur.x);
    this.top = Math.max(ul.y, ur.y);
    return this;
  },
  wrapDateLine: function(maxExtent, options) {
    options = options || {};
    var leftTolerance = options.leftTolerance || 0;
    var rightTolerance = options.rightTolerance || 0;
    var newBounds = this.clone();
    if (maxExtent) {
      var width = maxExtent.getWidth();
      while (
        newBounds.left < maxExtent.left &&
        newBounds.right - rightTolerance <= maxExtent.left
      ) {
        newBounds = newBounds.add(width, 0);
      }
      while (
        newBounds.left + leftTolerance >= maxExtent.right &&
        newBounds.right > maxExtent.right
      ) {
        newBounds = newBounds.add(-width, 0);
      }
      var newLeft = newBounds.left + leftTolerance;
      if (
        newLeft < maxExtent.right &&
        newLeft > maxExtent.left &&
        newBounds.right - rightTolerance > maxExtent.right
      ) {
        newBounds = newBounds.add(-width, 0);
      }
    }
    return newBounds;
  },
  CLASS_NAME: "OpenLayers.Bounds"
});
OpenLayers.Bounds.fromString = function(str, reverseAxisOrder) {
  var bounds = str.split(",");
  return OpenLayers.Bounds.fromArray(bounds, reverseAxisOrder);
};
OpenLayers.Bounds.fromArray = function(bbox, reverseAxisOrder) {
  return reverseAxisOrder === true
    ? new OpenLayers.Bounds(bbox[1], bbox[0], bbox[3], bbox[2])
    : new OpenLayers.Bounds(bbox[0], bbox[1], bbox[2], bbox[3]);
};
OpenLayers.Bounds.fromSize = function(size) {
  return new OpenLayers.Bounds(0, size.h, size.w, 0);
};
OpenLayers.Bounds.oppositeQuadrant = function(quadrant) {
  var opp = "";
  opp += quadrant.charAt(0) == "t" ? "b" : "t";
  opp += quadrant.charAt(1) == "l" ? "r" : "l";
  return opp;
};
OpenLayers.Element = {
  visible: function(element) {
    return OpenLayers.Util.getElement(element).style.display != "none";
  },
  toggle: function() {
    for (var i = 0, len = arguments.length; i < len; i++) {
      var element = OpenLayers.Util.getElement(arguments[i]);
      var display = OpenLayers.Element.visible(element) ? "none" : "";
      element.style.display = display;
    }
  },
  remove: function(element) {
    element = OpenLayers.Util.getElement(element);
    element.parentNode.removeChild(element);
  },
  getHeight: function(element) {
    element = OpenLayers.Util.getElement(element);
    return element.offsetHeight;
  },
  hasClass: function(element, name) {
    var names = element.className;
    return !!names && new RegExp("(^|\\s)" + name + "(\\s|$)").test(names);
  },
  addClass: function(element, name) {
    if (!OpenLayers.Element.hasClass(element, name)) {
      element.className += (element.className ? " " : "") + name;
    }
    return element;
  },
  removeClass: function(element, name) {
    var names = element.className;
    if (names) {
      element.className = OpenLayers.String.trim(
        names.replace(new RegExp("(^|\\s+)" + name + "(\\s+|$)"), " ")
      );
    }
    return element;
  },
  toggleClass: function(element, name) {
    if (OpenLayers.Element.hasClass(element, name)) {
      OpenLayers.Element.removeClass(element, name);
    } else {
      OpenLayers.Element.addClass(element, name);
    }
    return element;
  },
  getStyle: function(element, style) {
    element = OpenLayers.Util.getElement(element);
    var value = null;
    if (element && element.style) {
      value = element.style[OpenLayers.String.camelize(style)];
      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[OpenLayers.String.camelize(style)];
        }
      }
      var positions = ["left", "top", "right", "bottom"];
      if (
        window.opera &&
        OpenLayers.Util.indexOf(positions, style) != -1 &&
        OpenLayers.Element.getStyle(element, "position") == "static"
      ) {
        value = "auto";
      }
    }
    return value == "auto" ? null : value;
  }
};
OpenLayers.LonLat = OpenLayers.Class({
  lon: 0.0,
  lat: 0.0,
  initialize: function(lon, lat) {
    if (OpenLayers.Util.isArray(lon)) {
      lat = lon[1];
      lon = lon[0];
    }
    this.lon = OpenLayers.Util.toFloat(lon);
    this.lat = OpenLayers.Util.toFloat(lat);
  },
  toString: function() {
    return "lon=" + this.lon + ",lat=" + this.lat;
  },
  toShortString: function() {
    return this.lon + ", " + this.lat;
  },
  clone: function() {
    return new OpenLayers.LonLat(this.lon, this.lat);
  },
  add: function(lon, lat) {
    if (lon == null || lat == null) {
      throw new TypeError("LonLat.add cannot receive null values");
    }
    return new OpenLayers.LonLat(
      this.lon + OpenLayers.Util.toFloat(lon),
      this.lat + OpenLayers.Util.toFloat(lat)
    );
  },
  equals: function(ll) {
    var equals = false;
    if (ll != null) {
      equals =
        (this.lon == ll.lon && this.lat == ll.lat) ||
        (isNaN(this.lon) && isNaN(this.lat) && isNaN(ll.lon) && isNaN(ll.lat));
    }
    return equals;
  },
  transform: function(source, dest) {
    var point = OpenLayers.Projection.transform(
      { x: this.lon, y: this.lat },
      source,
      dest
    );
    this.lon = point.x;
    this.lat = point.y;
    return this;
  },
  wrapDateLine: function(maxExtent) {
    var newLonLat = this.clone();
    if (maxExtent) {
      while (newLonLat.lon < maxExtent.left) {
        newLonLat.lon += maxExtent.getWidth();
      }
      while (newLonLat.lon > maxExtent.right) {
        newLonLat.lon -= maxExtent.getWidth();
      }
    }
    return newLonLat;
  },
  CLASS_NAME: "OpenLayers.LonLat"
});
OpenLayers.LonLat.fromString = function(str) {
  var pair = str.split(",");
  return new OpenLayers.LonLat(pair[0], pair[1]);
};
OpenLayers.LonLat.fromArray = function(arr) {
  var gotArr = OpenLayers.Util.isArray(arr),
    lon = gotArr && arr[0],
    lat = gotArr && arr[1];
  return new OpenLayers.LonLat(lon, lat);
};
OpenLayers.Size = OpenLayers.Class({
  w: 0.0,
  h: 0.0,
  initialize: function(w, h) {
    this.w = parseFloat(w);
    this.h = parseFloat(h);
  },
  toString: function() {
    return "w=" + this.w + ",h=" + this.h;
  },
  clone: function() {
    return new OpenLayers.Size(this.w, this.h);
  },
  equals: function(sz) {
    var equals = false;
    if (sz != null) {
      equals =
        (this.w == sz.w && this.h == sz.h) ||
        (isNaN(this.w) && isNaN(this.h) && isNaN(sz.w) && isNaN(sz.h));
    }
    return equals;
  },
  CLASS_NAME: "OpenLayers.Size"
});
OpenLayers.Console = {
  log: function() {},
  debug: function() {},
  info: function() {},
  warn: function() {},
  error: function() {},
  userError: function(error) {
    alert(error);
  },
  assert: function() {},
  dir: function() {},
  dirxml: function() {},
  trace: function() {},
  group: function() {},
  groupEnd: function() {},
  time: function() {},
  timeEnd: function() {},
  profile: function() {},
  profileEnd: function() {},
  count: function() {},
  CLASS_NAME: "OpenLayers.Console"
};
(function() {
  var scripts = document.getElementsByTagName("script");
  for (var i = 0, len = scripts.length; i < len; ++i) {
    if (scripts[i].src.indexOf("firebug.js") != -1) {
      if (console) {
        OpenLayers.Util.extend(OpenLayers.Console, console);
        break;
      }
    }
  }
})();
OpenLayers.Lang = {
  code: null,
  defaultCode: "en",
  getCode: function() {
    if (!OpenLayers.Lang.code) {
      OpenLayers.Lang.setCode();
    }
    return OpenLayers.Lang.code;
  },
  setCode: function(code) {
    var lang;
    if (!code) {
      code =
        OpenLayers.BROWSER_NAME == "msie"
          ? navigator.userLanguage
          : navigator.language;
    }
    var parts = code.split("-");
    parts[0] = parts[0].toLowerCase();
    if (typeof OpenLayers.Lang[parts[0]] == "object") {
      lang = parts[0];
    }
    if (parts[1]) {
      var testLang = parts[0] + "-" + parts[1].toUpperCase();
      if (typeof OpenLayers.Lang[testLang] == "object") {
        lang = testLang;
      }
    }
    if (!lang) {
      OpenLayers.Console.warn(
        "Failed to find OpenLayers.Lang." +
          parts.join("-") +
          " dictionary, falling back to default language"
      );
      lang = OpenLayers.Lang.defaultCode;
    }
    OpenLayers.Lang.code = lang;
  },
  translate: function(key, context) {
    var dictionary = OpenLayers.Lang[OpenLayers.Lang.getCode()];
    var message = dictionary && dictionary[key];
    if (!message) {
      message = key;
    }
    if (context) {
      message = OpenLayers.String.format(message, context);
    }
    return message;
  }
};
OpenLayers.i18n = OpenLayers.Lang.translate;
OpenLayers.Util = OpenLayers.Util || {};
OpenLayers.Util.getElement = function() {
  var elements = [];
  for (var i = 0, len = arguments.length; i < len; i++) {
    var element = arguments[i];
    if (typeof element == "string") {
      element = document.getElementById(element);
    }
    if (arguments.length == 1) {
      return element;
    }
    elements.push(element);
  }
  return elements;
};
OpenLayers.Util.isElement = function(o) {
  return !!(o && o.nodeType === 1);
};
OpenLayers.Util.isArray = function(a) {
  return Object.prototype.toString.call(a) === "[object Array]";
};
if (typeof window.$ === "undefined") {
  window.$ = OpenLayers.Util.getElement;
}
OpenLayers.Util.removeItem = function(array, item) {
  for (var i = array.length - 1; i >= 0; i--) {
    if (array[i] == item) {
      array.splice(i, 1);
    }
  }
  return array;
};
OpenLayers.Util.indexOf = function(array, obj) {
  if (typeof array.indexOf == "function") {
    return array.indexOf(obj);
  } else {
    for (var i = 0, len = array.length; i < len; i++) {
      if (array[i] == obj) {
        return i;
      }
    }
    return -1;
  }
};
OpenLayers.Util.modifyDOMElement = function(
  element,
  id,
  px,
  sz,
  position,
  border,
  overflow,
  opacity
) {
  if (id) {
    element.id = id;
  }
  if (px) {
    element.style.left = px.x + "px";
    element.style.top = px.y + "px";
  }
  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;
  }
  if (parseFloat(opacity) >= 0.0 && parseFloat(opacity) < 1.0) {
    element.style.filter = "alpha(opacity=" + opacity * 100 + ")";
    element.style.opacity = opacity;
  } else if (parseFloat(opacity) == 1.0) {
    element.style.filter = "";
    element.style.opacity = "";
  }
};
OpenLayers.Util.createDiv = function(
  id,
  px,
  sz,
  imgURL,
  position,
  border,
  overflow,
  opacity
) {
  var dom = document.createElement("div");
  if (imgURL) {
    dom.style.backgroundImage = "url(" + imgURL + ")";
  }
  if (!id) {
    id = OpenLayers.Util.createUniqueID("OpenLayersDiv");
  }
  if (!position) {
    position = "absolute";
  }
  OpenLayers.Util.modifyDOMElement(
    dom,
    id,
    px,
    sz,
    position,
    border,
    overflow,
    opacity
  );
  return dom;
};
OpenLayers.Util.createImage = function(
  id,
  px,
  sz,
  imgURL,
  position,
  border,
  opacity,
  delayDisplay
) {
  var image = document.createElement("img");
  if (!id) {
    id = OpenLayers.Util.createUniqueID("OpenLayersDiv");
  }
  if (!position) {
    position = "relative";
  }
  OpenLayers.Util.modifyDOMElement(
    image,
    id,
    px,
    sz,
    position,
    border,
    null,
    opacity
  );
  if (delayDisplay) {
    image.style.display = "none";
    function display() {
      image.style.display = "";
      OpenLayers.Event.stopObservingElement(image);
    }
    OpenLayers.Event.observe(image, "load", display);
    OpenLayers.Event.observe(image, "error", display);
  }
  image.style.alt = id;
  image.galleryImg = "no";
  if (imgURL) {
    image.src = imgURL;
  }
  return image;
};
OpenLayers.IMAGE_RELOAD_ATTEMPTS = 0;
OpenLayers.Util.alphaHackNeeded = null;
OpenLayers.Util.alphaHack = function() {
  if (OpenLayers.Util.alphaHackNeeded == null) {
    var arVersion = navigator.appVersion.split("MSIE");
    var version = parseFloat(arVersion[1]);
    var filter = false;
    try {
      filter = !!document.body.filters;
    } catch (e) {}
    OpenLayers.Util.alphaHackNeeded = filter && version >= 5.5 && version < 7;
  }
  return OpenLayers.Util.alphaHackNeeded;
};
OpenLayers.Util.modifyAlphaImageDiv = function(
  div,
  id,
  px,
  sz,
  imgURL,
  position,
  border,
  sizing,
  opacity
) {
  OpenLayers.Util.modifyDOMElement(
    div,
    id,
    px,
    sz,
    position,
    null,
    null,
    opacity
  );
  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()) {
    if (div.style.display != "none") {
      div.style.display = "inline-block";
    }
    if (sizing == null) {
      sizing = "scale";
    }
    div.style.filter =
      "progid:DXImageTransform.Microsoft" +
      ".AlphaImageLoader(src='" +
      img.src +
      "', " +
      "sizingMethod='" +
      sizing +
      "')";
    if (
      parseFloat(div.style.opacity) >= 0.0 &&
      parseFloat(div.style.opacity) < 1.0
    ) {
      div.style.filter += " alpha(opacity=" + div.style.opacity * 100 + ")";
    }
    img.style.filter = "alpha(opacity=0)";
  }
};
OpenLayers.Util.createAlphaImageDiv = function(
  id,
  px,
  sz,
  imgURL,
  position,
  border,
  sizing,
  opacity,
  delayDisplay
) {
  var div = OpenLayers.Util.createDiv();
  var img = OpenLayers.Util.createImage(
    null,
    null,
    null,
    null,
    null,
    null,
    null,
    delayDisplay
  );
  img.className = "olAlphaImg";
  div.appendChild(img);
  OpenLayers.Util.modifyAlphaImageDiv(
    div,
    id,
    px,
    sz,
    imgURL,
    position,
    border,
    sizing,
    opacity
  );
  return div;
};
OpenLayers.Util.upperCaseObject = function(object) {
  var uObject = {};
  for (var key in object) {
    uObject[key.toUpperCase()] = object[key];
  }
  return uObject;
};
OpenLayers.Util.applyDefaults = function(to, from) {
  to = to || {};
  var fromIsEvt =
    typeof window.Event == "function" && from instanceof window.Event;
  for (var key in from) {
    if (
      to[key] === undefined ||
      (!fromIsEvt &&
        from.hasOwnProperty &&
        from.hasOwnProperty(key) &&
        !to.hasOwnProperty(key))
    ) {
      to[key] = from[key];
    }
  }
  if (
    !fromIsEvt &&
    from &&
    from.hasOwnProperty &&
    from.hasOwnProperty("toString") &&
    !to.hasOwnProperty("toString")
  ) {
    to.toString = from.toString;
  }
  return to;
};
OpenLayers.Util.getParameterString = function(params) {
  var paramsArray = [];
  for (var key in params) {
    var value = params[key];
    if (value != null && typeof value != "function") {
      var encodedValue;
      if (typeof value == "object" && value.constructor == Array) {
        var encodedItemArray = [];
        var item;
        for (
          var itemIndex = 0, len = value.length;
          itemIndex < len;
          itemIndex++
        ) {
          item = value[itemIndex];
          encodedItemArray.push(
            encodeURIComponent(item === null || item === undefined ? "" : item)
          );
        }
        encodedValue = encodedItemArray.join(",");
      } else {
        encodedValue = encodeURIComponent(value);
      }
      paramsArray.push(encodeURIComponent(key) + "=" + encodedValue);
    }
  }
  return paramsArray.join("&");
};
OpenLayers.Util.urlAppend = function(url, paramStr) {
  var newUrl = url;
  if (paramStr) {
    var parts = (url + " ").split(/[?&]/);
    newUrl +=
      parts.pop() === " "
        ? paramStr
        : parts.length
        ? "&" + paramStr
        : "?" + paramStr;
  }
  return newUrl;
};
OpenLayers.Util.getImagesLocation = function() {
  return OpenLayers.ImgPath || OpenLayers._getScriptLocation() + "img/";
};
OpenLayers.Util.getImageLocation = function(image) {
  return OpenLayers.Util.getImagesLocation() + image;
};
OpenLayers.Util.Try = function() {
  var returnValue = null;
  for (var i = 0, len = arguments.length; i < len; i++) {
    var lambda = arguments[i];
    try {
      returnValue = lambda();
      break;
    } catch (e) {}
  }
  return returnValue;
};
OpenLayers.Util.getXmlNodeValue = function(node) {
  var val = null;
  OpenLayers.Util.Try(
    function() {
      val = node.text;
      if (!val) {
        val = node.textContent;
      }
      if (!val) {
        val = node.firstChild.nodeValue;
      }
    },
    function() {
      val = node.textContent;
    }
  );
  return val;
};
OpenLayers.Util.mouseLeft = function(evt, div) {
  var target = evt.relatedTarget ? evt.relatedTarget : evt.toElement;
  while (target != div && target != null) {
    target = target.parentNode;
  }
  return target != div;
};
OpenLayers.Util.DEFAULT_PRECISION = 14;
OpenLayers.Util.toFloat = function(number, precision) {
  if (precision == null) {
    precision = OpenLayers.Util.DEFAULT_PRECISION;
  }
  if (typeof number !== "number") {
    number = parseFloat(number);
  }
  return precision === 0 ? number : parseFloat(number.toPrecision(precision));
};
OpenLayers.Util.rad = function(x) {
  return (x * Math.PI) / 180;
};
OpenLayers.Util.deg = function(x) {
  return (x * 180) / Math.PI;
};
OpenLayers.Util.VincentyConstants = {
  a: 6378137,
  b: 6356752.3142,
  f: 1 / 298.257223563
};
OpenLayers.Util.distVincenty = function(p1, p2) {
  var ct = OpenLayers.Util.VincentyConstants;
  var a = ct.a,
    b = ct.b,
    f = ct.f;
  var L = OpenLayers.Util.rad(p2.lon - p1.lon);
  var U1 = Math.atan((1 - f) * Math.tan(OpenLayers.Util.rad(p1.lat)));
  var U2 = Math.atan((1 - f) * Math.tan(OpenLayers.Util.rad(p2.lat)));
  var sinU1 = Math.sin(U1),
    cosU1 = Math.cos(U1);
  var sinU2 = Math.sin(U2),
    cosU2 = Math.cos(U2);
  var lambda = L,
    lambdaP = 2 * Math.PI;
  var iterLimit = 20;
  while (Math.abs(lambda - lambdaP) > 1e-12 && --iterLimit > 0) {
    var sinLambda = Math.sin(lambda),
      cosLambda = Math.cos(lambda);
    var sinSigma = Math.sqrt(
      cosU2 * sinLambda * (cosU2 * sinLambda) +
        (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) *
          (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
    );
    if (sinSigma == 0) {
      return 0;
    }
    var cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
    var sigma = Math.atan2(sinSigma, cosSigma);
    var alpha = Math.asin((cosU1 * cosU2 * sinLambda) / sinSigma);
    var cosSqAlpha = Math.cos(alpha) * Math.cos(alpha);
    var cos2SigmaM = cosSigma - (2 * sinU1 * sinU2) / cosSqAlpha;
    var C = (f / 16) * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
    lambdaP = lambda;
    lambda =
      L +
      (1 - C) *
        f *
        Math.sin(alpha) *
        (sigma +
          C *
            sinSigma *
            (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
  }
  if (iterLimit == 0) {
    return NaN;
  }
  var uSq = (cosSqAlpha * (a * a - b * b)) / (b * b);
  var A = 1 + (uSq / 16384) * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
  var B = (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
  var deltaSigma =
    B *
    sinSigma *
    (cos2SigmaM +
      (B / 4) *
        (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
          (B / 6) *
            cos2SigmaM *
            (-3 + 4 * sinSigma * sinSigma) *
            (-3 + 4 * cos2SigmaM * cos2SigmaM)));
  var s = b * A * (sigma - deltaSigma);
  var d = s.toFixed(3) / 1000;
  return d;
};
OpenLayers.Util.destinationVincenty = function(lonlat, brng, dist) {
  var u = OpenLayers.Util;
  var ct = u.VincentyConstants;
  var a = ct.a,
    b = ct.b,
    f = ct.f;
  var lon1 = lonlat.lon;
  var lat1 = lonlat.lat;
  var s = dist;
  var alpha1 = u.rad(brng);
  var sinAlpha1 = Math.sin(alpha1);
  var cosAlpha1 = Math.cos(alpha1);
  var tanU1 = (1 - f) * Math.tan(u.rad(lat1));
  var cosU1 = 1 / Math.sqrt(1 + tanU1 * tanU1),
    sinU1 = tanU1 * cosU1;
  var sigma1 = Math.atan2(tanU1, cosAlpha1);
  var sinAlpha = cosU1 * sinAlpha1;
  var cosSqAlpha = 1 - sinAlpha * sinAlpha;
  var uSq = (cosSqAlpha * (a * a - b * b)) / (b * b);
  var A = 1 + (uSq / 16384) * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
  var B = (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
  var sigma = s / (b * A),
    sigmaP = 2 * Math.PI;
  while (Math.abs(sigma - sigmaP) > 1e-12) {
    var cos2SigmaM = Math.cos(2 * sigma1 + sigma);
    var sinSigma = Math.sin(sigma);
    var cosSigma = Math.cos(sigma);
    var deltaSigma =
      B *
      sinSigma *
      (cos2SigmaM +
        (B / 4) *
          (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
            (B / 6) *
              cos2SigmaM *
              (-3 + 4 * sinSigma * sinSigma) *
              (-3 + 4 * cos2SigmaM * cos2SigmaM)));
    sigmaP = sigma;
    sigma = s / (b * A) + deltaSigma;
  }
  var tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosAlpha1;
  var lat2 = Math.atan2(
    sinU1 * cosSigma + cosU1 * sinSigma * cosAlpha1,
    (1 - f) * Math.sqrt(sinAlpha * sinAlpha + tmp * tmp)
  );
  var lambda = Math.atan2(
    sinSigma * sinAlpha1,
    cosU1 * cosSigma - sinU1 * sinSigma * cosAlpha1
  );
  var C = (f / 16) * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
  var L =
    lambda -
    (1 - C) *
      f *
      sinAlpha *
      (sigma +
        C *
          sinSigma *
          (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
  var revAz = Math.atan2(sinAlpha, -tmp);
  return new OpenLayers.LonLat(lon1 + u.deg(L), u.deg(lat2));
};
OpenLayers.Util.getParameters = function(url) {
  url = url === null || url === undefined ? window.location.href : url;
  var paramsString = "";
  if (OpenLayers.String.contains(url, "?")) {
    var start = url.indexOf("?") + 1;
    var end = OpenLayers.String.contains(url, "#")
      ? url.indexOf("#")
      : url.length;
    paramsString = url.substring(start, end);
  }
  var parameters = {};
  var pairs = paramsString.split(/[&;]/);
  for (var i = 0, len = pairs.length; i < len; ++i) {
    var keyValue = pairs[i].split("=");
    if (keyValue[0]) {
      var key = keyValue[0];
      try {
        key = decodeURIComponent(key);
      } catch (err) {
        key = unescape(key);
      }
      var value = (keyValue[1] || "").replace(/\+/g, " ");
      try {
        value = decodeURIComponent(value);
      } catch (err) {
        value = unescape(value);
      }
      value = value.split(",");
      if (value.length == 1) {
        value = value[0];
      }
      parameters[key] = value;
    }
  }
  return parameters;
};
OpenLayers.Util.lastSeqID = 0;
OpenLayers.Util.createUniqueID = function(prefix) {
  if (prefix == null) {
    prefix = "id_";
  }
  OpenLayers.Util.lastSeqID += 1;
  return prefix + OpenLayers.Util.lastSeqID;
};
OpenLayers.INCHES_PER_UNIT = {
  inches: 1.0,
  ft: 12.0,
  mi: 63360.0,
  m: 39.3701,
  km: 39370.1,
  dd: 4374754,
  yd: 36
};
OpenLayers.INCHES_PER_UNIT["in"] = OpenLayers.INCHES_PER_UNIT.inches;
OpenLayers.INCHES_PER_UNIT["degrees"] = OpenLayers.INCHES_PER_UNIT.dd;
OpenLayers.INCHES_PER_UNIT["nmi"] = 1852 * OpenLayers.INCHES_PER_UNIT.m;
OpenLayers.METERS_PER_INCH = 0.0254000508001016002;
OpenLayers.Util.extend(OpenLayers.INCHES_PER_UNIT, {
  Inch: OpenLayers.INCHES_PER_UNIT.inches,
  Meter: 1.0 / OpenLayers.METERS_PER_INCH,
  Foot: 0.30480060960121920243 / OpenLayers.METERS_PER_INCH,
  IFoot: 0.3048 / OpenLayers.METERS_PER_INCH,
  ClarkeFoot: 0.3047972651151 / OpenLayers.METERS_PER_INCH,
  SearsFoot: 0.30479947153867624624 / OpenLayers.METERS_PER_INCH,
  GoldCoastFoot: 0.30479971018150881758 / OpenLayers.METERS_PER_INCH,
  IInch: 0.0254 / OpenLayers.METERS_PER_INCH,
  MicroInch: 0.0000254 / OpenLayers.METERS_PER_INCH,
  Mil: 0.0000000254 / OpenLayers.METERS_PER_INCH,
  Centimeter: 0.01 / OpenLayers.METERS_PER_INCH,
  Kilometer: 1000.0 / OpenLayers.METERS_PER_INCH,
  Yard: 0.91440182880365760731 / OpenLayers.METERS_PER_INCH,
  SearsYard: 0.914398414616029 / OpenLayers.METERS_PER_INCH,
  IndianYard: 0.91439853074444079983 / OpenLayers.METERS_PER_INCH,
  IndianYd37: 0.91439523 / OpenLayers.METERS_PER_INCH,
  IndianYd62: 0.9143988 / OpenLayers.METERS_PER_INCH,
  IndianYd75: 0.9143985 / OpenLayers.METERS_PER_INCH,
  IndianFoot: 0.30479951 / OpenLayers.METERS_PER_INCH,
  IndianFt37: 0.30479841 / OpenLayers.METERS_PER_INCH,
  IndianFt62: 0.3047996 / OpenLayers.METERS_PER_INCH,
  IndianFt75: 0.3047995 / OpenLayers.METERS_PER_INCH,
  Mile: 1609.34721869443738887477 / OpenLayers.METERS_PER_INCH,
  IYard: 0.9144 / OpenLayers.METERS_PER_INCH,
  IMile: 1609.344 / OpenLayers.METERS_PER_INCH,
  NautM: 1852.0 / OpenLayers.METERS_PER_INCH,
  "Lat-66": 110943.316488932731 / OpenLayers.METERS_PER_INCH,
  "Lat-83": 110946.25736872234125 / OpenLayers.METERS_PER_INCH,
  Decimeter: 0.1 / OpenLayers.METERS_PER_INCH,
  Millimeter: 0.001 / OpenLayers.METERS_PER_INCH,
  Dekameter: 10.0 / OpenLayers.METERS_PER_INCH,
  Decameter: 10.0 / OpenLayers.METERS_PER_INCH,
  Hectometer: 100.0 / OpenLayers.METERS_PER_INCH,
  GermanMeter: 1.0000135965 / OpenLayers.METERS_PER_INCH,
  CaGrid: 0.999738 / OpenLayers.METERS_PER_INCH,
  ClarkeChain: 20.1166194976 / OpenLayers.METERS_PER_INCH,
  GunterChain: 20.11684023368047 / OpenLayers.METERS_PER_INCH,
  BenoitChain: 20.116782494375872 / OpenLayers.METERS_PER_INCH,
  SearsChain: 20.11676512155 / OpenLayers.METERS_PER_INCH,
  ClarkeLink: 0.201166194976 / OpenLayers.METERS_PER_INCH,
  GunterLink: 0.2011684023368047 / OpenLayers.METERS_PER_INCH,
  BenoitLink: 0.20116782494375872 / OpenLayers.METERS_PER_INCH,
  SearsLink: 0.2011676512155 / OpenLayers.METERS_PER_INCH,
  Rod: 5.02921005842012 / OpenLayers.METERS_PER_INCH,
  IntnlChain: 20.1168 / OpenLayers.METERS_PER_INCH,
  IntnlLink: 0.201168 / OpenLayers.METERS_PER_INCH,
  Perch: 5.02921005842012 / OpenLayers.METERS_PER_INCH,
  Pole: 5.02921005842012 / OpenLayers.METERS_PER_INCH,
  Furlong: 201.1684023368046 / OpenLayers.METERS_PER_INCH,
  Rood: 3.778266898 / OpenLayers.METERS_PER_INCH,
  CapeFoot: 0.3047972615 / OpenLayers.METERS_PER_INCH,
  Brealey: 375.0 / OpenLayers.METERS_PER_INCH,
  ModAmFt: 0.304812252984505969011938 / OpenLayers.METERS_PER_INCH,
  Fathom: 1.8288 / OpenLayers.METERS_PER_INCH,
  "NautM-UK": 1853.184 / OpenLayers.METERS_PER_INCH,
  "50kilometers": 50000.0 / OpenLayers.METERS_PER_INCH,
  "150kilometers": 150000.0 / OpenLayers.METERS_PER_INCH
});
OpenLayers.Util.extend(OpenLayers.INCHES_PER_UNIT, {
  mm: OpenLayers.INCHES_PER_UNIT["Meter"] / 1000.0,
  cm: OpenLayers.INCHES_PER_UNIT["Meter"] / 100.0,
  dm: OpenLayers.INCHES_PER_UNIT["Meter"] * 100.0,
  km: OpenLayers.INCHES_PER_UNIT["Meter"] * 1000.0,
  kmi: OpenLayers.INCHES_PER_UNIT["nmi"],
  fath: OpenLayers.INCHES_PER_UNIT["Fathom"],
  ch: OpenLayers.INCHES_PER_UNIT["IntnlChain"],
  link: OpenLayers.INCHES_PER_UNIT["IntnlLink"],
  "us-in": OpenLayers.INCHES_PER_UNIT["inches"],
  "us-ft": OpenLayers.INCHES_PER_UNIT["Foot"],
  "us-yd": OpenLayers.INCHES_PER_UNIT["Yard"],
  "us-ch": OpenLayers.INCHES_PER_UNIT["GunterChain"],
  "us-mi": OpenLayers.INCHES_PER_UNIT["Mile"],
  "ind-yd": OpenLayers.INCHES_PER_UNIT["IndianYd37"],
  "ind-ft": OpenLayers.INCHES_PER_UNIT["IndianFt37"],
  "ind-ch": 20.11669506 / OpenLayers.METERS_PER_INCH
});
OpenLayers.DOTS_PER_INCH = 72;
OpenLayers.Util.normalizeScale = function(scale) {
  var normScale = scale > 1.0 ? 1.0 / scale : scale;
  return normScale;
};
OpenLayers.Util.getResolutionFromScale = function(scale, units) {
  var resolution;
  if (scale) {
    if (units == null) {
      units = "degrees";
    }
    var normScale = OpenLayers.Util.normalizeScale(scale);
    resolution =
      1 /
      (normScale *
        OpenLayers.INCHES_PER_UNIT[units] *
        OpenLayers.DOTS_PER_INCH);
  }
  return resolution;
};
OpenLayers.Util.getScaleFromResolution = function(resolution, units) {
  if (units == null) {
    units = "degrees";
  }
  var scale =
    resolution * OpenLayers.INCHES_PER_UNIT[units] * OpenLayers.DOTS_PER_INCH;
  return scale;
};
OpenLayers.Util.pagePosition = function(forElement) {
  var pos = [0, 0];
  var viewportElement = OpenLayers.Util.getViewportElement();
  if (!forElement || forElement == window || forElement == viewportElement) {
    return pos;
  }
  var BUGGY_GECKO_BOX_OBJECT =
    OpenLayers.IS_GECKO &&
    document.getBoxObjectFor &&
    OpenLayers.Element.getStyle(forElement, "position") == "absolute" &&
    (forElement.style.top == "" || forElement.style.left == "");
  var parent = null;
  var box;
  if (forElement.getBoundingClientRect) {
    box = forElement.getBoundingClientRect();
    var scrollTop = viewportElement.scrollTop;
    var scrollLeft = viewportElement.scrollLeft;
    pos[0] = box.left + scrollLeft;
    pos[1] = box.top + scrollTop;
  } else if (document.getBoxObjectFor && !BUGGY_GECKO_BOX_OBJECT) {
    box = document.getBoxObjectFor(forElement);
    var vpBox = document.getBoxObjectFor(viewportElement);
    pos[0] = box.screenX - vpBox.screenX;
    pos[1] = box.screenY - vpBox.screenY;
  } else {
    pos[0] = forElement.offsetLeft;
    pos[1] = forElement.offsetTop;
    parent = forElement.offsetParent;
    if (parent != forElement) {
      while (parent) {
        pos[0] += parent.offsetLeft;
        pos[1] += parent.offsetTop;
        parent = parent.offsetParent;
      }
    }
    var browser = OpenLayers.BROWSER_NAME;
    if (
      browser == "opera" ||
      (browser == "safari" &&
        OpenLayers.Element.getStyle(forElement, "position") == "absolute")
    ) {
      pos[1] -= document.body.offsetTop;
    }
    parent = forElement.offsetParent;
    while (parent && parent != document.body) {
      pos[0] -= parent.scrollLeft;
      if (browser != "opera" || parent.tagName != "TR") {
        pos[1] -= parent.scrollTop;
      }
      parent = parent.offsetParent;
    }
  }
  return pos;
};
OpenLayers.Util.getViewportElement = function() {
  var viewportElement = arguments.callee.viewportElement;
  if (viewportElement == undefined) {
    viewportElement =
      OpenLayers.BROWSER_NAME == "msie" && document.compatMode != "CSS1Compat"
        ? document.body
        : document.documentElement;
    arguments.callee.viewportElement = viewportElement;
  }
  return viewportElement;
};
OpenLayers.Util.isEquivalentUrl = function(url1, url2, options) {
  options = options || {};
  OpenLayers.Util.applyDefaults(options, {
    ignoreCase: true,
    ignorePort80: true,
    ignoreHash: true
  });
  var urlObj1 = OpenLayers.Util.createUrlObject(url1, options);
  var urlObj2 = OpenLayers.Util.createUrlObject(url2, options);
  for (var key in urlObj1) {
    if (key !== "args") {
      if (urlObj1[key] != urlObj2[key]) {
        return false;
      }
    }
  }
  for (var key in urlObj1.args) {
    if (urlObj1.args[key] != urlObj2.args[key]) {
      return false;
    }
    delete urlObj2.args[key];
  }
  for (var key in urlObj2.args) {
    return false;
  }
  return true;
};
OpenLayers.Util.createUrlObject = function(url, options) {
  options = options || {};
  if (!/^\w+:\/\//.test(url)) {
    var loc = window.location;
    var port = loc.port ? ":" + loc.port : "";
    var fullUrl = loc.protocol + "//" + loc.host.split(":").shift() + port;
    if (url.indexOf("/") === 0) {
      url = fullUrl + url;
    } else {
      var parts = loc.pathname.split("/");
      parts.pop();
      url = fullUrl + parts.join("/") + "/" + url;
    }
  }
  if (options.ignoreCase) {
    url = url.toLowerCase();
  }
  var a = document.createElement("a");
  a.href = url;
  var urlObject = {};
  urlObject.host = a.host.split(":").shift();
  urlObject.protocol = a.protocol;
  if (options.ignorePort80) {
    urlObject.port = a.port == "80" || a.port == "0" ? "" : a.port;
  } else {
    urlObject.port = a.port == "" || a.port == "0" ? "80" : a.port;
  }
  urlObject.hash = options.ignoreHash || a.hash === "#" ? "" : a.hash;
  var queryString = a.search;
  if (!queryString) {
    var qMark = url.indexOf("?");
    queryString = qMark != -1 ? url.substr(qMark) : "";
  }
  urlObject.args = OpenLayers.Util.getParameters(queryString);
  urlObject.pathname =
    a.pathname.charAt(0) == "/" ? a.pathname : "/" + a.pathname;
  return urlObject;
};
OpenLayers.Util.removeTail = function(url) {
  var head = null;
  var qMark = url.indexOf("?");
  var hashMark = url.indexOf("#");
  if (qMark == -1) {
    head = hashMark != -1 ? url.substr(0, hashMark) : url;
  } else {
    head =
      hashMark != -1
        ? url.substr(0, Math.min(qMark, hashMark))
        : url.substr(0, qMark);
  }
  return head;
};
OpenLayers.IS_GECKO = (function() {
  var ua = navigator.userAgent.toLowerCase();
  return ua.indexOf("webkit") == -1 && ua.indexOf("gecko") != -1;
})();
OpenLayers.CANVAS_SUPPORTED = (function() {
  var elem = document.createElement("canvas");
  return !!(elem.getContext && elem.getContext("2d"));
})();
OpenLayers.BROWSER_NAME = (function() {
  var name = "";
  var ua = navigator.userAgent.toLowerCase();
  if (ua.indexOf("opera") != -1) {
    name = "opera";
  } else if (ua.indexOf("msie") != -1) {
    name = "msie";
  } else if (ua.indexOf("safari") != -1) {
    name = "safari";
  } else if (ua.indexOf("mozilla") != -1) {
    if (ua.indexOf("firefox") != -1) {
      name = "firefox";
    } else {
      name = "mozilla";
    }
  }
  return name;
})();
OpenLayers.Util.getBrowserName = function() {
  return OpenLayers.BROWSER_NAME;
};
OpenLayers.Util.getRenderedDimensions = function(contentHTML, size, options) {
  var w, h;
  var container = document.createElement("div");
  container.style.visibility = "hidden";
  var containerElement =
    options && options.containerElement
      ? options.containerElement
      : document.body;
  var parentHasPositionAbsolute = false;
  var superContainer = null;
  var parent = containerElement;
  while (parent && parent.tagName.toLowerCase() != "body") {
    var parentPosition = OpenLayers.Element.getStyle(parent, "position");
    if (parentPosition == "absolute") {
      parentHasPositionAbsolute = true;
      break;
    } else if (parentPosition && parentPosition != "static") {
      break;
    }
    parent = parent.parentNode;
  }
  if (
    parentHasPositionAbsolute &&
    (containerElement.clientHeight === 0 || containerElement.clientWidth === 0)
  ) {
    superContainer = document.createElement("div");
    superContainer.style.visibility = "hidden";
    superContainer.style.position = "absolute";
    superContainer.style.overflow = "visible";
    superContainer.style.width = document.body.clientWidth + "px";
    superContainer.style.height = document.body.clientHeight + "px";
    superContainer.appendChild(container);
  }
  container.style.position = "absolute";
  if (size) {
    if (size.w) {
      w = size.w;
      container.style.width = w + "px";
    } else if (size.h) {
      h = size.h;
      container.style.height = h + "px";
    }
  }
  if (options && options.displayClass) {
    container.className = options.displayClass;
  }
  var content = document.createElement("div");
  content.innerHTML = contentHTML;
  content.style.overflow = "visible";
  if (content.childNodes) {
    for (var i = 0, l = content.childNodes.length; i < l; i++) {
      if (!content.childNodes[i].style) continue;
      content.childNodes[i].style.overflow = "visible";
    }
  }
  container.appendChild(content);
  if (superContainer) {
    containerElement.appendChild(superContainer);
  } else {
    containerElement.appendChild(container);
  }
  if (!w) {
    w = parseInt(content.scrollWidth);
    container.style.width = w + "px";
  }
  if (!h) {
    h = parseInt(content.scrollHeight);
  }
  container.removeChild(content);
  if (superContainer) {
    superContainer.removeChild(container);
    containerElement.removeChild(superContainer);
  } else {
    containerElement.removeChild(container);
  }
  return new OpenLayers.Size(w, h);
};
OpenLayers.Util.getScrollbarWidth = function() {
  var scrollbarWidth = OpenLayers.Util._scrollbarWidth;
  if (scrollbarWidth == null) {
    var scr = null;
    var inn = null;
    var wNoScroll = 0;
    var wScroll = 0;
    scr = document.createElement("div");
    scr.style.position = "absolute";
    scr.style.top = "-1000px";
    scr.style.left = "-1000px";
    scr.style.width = "100px";
    scr.style.height = "50px";
    scr.style.overflow = "hidden";
    inn = document.createElement("div");
    inn.style.width = "100%";
    inn.style.height = "200px";
    scr.appendChild(inn);
    document.body.appendChild(scr);
    wNoScroll = inn.offsetWidth;
    scr.style.overflow = "scroll";
    wScroll = inn.offsetWidth;
    document.body.removeChild(document.body.lastChild);
    OpenLayers.Util._scrollbarWidth = wNoScroll - wScroll;
    scrollbarWidth = OpenLayers.Util._scrollbarWidth;
  }
  return scrollbarWidth;
};
OpenLayers.Util.getFormattedLonLat = function(coordinate, axis, dmsOption) {
  if (!dmsOption) {
    dmsOption = "dms";
  }
  coordinate = ((coordinate + 540) % 360) - 180;
  var abscoordinate = Math.abs(coordinate);
  var coordinatedegrees = Math.floor(abscoordinate);
  var coordinateminutes = (abscoordinate - coordinatedegrees) / (1 / 60);
  var tempcoordinateminutes = coordinateminutes;
  coordinateminutes = Math.floor(coordinateminutes);
  var coordinateseconds =
    (tempcoordinateminutes - coordinateminutes) / (1 / 60);
  coordinateseconds = Math.round(coordinateseconds * 10);
  coordinateseconds /= 10;
  if (coordinateseconds >= 60) {
    coordinateseconds -= 60;
    coordinateminutes += 1;
    if (coordinateminutes >= 60) {
      coordinateminutes -= 60;
      coordinatedegrees += 1;
    }
  }
  if (coordinatedegrees < 10) {
    coordinatedegrees = "0" + coordinatedegrees;
  }
  var str = coordinatedegrees + "\u00B0";
  if (dmsOption.indexOf("dm") >= 0) {
    if (coordinateminutes < 10) {
      coordinateminutes = "0" + coordinateminutes;
    }
    str += coordinateminutes + "'";
    if (dmsOption.indexOf("dms") >= 0) {
      if (coordinateseconds < 10) {
        coordinateseconds = "0" + coordinateseconds;
      }
      str += coordinateseconds + '"';
    }
  }
  if (axis == "lon") {
    str += coordinate < 0 ? OpenLayers.i18n("W") : OpenLayers.i18n("E");
  } else {
    str += coordinate < 0 ? OpenLayers.i18n("S") : OpenLayers.i18n("N");
  }
  return str;
};
OpenLayers.Event = {
  observers: false,
  KEY_SPACE: 32,
  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;
  },
  isSingleTouch: function(event) {
    return event.touches && event.touches.length == 1;
  },
  isMultiTouch: function(event) {
    return event.touches && event.touches.length > 1;
  },
  isLeftClick: function(event) {
    return (
      (event.which && event.which == 1) || (event.button && event.button == 1)
    );
  },
  isRightClick: function(event) {
    return (
      (event.which && event.which == 3) || (event.button && event.button == 2)
    );
  },
  stop: function(event, allowDefault) {
    if (!allowDefault) {
      if (event.preventDefault) {
        event.preventDefault();
      } else {
        event.returnValue = false;
      }
    }
    if (event.stopPropagation) {
      event.stopPropagation();
    } else {
      event.cancelBubble = true;
    }
  },
  findElement: function(event, tagName) {
    var element = OpenLayers.Event.element(event);
    while (
      element.parentNode &&
      (!element.tagName ||
        element.tagName.toUpperCase() != tagName.toUpperCase())
    ) {
      element = element.parentNode;
    }
    return element;
  },
  observe: function(elementParam, name, observer, useCapture) {
    var element = OpenLayers.Util.getElement(elementParam);
    useCapture = useCapture || false;
    if (
      name == "keypress" &&
      (navigator.appVersion.match(/Konqueror|Safari|KHTML/) ||
        element.attachEvent)
    ) {
      name = "keydown";
    }
    if (!this.observers) {
      this.observers = {};
    }
    if (!element._eventCacheID) {
      var idPrefix = "eventCacheID_";
      if (element.id) {
        idPrefix = element.id + "_" + idPrefix;
      }
      element._eventCacheID = OpenLayers.Util.createUniqueID(idPrefix);
    }
    var cacheID = element._eventCacheID;
    if (!this.observers[cacheID]) {
      this.observers[cacheID] = [];
    }
    this.observers[cacheID].push({
      element: element,
      name: name,
      observer: observer,
      useCapture: useCapture
    });
    if (element.addEventListener) {
      element.addEventListener(name, observer, useCapture);
    } else if (element.attachEvent) {
      element.attachEvent("on" + name, observer);
    }
  },
  stopObservingElement: function(elementParam) {
    var element = OpenLayers.Util.getElement(elementParam);
    var cacheID = element._eventCacheID;
    this._removeElementObservers(OpenLayers.Event.observers[cacheID]);
  },
  _removeElementObservers: function(elementObservers) {
    if (elementObservers) {
      for (var i = elementObservers.length - 1; i >= 0; i--) {
        var entry = elementObservers[i];
        var args = new Array(
          entry.element,
          entry.name,
          entry.observer,
          entry.useCapture
        );
        var removed = OpenLayers.Event.stopObserving.apply(this, args);
      }
    }
  },
  stopObserving: function(elementParam, name, observer, useCapture) {
    useCapture = useCapture || false;
    var element = OpenLayers.Util.getElement(elementParam);
    var cacheID = element._eventCacheID;
    if (name == "keypress") {
      if (
        navigator.appVersion.match(/Konqueror|Safari|KHTML/) ||
        element.detachEvent
      ) {
        name = "keydown";
      }
    }
    var foundEntry = false;
    var elementObservers = OpenLayers.Event.observers[cacheID];
    if (elementObservers) {
      var i = 0;
      while (!foundEntry && i < elementObservers.length) {
        var cacheEntry = elementObservers[i];
        if (
          cacheEntry.name == name &&
          cacheEntry.observer == observer &&
          cacheEntry.useCapture == useCapture
        ) {
          elementObservers.splice(i, 1);
          if (elementObservers.length == 0) {
            delete OpenLayers.Event.observers[cacheID];
          }
          foundEntry = true;
          break;
        }
        i++;
      }
    }
    if (foundEntry) {
      if (element.removeEventListener) {
        element.removeEventListener(name, observer, useCapture);
      } else if (element && element.detachEvent) {
        element.detachEvent("on" + name, observer);
      }
    }
    return foundEntry;
  },
  unloadCache: function() {
    if (OpenLayers.Event && OpenLayers.Event.observers) {
      for (var cacheID in OpenLayers.Event.observers) {
        var elementObservers = OpenLayers.Event.observers[cacheID];
        OpenLayers.Event._removeElementObservers.apply(this, [
          elementObservers
        ]);
      }
      OpenLayers.Event.observers = false;
    }
  },
  CLASS_NAME: "OpenLayers.Event"
};
OpenLayers.Event.observe(window, "unload", OpenLayers.Event.unloadCache, false);
OpenLayers.Events = OpenLayers.Class({
  BROWSER_EVENTS: [
    "mouseover",
    "mouseout",
    "mousedown",
    "mouseup",
    "mousemove",
    "click",
    "dblclick",
    "rightclick",
    "dblrightclick",
    "resize",
    "focus",
    "blur",
    "touchstart",
    "touchmove",
    "touchend",
    "keydown"
  ],
  listeners: null,
  object: null,
  element: null,
  eventHandler: null,
  fallThrough: null,
  includeXY: false,
  extensions: null,
  extensionCount: null,
  clearMouseListener: null,
  initialize: function(object, element, eventTypes, fallThrough, options) {
    OpenLayers.Util.extend(this, options);
    this.object = object;
    this.fallThrough = fallThrough;
    this.listeners = {};
    this.extensions = {};
    this.extensionCount = {};
    if (element != null) {
      this.attachToElement(element);
    }
  },
  destroy: function() {
    for (var e in this.extensions) {
      if (typeof this.extensions[e] !== "boolean") {
        this.extensions[e].destroy();
      }
    }
    this.extensions = null;
    if (this.element) {
      OpenLayers.Event.stopObservingElement(this.element);
      if (this.element.hasScrollEvent) {
        OpenLayers.Event.stopObserving(
          window,
          "scroll",
          this.clearMouseListener
        );
      }
    }
    this.element = null;
    this.listeners = null;
    this.object = null;
    this.fallThrough = null;
    this.eventHandler = null;
  },
  addEventType: function(eventName) {},
  attachToElement: function(element) {
    if (this.element) {
      OpenLayers.Event.stopObservingElement(this.element);
    } else {
      this.eventHandler = OpenLayers.Function.bindAsEventListener(
        this.handleBrowserEvent,
        this
      );
      this.clearMouseListener = OpenLayers.Function.bind(
        this.clearMouseCache,
        this
      );
    }
    this.element = element;
    for (var i = 0, len = this.BROWSER_EVENTS.length; i < len; i++) {
      OpenLayers.Event.observe(
        element,
        this.BROWSER_EVENTS[i],
        this.eventHandler
      );
    }
    OpenLayers.Event.observe(element, "dragstart", OpenLayers.Event.stop);
  },
  on: function(object) {
    for (var type in object) {
      if (type != "scope" && object.hasOwnProperty(type)) {
        this.register(type, object.scope, object[type]);
      }
    }
  },
  register: function(type, obj, func, priority) {
    if (type in OpenLayers.Events && !this.extensions[type]) {
      this.extensions[type] = new OpenLayers.Events[type](this);
    }
    if (func != null) {
      if (obj == null) {
        obj = this.object;
      }
      var listeners = this.listeners[type];
      if (!listeners) {
        listeners = [];
        this.listeners[type] = listeners;
        this.extensionCount[type] = 0;
      }
      var listener = { obj: obj, func: func };
      if (priority) {
        listeners.splice(this.extensionCount[type], 0, listener);
        if (typeof priority === "object" && priority.extension) {
          this.extensionCount[type]++;
        }
      } else {
        listeners.push(listener);
      }
    }
  },
  registerPriority: function(type, obj, func) {
    this.register(type, obj, func, true);
  },
  un: function(object) {
    for (var type in object) {
      if (type != "scope" && object.hasOwnProperty(type)) {
        this.unregister(type, object.scope, object[type]);
      }
    }
  },
  unregister: function(type, obj, func) {
    if (obj == null) {
      obj = this.object;
    }
    var listeners = this.listeners[type];
    if (listeners != null) {
      for (var i = 0, len = listeners.length; i < len; i++) {
        if (listeners[i].obj == obj && listeners[i].func == func) {
          listeners.splice(i, 1);
          break;
        }
      }
    }
  },
  remove: function(type) {
    if (this.listeners[type] != null) {
      this.listeners[type] = [];
    }
  },
  triggerEvent: function(type, evt) {
    var listeners = this.listeners[type];
    if (!listeners || listeners.length == 0) {
      return undefined;
    }
    if (evt == null) {
      evt = {};
    }
    evt.object = this.object;
    evt.element = this.element;
    if (!evt.type) {
      evt.type = type;
    }
    listeners = listeners.slice();
    var continueChain;
    for (var i = 0, len = listeners.length; i < len; i++) {
      var callback = listeners[i];
      continueChain = callback.func.apply(callback.obj, [evt]);
      if (continueChain != undefined && continueChain == false) {
        break;
      }
    }
    if (!this.fallThrough) {
      OpenLayers.Event.stop(evt, true);
    }
    return continueChain;
  },
  handleBrowserEvent: function(evt) {
    var type = evt.type,
      listeners = this.listeners[type];
    if (!listeners || listeners.length == 0) {
      return;
    }
    var touches = evt.touches;
    if (touches && touches[0]) {
      var x = 0;
      var y = 0;
      var num = touches.length;
      var touch;
      for (var i = 0; i < num; ++i) {
        touch = touches[i];
        x += touch.clientX;
        y += touch.clientY;
      }
      evt.clientX = x / num;
      evt.clientY = y / num;
    }
    if (this.includeXY) {
      evt.xy = this.getMousePosition(evt);
    }
    this.triggerEvent(type, evt);
  },
  clearMouseCache: function() {
    this.element.scrolls = null;
    this.element.lefttop = null;
    var body = document.body;
    if (
      body &&
      !(
        (body.scrollTop != 0 || body.scrollLeft != 0) &&
        navigator.userAgent.match(/iPhone/i)
      )
    ) {
      this.element.offsets = null;
    }
  },
  getMousePosition: function(evt) {
    if (!this.includeXY) {
      this.clearMouseCache();
    } else if (!this.element.hasScrollEvent) {
      OpenLayers.Event.observe(window, "scroll", this.clearMouseListener);
      this.element.hasScrollEvent = true;
    }
    if (!this.element.scrolls) {
      var viewportElement = OpenLayers.Util.getViewportElement();
      this.element.scrolls = [
        viewportElement.scrollLeft,
        viewportElement.scrollTop
      ];
    }
    if (!this.element.lefttop) {
      this.element.lefttop = [
        document.documentElement.clientLeft || 0,
        document.documentElement.clientTop || 0
      ];
    }
    if (!this.element.offsets) {
      this.element.offsets = OpenLayers.Util.pagePosition(this.element);
    }
    return new OpenLayers.Pixel(
      evt.clientX +
        this.element.scrolls[0] -
        this.element.offsets[0] -
        this.element.lefttop[0],
      evt.clientY +
        this.element.scrolls[1] -
        this.element.offsets[1] -
        this.element.lefttop[1]
    );
  },
  CLASS_NAME: "OpenLayers.Events"
});
OpenLayers.Events.buttonclick = OpenLayers.Class({
  target: null,
  events: [
    "mousedown",
    "mouseup",
    "click",
    "dblclick",
    "touchstart",
    "touchmove",
    "touchend",
    "keydown"
  ],
  startRegEx: /^mousedown|touchstart$/,
  cancelRegEx: /^touchmove$/,
  completeRegEx: /^mouseup|touchend$/,
  initialize: function(target) {
    this.target = target;
    for (var i = this.events.length - 1; i >= 0; --i) {
      this.target.register(this.events[i], this, this.buttonClick, {
        extension: true
      });
    }
  },
  destroy: function() {
    for (var i = this.events.length - 1; i >= 0; --i) {
      this.target.unregister(this.events[i], this, this.buttonClick);
    }
    delete this.target;
  },
  getPressedButton: function(element) {
    var depth = 3,
      button;
    do {
      if (OpenLayers.Element.hasClass(element, "olButton")) {
        button = element;
        break;
      }
      element = element.parentNode;
    } while (--depth > 0 && element);
    return button;
  },
  buttonClick: function(evt) {
    var propagate = true,
      element = OpenLayers.Event.element(evt);
    if (
      element &&
      (OpenLayers.Event.isLeftClick(evt) || !~evt.type.indexOf("mouse"))
    ) {
      var button = this.getPressedButton(element);
      if (button) {
        if (evt.type === "keydown") {
          switch (evt.keyCode) {
            case OpenLayers.Event.KEY_RETURN:
            case OpenLayers.Event.KEY_SPACE:
              this.target.triggerEvent("buttonclick", {
                buttonElement: button
              });
              OpenLayers.Event.stop(evt);
              propagate = false;
              break;
          }
        } else if (this.startEvt) {
          if (this.completeRegEx.test(evt.type)) {
            var pos = OpenLayers.Util.pagePosition(button);
            this.target.triggerEvent("buttonclick", {
              buttonElement: button,
              buttonXY: {
                x: this.startEvt.clientX - pos[0],
                y: this.startEvt.clientY - pos[1]
              }
            });
          }
          if (this.cancelRegEx.test(evt.type)) {
            delete this.startEvt;
          }
          OpenLayers.Event.stop(evt);
          propagate = false;
        }
        if (this.startRegEx.test(evt.type)) {
          this.startEvt = evt;
          OpenLayers.Event.stop(evt);
          propagate = false;
        }
      } else {
        delete this.startEvt;
      }
    }
    return propagate;
  }
});
OpenLayers.Animation = (function(window) {
  var isNative = !!(
    window.requestAnimationFrame ||
    window.webkitRequestAnimationFrame ||
    window.mozRequestAnimationFrame ||
    window.oRequestAnimationFrame ||
    window.msRequestAnimationFrame
  );
  var requestFrame = (function() {
    var request =
      window.requestAnimationFrame ||
      window.webkitRequestAnimationFrame ||
      window.mozRequestAnimationFrame ||
      window.oRequestAnimationFrame ||
      window.msRequestAnimationFrame ||
      function(callback, element) {
        window.setTimeout(callback, 16);
      };
    return function(callback, element) {
      request.apply(window, [callback, element]);
    };
  })();
  var counter = 0;
  var loops = {};
  function start(callback, duration, element) {
    duration = duration > 0 ? duration : Number.POSITIVE_INFINITY;
    var id = ++counter;
    var start = +new Date();
    loops[id] = function() {
      if (loops[id] && +new Date() - start <= duration) {
        callback();
        if (loops[id]) {
          requestFrame(loops[id], element);
        }
      } else {
        delete loops[id];
      }
    };
    requestFrame(loops[id], element);
    return id;
  }
  function stop(id) {
    delete loops[id];
  }
  return {
    isNative: isNative,
    requestFrame: requestFrame,
    start: start,
    stop: stop
  };
})(window);
OpenLayers.Tween = OpenLayers.Class({
  easing: null,
  begin: null,
  finish: null,
  duration: null,
  callbacks: null,
  time: null,
  animationId: null,
  playing: false,
  initialize: function(easing) {
    this.easing = easing ? easing : OpenLayers.Easing.Expo.easeOut;
  },
  start: function(begin, finish, duration, options) {
    this.playing = true;
    this.begin = begin;
    this.finish = finish;
    this.duration = duration;
    this.callbacks = options.callbacks;
    this.time = 0;
    OpenLayers.Animation.stop(this.animationId);
    this.animationId = null;
    if (this.callbacks && this.callbacks.start) {
      this.callbacks.start.call(this, this.begin);
    }
    this.animationId = OpenLayers.Animation.start(
      OpenLayers.Function.bind(this.play, this)
    );
  },
  stop: function() {
    if (!this.playing) {
      return;
    }
    if (this.callbacks && this.callbacks.done) {
      this.callbacks.done.call(this, this.finish);
    }
    OpenLayers.Animation.stop(this.animationId);
    this.animationId = null;
    this.playing = false;
  },
  play: function() {
    var value = {};
    for (var i in this.begin) {
      var b = this.begin[i];
      var f = this.finish[i];
      if (b == null || f == null || isNaN(b) || isNaN(f)) {
        throw new TypeError("invalid value for Tween");
      }
      var c = f - b;
      value[i] = this.easing.apply(this, [this.time, b, c, this.duration]);
    }
    this.time++;
    if (this.callbacks && this.callbacks.eachStep) {
      this.callbacks.eachStep.call(this, value);
    }
    if (this.time > this.duration) {
      this.stop();
    }
  },
  CLASS_NAME: "OpenLayers.Tween"
});
OpenLayers.Easing = { CLASS_NAME: "OpenLayers.Easing" };
OpenLayers.Easing.Linear = {
  easeIn: function(t, b, c, d) {
    return (c * t) / d + b;
  },
  easeOut: function(t, b, c, d) {
    return (c * t) / d + b;
  },
  easeInOut: function(t, b, c, d) {
    return (c * t) / d + b;
  },
  CLASS_NAME: "OpenLayers.Easing.Linear"
};
OpenLayers.Easing.Expo = {
  easeIn: function(t, b, c, d) {
    return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
  },
  easeOut: function(t, b, c, d) {
    return t == d ? b + c : c * (-Math.pow(2, (-10 * t) / d) + 1) + b;
  },
  easeInOut: function(t, b, c, d) {
    if (t == 0) return b;
    if (t == d) return b + c;
    if ((t /= d / 2) < 1) return (c / 2) * Math.pow(2, 10 * (t - 1)) + b;
    return (c / 2) * (-Math.pow(2, -10 * --t) + 2) + b;
  },
  CLASS_NAME: "OpenLayers.Easing.Expo"
};
OpenLayers.Easing.Quad = {
  easeIn: function(t, b, c, d) {
    return c * (t /= d) * t + b;
  },
  easeOut: function(t, b, c, d) {
    return -c * (t /= d) * (t - 2) + b;
  },
  easeInOut: function(t, b, c, d) {
    if ((t /= d / 2) < 1) return (c / 2) * t * t + b;
    return (-c / 2) * (--t * (t - 2) - 1) + b;
  },
  CLASS_NAME: "OpenLayers.Easing.Quad"
};
OpenLayers.Projection = OpenLayers.Class({
  proj: null,
  projCode: null,
  titleRegEx: /\+title=[^\+]*/,
  initialize: function(projCode, options) {
    OpenLayers.Util.extend(this, options);
    this.projCode = projCode;
    if (window.Proj4js) {
      this.proj = new Proj4js.Proj(projCode);
    }
  },
  getCode: function() {
    return this.proj ? this.proj.srsCode : this.projCode;
  },
  getUnits: function() {
    return this.proj ? this.proj.units : null;
  },
  toString: function() {
    return this.getCode();
  },
  equals: function(projection) {
    var p = projection,
      equals = false;
    if (p) {
      if (!(p instanceof OpenLayers.Projection)) {
        p = new OpenLayers.Projection(p);
      }
      if (window.Proj4js && this.proj.defData && p.proj.defData) {
        equals =
          this.proj.defData.replace(this.titleRegEx, "") ==
          p.proj.defData.replace(this.titleRegEx, "");
      } else if (p.getCode) {
        var source = this.getCode(),
          target = p.getCode();
        equals =
          source == target ||
          (!!OpenLayers.Projection.transforms[source] &&
            OpenLayers.Projection.transforms[source][target] ===
              OpenLayers.Projection.nullTransform);
      }
    }
    return equals;
  },
  destroy: function() {
    delete this.proj;
    delete this.projCode;
  },
  CLASS_NAME: "OpenLayers.Projection"
});
OpenLayers.Projection.transforms = {};
OpenLayers.Projection.defaults = {
  "EPSG:4326": { units: "degrees", maxExtent: [-180, -90, 180, 90], yx: true },
  "CRS:84": { units: "degrees", maxExtent: [-180, -90, 180, 90] },
  "EPSG:900913": {
    units: "m",
    maxExtent: [-20037508.34, -20037508.34, 20037508.34, 20037508.34]
  }
};
OpenLayers.Projection.addTransform = function(from, to, method) {
  if (method === OpenLayers.Projection.nullTransform) {
    var defaults = OpenLayers.Projection.defaults[from];
    if (defaults && !OpenLayers.Projection.defaults[to]) {
      OpenLayers.Projection.defaults[to] = defaults;
    }
  }
  if (!OpenLayers.Projection.transforms[from]) {
    OpenLayers.Projection.transforms[from] = {};
  }
  OpenLayers.Projection.transforms[from][to] = method;
};
OpenLayers.Projection.transform = function(point, source, dest) {
  if (source && dest) {
    if (!(source instanceof OpenLayers.Projection)) {
      source = new OpenLayers.Projection(source);
    }
    if (!(dest instanceof OpenLayers.Projection)) {
      dest = new OpenLayers.Projection(dest);
    }
    if (source.proj && dest.proj) {
      point = Proj4js.transform(source.proj, dest.proj, point);
    } else {
      var sourceCode = source.getCode();
      var destCode = dest.getCode();
      var transforms = OpenLayers.Projection.transforms;
      if (transforms[sourceCode] && transforms[sourceCode][destCode]) {
        transforms[sourceCode][destCode](point);
      }
    }
  }
  return point;
};
OpenLayers.Projection.nullTransform = function(point) {
  return point;
};
(function() {
  var pole = 20037508.34;
  function inverseMercator(xy) {
    xy.x = (180 * xy.x) / pole;
    xy.y =
      (180 / Math.PI) *
      (2 * Math.atan(Math.exp((xy.y / pole) * Math.PI)) - Math.PI / 2);
    return xy;
  }
  function forwardMercator(xy) {
    xy.x = (xy.x * pole) / 180;
    xy.y = (Math.log(Math.tan(((90 + xy.y) * Math.PI) / 360)) / Math.PI) * pole;
    return xy;
  }
  function map(base, codes) {
    var add = OpenLayers.Projection.addTransform;
    var same = OpenLayers.Projection.nullTransform;
    var i, len, code, other, j;
    for (i = 0, len = codes.length; i < len; ++i) {
      code = codes[i];
      add(base, code, forwardMercator);
      add(code, base, inverseMercator);
      for (j = i + 1; j < len; ++j) {
        other = codes[j];
        add(code, other, same);
        add(other, code, same);
      }
    }
  }
  var mercator = ["EPSG:900913", "EPSG:3857", "EPSG:102113", "EPSG:102100"],
    geographic = ["CRS:84", "urn:ogc:def:crs:EPSG:6.6:4326", "EPSG:4326"],
    i;
  for (i = mercator.length - 1; i >= 0; --i) {
    map(mercator[i], geographic);
  }
  for (i = geographic.length - 1; i >= 0; --i) {
    map(geographic[i], mercator);
  }
})();
OpenLayers.Map = OpenLayers.Class({
  Z_INDEX_BASE: {
    BaseLayer: 100,
    Overlay: 325,
    Feature: 725,
    Popup: 750,
    Control: 1000
  },
  id: null,
  fractionalZoom: false,
  events: null,
  allOverlays: false,
  div: null,
  dragging: false,
  size: null,
  viewPortDiv: null,
  layerContainerOrigin: null,
  layerContainerDiv: null,
  layers: null,
  controls: null,
  popups: null,
  baseLayer: null,
  center: null,
  resolution: null,
  zoom: 0,
  panRatio: 1.5,
  options: null,
  tileSize: null,
  projection: "EPSG:4326",
  units: null,
  resolutions: null,
  maxResolution: null,
  minResolution: null,
  maxScale: null,
  minScale: null,
  maxExtent: null,
  minExtent: null,
  restrictedExtent: null,
  numZoomLevels: 16,
  theme: null,
  displayProjection: null,
  fallThrough: true,
  panTween: null,
  eventListeners: null,
  panMethod: OpenLayers.Easing.Expo.easeOut,
  panDuration: 50,
  paddingForPopups: null,
  minPx: null,
  maxPx: null,
  initialize: function(div, options) {
    if (arguments.length === 1 && typeof div === "object") {
      options = div;
      div = options && options.div;
    }
    this.tileSize = new OpenLayers.Size(
      OpenLayers.Map.TILE_WIDTH,
      OpenLayers.Map.TILE_HEIGHT
    );
    this.paddingForPopups = new OpenLayers.Bounds(15, 15, 15, 15);
    this.options = OpenLayers.Util.extend({}, options);
    OpenLayers.Util.extend(this, options);
    var projCode =
      this.projection instanceof OpenLayers.Projection
        ? this.projection.projCode
        : this.projection;
    OpenLayers.Util.applyDefaults(
      this,
      OpenLayers.Projection.defaults[projCode]
    );
    if (this.maxExtent && !(this.maxExtent instanceof OpenLayers.Bounds)) {
      this.maxExtent = new OpenLayers.Bounds(this.maxExtent);
    }
    if (this.minExtent && !(this.minExtent instanceof OpenLayers.Bounds)) {
      this.minExtent = new OpenLayers.Bounds(this.minExtent);
    }
    if (
      this.restrictedExtent &&
      !(this.restrictedExtent instanceof OpenLayers.Bounds)
    ) {
      this.restrictedExtent = new OpenLayers.Bounds(this.restrictedExtent);
    }
    if (this.center && !(this.center instanceof OpenLayers.LonLat)) {
      this.center = new OpenLayers.LonLat(this.center);
    }
    this.layers = [];
    this.id = OpenLayers.Util.createUniqueID("OpenLayers.Map_");
    this.div = OpenLayers.Util.getElement(div);
    if (!this.div) {
      this.div = document.createElement("div");
      this.div.style.height = "1px";
      this.div.style.width = "1px";
    }
    OpenLayers.Element.addClass(this.div, "olMap");
    var id = this.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.viewPortDiv.className = "olMapViewport";
    this.div.appendChild(this.viewPortDiv);
    this.events = new OpenLayers.Events(
      this,
      this.viewPortDiv,
      null,
      this.fallThrough,
      { includeXY: true }
    );
    id = this.id + "_OpenLayers_Container";
    this.layerContainerDiv = OpenLayers.Util.createDiv(id);
    this.layerContainerDiv.style.width = "100px";
    this.layerContainerDiv.style.height = "100px";
    this.layerContainerDiv.style.zIndex = this.Z_INDEX_BASE["Popup"] - 1;
    this.viewPortDiv.appendChild(this.layerContainerDiv);
    this.updateSize();
    if (this.eventListeners instanceof Object) {
      this.events.on(this.eventListeners);
    }
    if (parseFloat(navigator.appVersion.split("MSIE")[1]) < 9) {
      this.events.register("resize", this, this.updateSize);
    } else {
      this.updateSizeDestroy = OpenLayers.Function.bind(this.updateSize, this);
      OpenLayers.Event.observe(window, "resize", this.updateSizeDestroy);
    }
    if (this.theme) {
      var addNode = true;
      var nodes = document.getElementsByTagName("link");
      for (var i = 0, len = nodes.length; i < len; ++i) {
        if (OpenLayers.Util.isEquivalentUrl(nodes.item(i).href, this.theme)) {
          addNode = false;
          break;
        }
      }
      if (addNode) {
        var cssNode = document.createElement("link");
        cssNode.setAttribute("rel", "stylesheet");
        cssNode.setAttribute("type", "text/css");
        cssNode.setAttribute("href", this.theme);
        document.getElementsByTagName("head")[0].appendChild(cssNode);
      }
    }
    if (this.controls == null) {
      this.controls = [];
      if (OpenLayers.Control != null) {
        if (OpenLayers.Control.Navigation) {
          this.controls.push(new OpenLayers.Control.Navigation());
        } else if (OpenLayers.Control.TouchNavigation) {
          this.controls.push(new OpenLayers.Control.TouchNavigation());
        }
        if (OpenLayers.Control.Zoom) {
          this.controls.push(new OpenLayers.Control.Zoom());
        } else if (OpenLayers.Control.PanZoom) {
          this.controls.push(new OpenLayers.Control.PanZoom());
        }
        if (OpenLayers.Control.ArgParser) {
          this.controls.push(new OpenLayers.Control.ArgParser());
        }
        if (OpenLayers.Control.Attribution) {
          this.controls.push(new OpenLayers.Control.Attribution());
        }
      }
    }
    for (var i = 0, len = this.controls.length; i < len; i++) {
      this.addControlToMap(this.controls[i]);
    }
    this.popups = [];
    this.unloadDestroy = OpenLayers.Function.bind(this.destroy, this);
    OpenLayers.Event.observe(window, "unload", this.unloadDestroy);
    if (options && options.layers) {
      delete this.center;
      this.addLayers(options.layers);
      if (options.center && !this.getCenter()) {
        this.setCenter(options.center, options.zoom);
      }
    }
  },
  getViewport: function() {
    return this.viewPortDiv;
  },
  render: function(div) {
    this.div = OpenLayers.Util.getElement(div);
    OpenLayers.Element.addClass(this.div, "olMap");
    this.viewPortDiv.parentNode.removeChild(this.viewPortDiv);
    this.div.appendChild(this.viewPortDiv);
    this.updateSize();
  },
  unloadDestroy: null,
  updateSizeDestroy: null,
  destroy: function() {
    if (!this.unloadDestroy) {
      return false;
    }
    if (this.panTween) {
      this.panTween.stop();
      this.panTween = null;
    }
    OpenLayers.Event.stopObserving(window, "unload", this.unloadDestroy);
    this.unloadDestroy = null;
    if (this.updateSizeDestroy) {
      OpenLayers.Event.stopObserving(window, "resize", this.updateSizeDestroy);
    } else {
      this.events.unregister("resize", this, this.updateSize);
    }
    this.paddingForPopups = null;
    if (this.controls != null) {
      for (var i = this.controls.length - 1; i >= 0; --i) {
        this.controls[i].destroy();
      }
      this.controls = null;
    }
    if (this.layers != null) {
      for (var i = this.layers.length - 1; i >= 0; --i) {
        this.layers[i].destroy(false);
      }
      this.layers = null;
    }
    if (this.viewPortDiv) {
      this.div.removeChild(this.viewPortDiv);
    }
    this.viewPortDiv = null;
    if (this.eventListeners) {
      this.events.un(this.eventListeners);
      this.eventListeners = null;
    }
    this.events.destroy();
    this.events = null;
    this.options = null;
  },
  setOptions: function(options) {
    var updatePxExtent =
      this.minPx && options.restrictedExtent != this.restrictedExtent;
    OpenLayers.Util.extend(this, options);
    updatePxExtent &&
      this.moveTo(this.getCachedCenter(), this.zoom, { forceZoomChange: true });
  },
  getTileSize: function() {
    return this.tileSize;
  },
  getBy: function(array, property, match) {
    var test = typeof match.test == "function";
    var found = OpenLayers.Array.filter(this[array], function(item) {
      return item[property] == match || (test && match.test(item[property]));
    });
    return found;
  },
  getLayersBy: function(property, match) {
    return this.getBy("layers", property, match);
  },
  getLayersByName: function(match) {
    return this.getLayersBy("name", match);
  },
  getLayersByClass: function(match) {
    return this.getLayersBy("CLASS_NAME", match);
  },
  getControlsBy: function(property, match) {
    return this.getBy("controls", property, match);
  },
  getControlsByClass: function(match) {
    return this.getControlsBy("CLASS_NAME", match);
  },
  getLayer: function(id) {
    var foundLayer = null;
    for (var i = 0, len = this.layers.length; i < len; i++) {
      var layer = this.layers[i];
      if (layer.id == id) {
        foundLayer = layer;
        break;
      }
    }
    return foundLayer;
  },
  setLayerZIndex: function(layer, zIdx) {
    layer.setZIndex(
      this.Z_INDEX_BASE[layer.isBaseLayer ? "BaseLayer" : "Overlay"] + zIdx * 5
    );
  },
  resetLayersZIndex: function() {
    for (var i = 0, len = this.layers.length; i < len; i++) {
      var layer = this.layers[i];
      this.setLayerZIndex(layer, i);
    }
  },
  addLayer: function(layer) {
    for (var i = 0, len = this.layers.length; i < len; i++) {
      if (this.layers[i] == layer) {
        return false;
      }
    }
    if (this.events.triggerEvent("preaddlayer", { layer: layer }) === false) {
      return false;
    }
    if (this.allOverlays) {
      layer.isBaseLayer = false;
    }
    layer.div.className = "olLayerDiv";
    layer.div.style.overflow = "";
    this.setLayerZIndex(layer, this.layers.length);
    if (layer.isFixed) {
      this.viewPortDiv.appendChild(layer.div);
    } else {
      this.layerContainerDiv.appendChild(layer.div);
    }
    this.layers.push(layer);
    layer.setMap(this);
    if (layer.isBaseLayer || (this.allOverlays && !this.baseLayer)) {
      if (this.baseLayer == null) {
        this.setBaseLayer(layer);
      } else {
        layer.setVisibility(false);
      }
    } else {
      layer.redraw();
    }
    this.events.triggerEvent("addlayer", { layer: layer });
    layer.events.triggerEvent("added", { map: this, layer: layer });
    layer.afterAdd();
    return true;
  },
  addLayers: function(layers) {
    for (var i = 0, len = layers.length; i < len; i++) {
      this.addLayer(layers[i]);
    }
  },
  removeLayer: function(layer, setNewBaseLayer) {
    if (
      this.events.triggerEvent("preremovelayer", { layer: layer }) === false
    ) {
      return;
    }
    if (setNewBaseLayer == null) {
      setNewBaseLayer = true;
    }
    if (layer.isFixed) {
      this.viewPortDiv.removeChild(layer.div);
    } else {
      this.layerContainerDiv.removeChild(layer.div);
    }
    OpenLayers.Util.removeItem(this.layers, layer);
    layer.removeMap(this);
    layer.map = null;
    if (this.baseLayer == layer) {
      this.baseLayer = null;
      if (setNewBaseLayer) {
        for (var i = 0, len = this.layers.length; i < len; i++) {
          var iLayer = this.layers[i];
          if (iLayer.isBaseLayer || this.allOverlays) {
            this.setBaseLayer(iLayer);
            break;
          }
        }
      }
    }
    this.resetLayersZIndex();
    this.events.triggerEvent("removelayer", { layer: layer });
    layer.events.triggerEvent("removed", { map: this, layer: layer });
  },
  getNumLayers: function() {
    return this.layers.length;
  },
  getLayerIndex: function(layer) {
    return OpenLayers.Util.indexOf(this.layers, layer);
  },
  setLayerIndex: function(layer, idx) {
    var base = this.getLayerIndex(layer);
    if (idx < 0) {
      idx = 0;
    } else if (idx > this.layers.length) {
      idx = this.layers.length;
    }
    if (base != idx) {
      this.layers.splice(base, 1);
      this.layers.splice(idx, 0, layer);
      for (var i = 0, len = this.layers.length; i < len; i++) {
        this.setLayerZIndex(this.layers[i], i);
      }
      this.events.triggerEvent("changelayer", {
        layer: layer,
        property: "order"
      });
      if (this.allOverlays) {
        if (idx === 0) {
          this.setBaseLayer(layer);
        } else if (this.baseLayer !== this.layers[0]) {
          this.setBaseLayer(this.layers[0]);
        }
      }
    }
  },
  raiseLayer: function(layer, delta) {
    var idx = this.getLayerIndex(layer) + delta;
    this.setLayerIndex(layer, idx);
  },
  setBaseLayer: function(newBaseLayer) {
    if (newBaseLayer != this.baseLayer) {
      if (OpenLayers.Util.indexOf(this.layers, newBaseLayer) != -1) {
        var center = this.getCachedCenter();
        var newResolution = OpenLayers.Util.getResolutionFromScale(
          this.getScale(),
          newBaseLayer.units
        );
        if (this.baseLayer != null && !this.allOverlays) {
          this.baseLayer.setVisibility(false);
        }
        this.baseLayer = newBaseLayer;
        if (!this.allOverlays || this.baseLayer.visibility) {
          this.baseLayer.setVisibility(true);
          if (this.baseLayer.inRange === false) {
            this.baseLayer.redraw();
          }
        }
        if (center != null) {
          var newZoom = this.getZoomForResolution(
            newResolution || this.resolution,
            true
          );
          this.setCenter(center, newZoom, false, true);
        }
        this.events.triggerEvent("changebaselayer", { layer: this.baseLayer });
      }
    }
  },
  addControl: function(control, px) {
    this.controls.push(control);
    this.addControlToMap(control, px);
  },
  addControls: function(controls, pixels) {
    var pxs = arguments.length === 1 ? [] : pixels;
    for (var i = 0, len = controls.length; i < len; i++) {
      var ctrl = controls[i];
      var px = pxs[i] ? pxs[i] : null;
      this.addControl(ctrl, px);
    }
  },
  addControlToMap: function(control, px) {
    control.outsideViewport = control.div != null;
    if (this.displayProjection && !control.displayProjection) {
      control.displayProjection = this.displayProjection;
    }
    control.setMap(this);
    var div = control.draw(px);
    if (div) {
      if (!control.outsideViewport) {
        div.style.zIndex = this.Z_INDEX_BASE["Control"] + this.controls.length;
        this.viewPortDiv.appendChild(div);
      }
    }
    if (control.autoActivate) {
      control.activate();
    }
  },
  getControl: function(id) {
    var returnControl = null;
    for (var i = 0, len = this.controls.length; i < len; i++) {
      var control = this.controls[i];
      if (control.id == id) {
        returnControl = control;
        break;
      }
    }
    return returnControl;
  },
  removeControl: function(control) {
    if (control && control == this.getControl(control.id)) {
      if (control.div && control.div.parentNode == this.viewPortDiv) {
        this.viewPortDiv.removeChild(control.div);
      }
      OpenLayers.Util.removeItem(this.controls, control);
    }
  },
  addPopup: function(popup, exclusive) {
    if (exclusive) {
      for (var i = this.popups.length - 1; i >= 0; --i) {
        this.removePopup(this.popups[i]);
      }
    }
    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);
    }
  },
  removePopup: function(popup) {
    OpenLayers.Util.removeItem(this.popups, popup);
    if (popup.div) {
      try {
        this.layerContainerDiv.removeChild(popup.div);
      } catch (e) {}
    }
    popup.map = null;
  },
  getSize: function() {
    var size = null;
    if (this.size != null) {
      size = this.size.clone();
    }
    return size;
  },
  updateSize: function() {
    var newSize = this.getCurrentSize();
    if (newSize && !isNaN(newSize.h) && !isNaN(newSize.w)) {
      this.events.clearMouseCache();
      var oldSize = this.getSize();
      if (oldSize == null) {
        this.size = oldSize = newSize;
      }
      if (!newSize.equals(oldSize)) {
        this.size = newSize;
        for (var i = 0, len = this.layers.length; i < len; i++) {
          this.layers[i].onMapResize();
        }
        var center = this.getCachedCenter();
        if (this.baseLayer != null && center != null) {
          var zoom = this.getZoom();
          this.zoom = null;
          this.setCenter(center, zoom);
        }
      }
    }
  },
  getCurrentSize: function() {
    var size = new OpenLayers.Size(this.div.clientWidth, this.div.clientHeight);
    if ((size.w == 0 && size.h == 0) || (isNaN(size.w) && isNaN(size.h))) {
      size.w = this.div.offsetWidth;
      size.h = this.div.offsetHeight;
    }
    if ((size.w == 0 && size.h == 0) || (isNaN(size.w) && isNaN(size.h))) {
      size.w = parseInt(this.div.style.width);
      size.h = parseInt(this.div.style.height);
    }
    return size;
  },
  calculateBounds: function(center, resolution) {
    var extent = null;
    if (center == null) {
      center = this.getCachedCenter();
    }
    if (resolution == null) {
      resolution = this.getResolution();
    }
    if (center != null && resolution != null) {
      var halfWDeg = (this.size.w * resolution) / 2;
      var halfHDeg = (this.size.h * resolution) / 2;
      extent = new OpenLayers.Bounds(
        center.lon - halfWDeg,
        center.lat - halfHDeg,
        center.lon + halfWDeg,
        center.lat + halfHDeg
      );
    }
    return extent;
  },
  getCenter: function() {
    var center = null;
    var cachedCenter = this.getCachedCenter();
    if (cachedCenter) {
      center = cachedCenter.clone();
    }
    return center;
  },
  getCachedCenter: function() {
    if (!this.center && this.size) {
      this.center = this.getLonLatFromViewPortPx({
        x: this.size.w / 2,
        y: this.size.h / 2
      });
    }
    return this.center;
  },
  getZoom: function() {
    return this.zoom;
  },
  pan: function(dx, dy, options) {
    options = OpenLayers.Util.applyDefaults(options, {
      animate: true,
      dragging: false
    });
    if (options.dragging) {
      if (dx != 0 || dy != 0) {
        this.moveByPx(dx, dy);
      }
    } else {
      var centerPx = this.getViewPortPxFromLonLat(this.getCachedCenter());
      var newCenterPx = centerPx.add(dx, dy);
      if (this.dragging || !newCenterPx.equals(centerPx)) {
        var newCenterLonLat = this.getLonLatFromViewPortPx(newCenterPx);
        if (options.animate) {
          this.panTo(newCenterLonLat);
        } else {
          this.moveTo(newCenterLonLat);
          if (this.dragging) {
            this.dragging = false;
            this.events.triggerEvent("moveend");
          }
        }
      }
    }
  },
  panTo: function(lonlat) {
    if (
      this.panMethod &&
      this.getExtent()
        .scale(this.panRatio)
        .containsLonLat(lonlat)
    ) {
      if (!this.panTween) {
        this.panTween = new OpenLayers.Tween(this.panMethod);
      }
      var center = this.getCachedCenter();
      if (lonlat.equals(center)) {
        return;
      }
      var from = this.getPixelFromLonLat(center);
      var to = this.getPixelFromLonLat(lonlat);
      var vector = { x: to.x - from.x, y: to.y - from.y };
      var last = { x: 0, y: 0 };
      this.panTween.start({ x: 0, y: 0 }, vector, this.panDuration, {
        callbacks: {
          eachStep: OpenLayers.Function.bind(function(px) {
            var x = px.x - last.x,
              y = px.y - last.y;
            this.moveByPx(x, y);
            last.x = Math.round(px.x);
            last.y = Math.round(px.y);
          }, this),
          done: OpenLayers.Function.bind(function(px) {
            this.moveTo(lonlat);
            this.dragging = false;
            this.events.triggerEvent("moveend");
          }, this)
        }
      });
    } else {
      this.setCenter(lonlat);
    }
  },
  setCenter: function(lonlat, zoom, dragging, forceZoomChange) {
    this.panTween && this.panTween.stop();
    this.moveTo(lonlat, zoom, {
      dragging: dragging,
      forceZoomChange: forceZoomChange
    });
  },
  moveByPx: function(dx, dy) {
    var hw = this.size.w / 2;
    var hh = this.size.h / 2;
    var x = hw + dx;
    var y = hh + dy;
    var wrapDateLine = this.baseLayer.wrapDateLine;
    var xRestriction = 0;
    var yRestriction = 0;
    if (this.restrictedExtent) {
      xRestriction = hw;
      yRestriction = hh;
      wrapDateLine = false;
    }
    dx =
      wrapDateLine ||
      (x <= this.maxPx.x - xRestriction && x >= this.minPx.x + xRestriction)
        ? Math.round(dx)
        : 0;
    dy =
      y <= this.maxPx.y - yRestriction && y >= this.minPx.y + yRestriction
        ? Math.round(dy)
        : 0;
    if (dx || dy) {
      if (!this.dragging) {
        this.dragging = true;
        this.events.triggerEvent("movestart");
      }
      this.center = null;
      if (dx) {
        this.layerContainerDiv.style.left =
          parseInt(this.layerContainerDiv.style.left) - dx + "px";
        this.minPx.x -= dx;
        this.maxPx.x -= dx;
      }
      if (dy) {
        this.layerContainerDiv.style.top =
          parseInt(this.layerContainerDiv.style.top) - dy + "px";
        this.minPx.y -= dy;
        this.maxPx.y -= dy;
      }
      var layer, i, len;
      for (i = 0, len = this.layers.length; i < len; ++i) {
        layer = this.layers[i];
        if (layer.visibility && (layer === this.baseLayer || layer.inRange)) {
          layer.moveByPx(dx, dy);
          layer.events.triggerEvent("move");
        }
      }
      this.events.triggerEvent("move");
    }
  },
  adjustZoom: function(zoom) {
    var resolution,
      resolutions = this.baseLayer.resolutions,
      maxResolution = this.getMaxExtent().getWidth() / this.size.w;
    if (this.getResolutionForZoom(zoom) > maxResolution) {
      for (var i = zoom | 0, ii = resolutions.length; i < ii; ++i) {
        if (resolutions[i] <= maxResolution) {
          zoom = i;
          break;
        }
      }
    }
    return zoom;
  },
  moveTo: function(lonlat, zoom, options) {
    if (lonlat != null && !(lonlat instanceof OpenLayers.LonLat)) {
      lonlat = new OpenLayers.LonLat(lonlat);
    }
    if (!options) {
      options = {};
    }
    if (zoom != null) {
      zoom = parseFloat(zoom);
      if (!this.fractionalZoom) {
        zoom = Math.round(zoom);
      }
    }
    if (this.baseLayer.wrapDateLine) {
      var requestedZoom = zoom;
      zoom = this.adjustZoom(zoom);
      if (zoom !== requestedZoom) {
        lonlat = this.getCenter();
      }
    }
    var dragging = options.dragging || this.dragging;
    var forceZoomChange = options.forceZoomChange;
    if (!this.getCachedCenter() && !this.isValidLonLat(lonlat)) {
      lonlat = this.maxExtent.getCenterLonLat();
      this.center = lonlat.clone();
    }
    if (this.restrictedExtent != null) {
      if (lonlat == null) {
        lonlat = this.center;
      }
      if (zoom == null) {
        zoom = this.getZoom();
      }
      var resolution = this.getResolutionForZoom(zoom);
      var extent = this.calculateBounds(lonlat, resolution);
      if (!this.restrictedExtent.containsBounds(extent)) {
        var maxCenter = this.restrictedExtent.getCenterLonLat();
        if (extent.getWidth() > this.restrictedExtent.getWidth()) {
          lonlat = new OpenLayers.LonLat(maxCenter.lon, lonlat.lat);
        } else if (extent.left < this.restrictedExtent.left) {
          lonlat = lonlat.add(this.restrictedExtent.left - extent.left, 0);
        } else if (extent.right > this.restrictedExtent.right) {
          lonlat = lonlat.add(this.restrictedExtent.right - extent.right, 0);
        }
        if (extent.getHeight() > this.restrictedExtent.getHeight()) {
          lonlat = new OpenLayers.LonLat(lonlat.lon, maxCenter.lat);
        } else if (extent.bottom < this.restrictedExtent.bottom) {
          lonlat = lonlat.add(0, this.restrictedExtent.bottom - extent.bottom);
        } else if (extent.top > this.restrictedExtent.top) {
          lonlat = lonlat.add(0, this.restrictedExtent.top - extent.top);
        }
      }
    }
    var zoomChanged =
      forceZoomChange ||
      (this.isValidZoomLevel(zoom) && zoom != this.getZoom());
    var centerChanged =
      this.isValidLonLat(lonlat) && !lonlat.equals(this.center);
    if (zoomChanged || centerChanged || dragging) {
      dragging || this.events.triggerEvent("movestart");
      if (centerChanged) {
        if (!zoomChanged && this.center) {
          this.centerLayerContainer(lonlat);
        }
        this.center = lonlat.clone();
      }
      var res = zoomChanged
        ? this.getResolutionForZoom(zoom)
        : this.getResolution();
      if (zoomChanged || this.layerContainerOrigin == null) {
        this.layerContainerOrigin = this.getCachedCenter();
        this.layerContainerDiv.style.left = "0px";
        this.layerContainerDiv.style.top = "0px";
        var maxExtent = this.getMaxExtent({ restricted: true });
        var maxExtentCenter = maxExtent.getCenterLonLat();
        var lonDelta = this.center.lon - maxExtentCenter.lon;
        var latDelta = maxExtentCenter.lat - this.center.lat;
        var extentWidth = Math.round(maxExtent.getWidth() / res);
        var extentHeight = Math.round(maxExtent.getHeight() / res);
        this.minPx = {
          x: (this.size.w - extentWidth) / 2 - lonDelta / res,
          y: (this.size.h - extentHeight) / 2 - latDelta / res
        };
        this.maxPx = {
          x: this.minPx.x + Math.round(maxExtent.getWidth() / res),
          y: this.minPx.y + Math.round(maxExtent.getHeight() / res)
        };
      }
      if (zoomChanged) {
        this.zoom = zoom;
        this.resolution = res;
      }
      var bounds = this.getExtent();
      if (this.baseLayer.visibility) {
        this.baseLayer.moveTo(bounds, zoomChanged, options.dragging);
        options.dragging ||
          this.baseLayer.events.triggerEvent("moveend", {
            zoomChanged: zoomChanged
          });
      }
      bounds = this.baseLayer.getExtent();
      for (var i = this.layers.length - 1; i >= 0; --i) {
        var layer = this.layers[i];
        if (layer !== this.baseLayer && !layer.isBaseLayer) {
          var inRange = layer.calculateInRange();
          if (layer.inRange != inRange) {
            layer.inRange = inRange;
            if (!inRange) {
              layer.display(false);
            }
            this.events.triggerEvent("changelayer", {
              layer: layer,
              property: "visibility"
            });
          }
          if (inRange && layer.visibility) {
            layer.moveTo(bounds, zoomChanged, options.dragging);
            options.dragging ||
              layer.events.triggerEvent("moveend", {
                zoomChanged: zoomChanged
              });
          }
        }
      }
      this.events.triggerEvent("move");
      dragging || this.events.triggerEvent("moveend");
      if (zoomChanged) {
        for (var i = 0, len = this.popups.length; i < len; i++) {
          this.popups[i].updatePosition();
        }
        this.events.triggerEvent("zoomend");
      }
    }
  },
  centerLayerContainer: function(lonlat) {
    var originPx = this.getViewPortPxFromLonLat(this.layerContainerOrigin);
    var newPx = this.getViewPortPxFromLonLat(lonlat);
    if (originPx != null && newPx != null) {
      var oldLeft = parseInt(this.layerContainerDiv.style.left);
      var oldTop = parseInt(this.layerContainerDiv.style.top);
      var newLeft = Math.round(originPx.x - newPx.x);
      var newTop = Math.round(originPx.y - newPx.y);
      this.layerContainerDiv.style.left = newLeft + "px";
      this.layerContainerDiv.style.top = newTop + "px";
      var dx = oldLeft - newLeft;
      var dy = oldTop - newTop;
      this.minPx.x -= dx;
      this.maxPx.x -= dx;
      this.minPx.y -= dy;
      this.maxPx.y -= dy;
    }
  },
  isValidZoomLevel: function(zoomLevel) {
    return (
      zoomLevel != null && zoomLevel >= 0 && zoomLevel < this.getNumZoomLevels()
    );
  },
  isValidLonLat: function(lonlat) {
    var valid = false;
    if (lonlat != null) {
      var maxExtent = this.getMaxExtent();
      var worldBounds = this.baseLayer.wrapDateLine && maxExtent;
      valid = maxExtent.containsLonLat(lonlat, { worldBounds: worldBounds });
    }
    return valid;
  },
  getProjection: function() {
    var projection = this.getProjectionObject();
    return projection ? projection.getCode() : null;
  },
  getProjectionObject: function() {
    var projection = null;
    if (this.baseLayer != null) {
      projection = this.baseLayer.projection;
    }
    return projection;
  },
  getMaxResolution: function() {
    var maxResolution = null;
    if (this.baseLayer != null) {
      maxResolution = this.baseLayer.maxResolution;
    }
    return maxResolution;
  },
  getMaxExtent: function(options) {
    var maxExtent = null;
    if (options && options.restricted && this.restrictedExtent) {
      maxExtent = this.restrictedExtent;
    } else if (this.baseLayer != null) {
      maxExtent = this.baseLayer.maxExtent;
    }
    return maxExtent;
  },
  getNumZoomLevels: function() {
    var numZoomLevels = null;
    if (this.baseLayer != null) {
      numZoomLevels = this.baseLayer.numZoomLevels;
    }
    return numZoomLevels;
  },
  getExtent: function() {
    var extent = null;
    if (this.baseLayer != null) {
      extent = this.baseLayer.getExtent();
    }
    return extent;
  },
  getResolution: function() {
    var resolution = null;
    if (this.baseLayer != null) {
      resolution = this.baseLayer.getResolution();
    } else if (this.allOverlays === true && this.layers.length > 0) {
      resolution = this.layers[0].getResolution();
    }
    return resolution;
  },
  getUnits: function() {
    var units = null;
    if (this.baseLayer != null) {
      units = this.baseLayer.units;
    }
    return units;
  },
  getScale: function() {
    var scale = null;
    if (this.baseLayer != null) {
      var res = this.getResolution();
      var units = this.baseLayer.units;
      scale = OpenLayers.Util.getScaleFromResolution(res, units);
    }
    return scale;
  },
  getZoomForExtent: function(bounds, closest) {
    var zoom = null;
    if (this.baseLayer != null) {
      zoom = this.baseLayer.getZoomForExtent(bounds, closest);
    }
    return zoom;
  },
  getResolutionForZoom: function(zoom) {
    var resolution = null;
    if (this.baseLayer) {
      resolution = this.baseLayer.getResolutionForZoom(zoom);
    }
    return resolution;
  },
  getZoomForResolution: function(resolution, closest) {
    var zoom = null;
    if (this.baseLayer != null) {
      zoom = this.baseLayer.getZoomForResolution(resolution, closest);
    }
    return zoom;
  },
  zoomTo: function(zoom) {
    if (this.isValidZoomLevel(zoom)) {
      this.setCenter(null, zoom);
    }
  },
  zoomIn: function() {
    this.zoomTo(this.getZoom() + 1);
  },
  zoomOut: function() {
    this.zoomTo(this.getZoom() - 1);
  },
  zoomToExtent: function(bounds, closest) {
    if (!(bounds instanceof OpenLayers.Bounds)) {
      bounds = new OpenLayers.Bounds(bounds);
    }
    var center = bounds.getCenterLonLat();
    if (this.baseLayer.wrapDateLine) {
      var maxExtent = this.getMaxExtent();
      bounds = bounds.clone();
      while (bounds.right < bounds.left) {
        bounds.right += maxExtent.getWidth();
      }
      center = bounds.getCenterLonLat().wrapDateLine(maxExtent);
    }
    this.setCenter(center, this.getZoomForExtent(bounds, closest));
  },
  zoomToMaxExtent: function(options) {
    var restricted = options ? options.restricted : true;
    var maxExtent = this.getMaxExtent({ restricted: restricted });
    this.zoomToExtent(maxExtent);
  },
  zoomToScale: function(scale, closest) {
    var res = OpenLayers.Util.getResolutionFromScale(
      scale,
      this.baseLayer.units
    );
    var halfWDeg = (this.size.w * res) / 2;
    var halfHDeg = (this.size.h * res) / 2;
    var center = this.getCachedCenter();
    var extent = new OpenLayers.Bounds(
      center.lon - halfWDeg,
      center.lat - halfHDeg,
      center.lon + halfWDeg,
      center.lat + halfHDeg
    );
    this.zoomToExtent(extent, closest);
  },
  getLonLatFromViewPortPx: function(viewPortPx) {
    var lonlat = null;
    if (this.baseLayer != null) {
      lonlat = this.baseLayer.getLonLatFromViewPortPx(viewPortPx);
    }
    return lonlat;
  },
  getViewPortPxFromLonLat: function(lonlat) {
    var px = null;
    if (this.baseLayer != null) {
      px = this.baseLayer.getViewPortPxFromLonLat(lonlat);
    }
    return px;
  },
  getLonLatFromPixel: function(px) {
    return this.getLonLatFromViewPortPx(px);
  },
  getPixelFromLonLat: function(lonlat) {
    var px = this.getViewPortPxFromLonLat(lonlat);
    px.x = Math.round(px.x);
    px.y = Math.round(px.y);
    return px;
  },
  getGeodesicPixelSize: function(px) {
    var lonlat = px
      ? this.getLonLatFromPixel(px)
      : this.getCachedCenter() || new OpenLayers.LonLat(0, 0);
    var res = this.getResolution();
    var left = lonlat.add(-res / 2, 0);
    var right = lonlat.add(res / 2, 0);
    var bottom = lonlat.add(0, -res / 2);
    var top = lonlat.add(0, res / 2);
    var dest = new OpenLayers.Projection("EPSG:4326");
    var source = this.getProjectionObject() || dest;
    if (!source.equals(dest)) {
      left.transform(source, dest);
      right.transform(source, dest);
      bottom.transform(source, dest);
      top.transform(source, dest);
    }
    return new OpenLayers.Size(
      OpenLayers.Util.distVincenty(left, right),
      OpenLayers.Util.distVincenty(bottom, top)
    );
  },
  getViewPortPxFromLayerPx: function(layerPx) {
    var viewPortPx = null;
    if (layerPx != null) {
      var dX = parseInt(this.layerContainerDiv.style.left);
      var dY = parseInt(this.layerContainerDiv.style.top);
      viewPortPx = layerPx.add(dX, dY);
    }
    return viewPortPx;
  },
  getLayerPxFromViewPortPx: function(viewPortPx) {
    var layerPx = null;
    if (viewPortPx != null) {
      var dX = -parseInt(this.layerContainerDiv.style.left);
      var dY = -parseInt(this.layerContainerDiv.style.top);
      layerPx = viewPortPx.add(dX, dY);
      if (isNaN(layerPx.x) || isNaN(layerPx.y)) {
        layerPx = null;
      }
    }
    return layerPx;
  },
  getLonLatFromLayerPx: function(px) {
    px = this.getViewPortPxFromLayerPx(px);
    return this.getLonLatFromViewPortPx(px);
  },
  getLayerPxFromLonLat: function(lonlat) {
    var px = this.getPixelFromLonLat(lonlat);
    return this.getLayerPxFromViewPortPx(px);
  },
  CLASS_NAME: "OpenLayers.Map"
});
OpenLayers.Map.TILE_WIDTH = 256;
OpenLayers.Map.TILE_HEIGHT = 256;
OpenLayers.Layer = OpenLayers.Class({
  id: null,
  name: null,
  div: null,
  opacity: 1,
  alwaysInRange: null,
  RESOLUTION_PROPERTIES: [
    "scales",
    "resolutions",
    "maxScale",
    "minScale",
    "maxResolution",
    "minResolution",
    "numZoomLevels",
    "maxZoomLevel"
  ],
  events: null,
  map: null,
  isBaseLayer: false,
  alpha: false,
  displayInLayerSwitcher: true,
  visibility: true,
  attribution: null,
  inRange: false,
  imageSize: null,
  options: null,
  eventListeners: null,
  gutter: 0,
  projection: null,
  units: null,
  scales: null,
  resolutions: null,
  maxExtent: null,
  minExtent: null,
  maxResolution: null,
  minResolution: null,
  numZoomLevels: null,
  minScale: null,
  maxScale: null,
  displayOutsideMaxExtent: false,
  wrapDateLine: false,
  metadata: null,
  initialize: function(name, options) {
    this.metadata = {};
    this.addOptions(options);
    this.name = name;
    if (this.id == null) {
      this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
      this.div = OpenLayers.Util.createDiv(this.id);
      this.div.style.width = "100%";
      this.div.style.height = "100%";
      this.div.dir = "ltr";
      this.events = new OpenLayers.Events(this, this.div);
      if (this.eventListeners instanceof Object) {
        this.events.on(this.eventListeners);
      }
    }
  },
  destroy: function(setNewBaseLayer) {
    if (setNewBaseLayer == null) {
      setNewBaseLayer = true;
    }
    if (this.map != null) {
      this.map.removeLayer(this, setNewBaseLayer);
    }
    this.projection = null;
    this.map = null;
    this.name = null;
    this.div = null;
    this.options = null;
    if (this.events) {
      if (this.eventListeners) {
        this.events.un(this.eventListeners);
      }
      this.events.destroy();
    }
    this.eventListeners = null;
    this.events = null;
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer(this.name, this.getOptions());
    }
    OpenLayers.Util.applyDefaults(obj, this);
    obj.map = null;
    return obj;
  },
  getOptions: function() {
    var options = {};
    for (var o in this.options) {
      options[o] = this[o];
    }
    return options;
  },
  setName: function(newName) {
    if (newName != this.name) {
      this.name = newName;
      if (this.map != null) {
        this.map.events.triggerEvent("changelayer", {
          layer: this,
          property: "name"
        });
      }
    }
  },
  addOptions: function(newOptions, reinitialize) {
    if (this.options == null) {
      this.options = {};
    }
    if (newOptions) {
      if (typeof newOptions.projection == "string") {
        newOptions.projection = new OpenLayers.Projection(
          newOptions.projection
        );
      }
      if (newOptions.projection) {
        OpenLayers.Util.applyDefaults(
          newOptions,
          OpenLayers.Projection.defaults[newOptions.projection.getCode()]
        );
      }
      if (
        newOptions.maxExtent &&
        !(newOptions.maxExtent instanceof OpenLayers.Bounds)
      ) {
        newOptions.maxExtent = new OpenLayers.Bounds(newOptions.maxExtent);
      }
      if (
        newOptions.minExtent &&
        !(newOptions.minExtent instanceof OpenLayers.Bounds)
      ) {
        newOptions.minExtent = new OpenLayers.Bounds(newOptions.minExtent);
      }
    }
    OpenLayers.Util.extend(this.options, newOptions);
    OpenLayers.Util.extend(this, newOptions);
    if (this.projection && this.projection.getUnits()) {
      this.units = this.projection.getUnits();
    }
    if (this.map) {
      var resolution = this.map.getResolution();
      var properties = this.RESOLUTION_PROPERTIES.concat([
        "projection",
        "units",
        "minExtent",
        "maxExtent"
      ]);
      for (var o in newOptions) {
        if (
          newOptions.hasOwnProperty(o) &&
          OpenLayers.Util.indexOf(properties, o) >= 0
        ) {
          this.initResolutions();
          if (reinitialize && this.map.baseLayer === this) {
            this.map.setCenter(
              this.map.getCenter(),
              this.map.getZoomForResolution(resolution),
              false,
              true
            );
            this.map.events.triggerEvent("changebaselayer", { layer: this });
          }
          break;
        }
      }
    }
  },
  onMapResize: function() {},
  redraw: function() {
    var redrawn = false;
    if (this.map) {
      this.inRange = this.calculateInRange();
      var extent = this.getExtent();
      if (extent && this.inRange && this.visibility) {
        var zoomChanged = true;
        this.moveTo(extent, zoomChanged, false);
        this.events.triggerEvent("moveend", { zoomChanged: zoomChanged });
        redrawn = true;
      }
    }
    return redrawn;
  },
  moveTo: function(bounds, zoomChanged, dragging) {
    var display = this.visibility;
    if (!this.isBaseLayer) {
      display = display && this.inRange;
    }
    this.display(display);
  },
  moveByPx: function(dx, dy) {},
  setMap: function(map) {
    if (this.map == null) {
      this.map = map;
      this.maxExtent = this.maxExtent || this.map.maxExtent;
      this.minExtent = this.minExtent || this.map.minExtent;
      this.projection = this.projection || this.map.projection;
      if (typeof this.projection == "string") {
        this.projection = new OpenLayers.Projection(this.projection);
      }
      this.units = this.projection.getUnits() || this.units || this.map.units;
      this.initResolutions();
      if (!this.isBaseLayer) {
        this.inRange = this.calculateInRange();
        var show = this.visibility && this.inRange;
        this.div.style.display = show ? "" : "none";
      }
      this.setTileSize();
    }
  },
  afterAdd: function() {},
  removeMap: function(map) {},
  getImageSize: function(bounds) {
    return this.imageSize || this.tileSize;
  },
  setTileSize: function(size) {
    var tileSize = size
      ? size
      : this.tileSize
      ? this.tileSize
      : this.map.getTileSize();
    this.tileSize = tileSize;
    if (this.gutter) {
      this.imageSize = new OpenLayers.Size(
        tileSize.w + 2 * this.gutter,
        tileSize.h + 2 * this.gutter
      );
    }
  },
  getVisibility: function() {
    return this.visibility;
  },
  setVisibility: function(visibility) {
    if (visibility != this.visibility) {
      this.visibility = visibility;
      this.display(visibility);
      this.redraw();
      if (this.map != null) {
        this.map.events.triggerEvent("changelayer", {
          layer: this,
          property: "visibility"
        });
      }
      this.events.triggerEvent("visibilitychanged");
    }
  },
  display: function(display) {
    if (display != (this.div.style.display != "none")) {
      this.div.style.display =
        display && this.calculateInRange() ? "block" : "none";
    }
  },
  calculateInRange: function() {
    var inRange = false;
    if (this.alwaysInRange) {
      inRange = true;
    } else {
      if (this.map) {
        var resolution = this.map.getResolution();
        inRange =
          resolution >= this.minResolution && resolution <= this.maxResolution;
      }
    }
    return inRange;
  },
  setIsBaseLayer: function(isBaseLayer) {
    if (isBaseLayer != this.isBaseLayer) {
      this.isBaseLayer = isBaseLayer;
      if (this.map != null) {
        this.map.events.triggerEvent("changebaselayer", { layer: this });
      }
    }
  },
  initResolutions: function() {
    var i, len, p;
    var props = {},
      alwaysInRange = true;
    for (i = 0, len = this.RESOLUTION_PROPERTIES.length; i < len; i++) {
      p = this.RESOLUTION_PROPERTIES[i];
      props[p] = this.options[p];
      if (alwaysInRange && this.options[p]) {
        alwaysInRange = false;
      }
    }
    if (this.alwaysInRange == null) {
      this.alwaysInRange = alwaysInRange;
    }
    if (props.resolutions == null) {
      props.resolutions = this.resolutionsFromScales(props.scales);
    }
    if (props.resolutions == null) {
      props.resolutions = this.calculateResolutions(props);
    }
    if (props.resolutions == null) {
      for (i = 0, len = this.RESOLUTION_PROPERTIES.length; i < len; i++) {
        p = this.RESOLUTION_PROPERTIES[i];
        props[p] = this.options[p] != null ? this.options[p] : this.map[p];
      }
      if (props.resolutions == null) {
        props.resolutions = this.resolutionsFromScales(props.scales);
      }
      if (props.resolutions == null) {
        props.resolutions = this.calculateResolutions(props);
      }
    }
    var maxResolution;
    if (this.options.maxResolution && this.options.maxResolution !== "auto") {
      maxResolution = this.options.maxResolution;
    }
    if (this.options.minScale) {
      maxResolution = OpenLayers.Util.getResolutionFromScale(
        this.options.minScale,
        this.units
      );
    }
    var minResolution;
    if (this.options.minResolution && this.options.minResolution !== "auto") {
      minResolution = this.options.minResolution;
    }
    if (this.options.maxScale) {
      minResolution = OpenLayers.Util.getResolutionFromScale(
        this.options.maxScale,
        this.units
      );
    }
    if (props.resolutions) {
      props.resolutions.sort(function(a, b) {
        return b - a;
      });
      if (!maxResolution) {
        maxResolution = props.resolutions[0];
      }
      if (!minResolution) {
        var lastIdx = props.resolutions.length - 1;
        minResolution = props.resolutions[lastIdx];
      }
    }
    this.resolutions = props.resolutions;
    if (this.resolutions) {
      len = this.resolutions.length;
      this.scales = new Array(len);
      for (i = 0; i < len; i++) {
        this.scales[i] = OpenLayers.Util.getScaleFromResolution(
          this.resolutions[i],
          this.units
        );
      }
      this.numZoomLevels = len;
    }
    this.minResolution = minResolution;
    if (minResolution) {
      this.maxScale = OpenLayers.Util.getScaleFromResolution(
        minResolution,
        this.units
      );
    }
    this.maxResolution = maxResolution;
    if (maxResolution) {
      this.minScale = OpenLayers.Util.getScaleFromResolution(
        maxResolution,
        this.units
      );
    }
  },
  resolutionsFromScales: function(scales) {
    if (scales == null) {
      return;
    }
    var resolutions, i, len;
    len = scales.length;
    resolutions = new Array(len);
    for (i = 0; i < len; i++) {
      resolutions[i] = OpenLayers.Util.getResolutionFromScale(
        scales[i],
        this.units
      );
    }
    return resolutions;
  },
  calculateResolutions: function(props) {
    var viewSize, wRes, hRes;
    var maxResolution = props.maxResolution;
    if (props.minScale != null) {
      maxResolution = OpenLayers.Util.getResolutionFromScale(
        props.minScale,
        this.units
      );
    } else if (maxResolution == "auto" && this.maxExtent != null) {
      viewSize = this.map.getSize();
      wRes = this.maxExtent.getWidth() / viewSize.w;
      hRes = this.maxExtent.getHeight() / viewSize.h;
      maxResolution = Math.max(wRes, hRes);
    }
    var minResolution = props.minResolution;
    if (props.maxScale != null) {
      minResolution = OpenLayers.Util.getResolutionFromScale(
        props.maxScale,
        this.units
      );
    } else if (props.minResolution == "auto" && this.minExtent != null) {
      viewSize = this.map.getSize();
      wRes = this.minExtent.getWidth() / viewSize.w;
      hRes = this.minExtent.getHeight() / viewSize.h;
      minResolution = Math.max(wRes, hRes);
    }
    if (
      typeof maxResolution !== "number" &&
      typeof minResolution !== "number" &&
      this.maxExtent != null
    ) {
      var tileSize = this.map.getTileSize();
      maxResolution = Math.max(
        this.maxExtent.getWidth() / tileSize.w,
        this.maxExtent.getHeight() / tileSize.h
      );
    }
    var maxZoomLevel = props.maxZoomLevel;
    var numZoomLevels = props.numZoomLevels;
    if (
      typeof minResolution === "number" &&
      typeof maxResolution === "number" &&
      numZoomLevels === undefined
    ) {
      var ratio = maxResolution / minResolution;
      numZoomLevels = Math.floor(Math.log(ratio) / Math.log(2)) + 1;
    } else if (numZoomLevels === undefined && maxZoomLevel != null) {
      numZoomLevels = maxZoomLevel + 1;
    }
    if (
      typeof numZoomLevels !== "number" ||
      numZoomLevels <= 0 ||
      (typeof maxResolution !== "number" && typeof minResolution !== "number")
    ) {
      return;
    }
    var resolutions = new Array(numZoomLevels);
    var base = 2;
    if (typeof minResolution == "number" && typeof maxResolution == "number") {
      base = Math.pow(maxResolution / minResolution, 1 / (numZoomLevels - 1));
    }
    var i;
    if (typeof maxResolution === "number") {
      for (i = 0; i < numZoomLevels; i++) {
        resolutions[i] = maxResolution / Math.pow(base, i);
      }
    } else {
      for (i = 0; i < numZoomLevels; i++) {
        resolutions[numZoomLevels - 1 - i] = minResolution * Math.pow(base, i);
      }
    }
    return resolutions;
  },
  getResolution: function() {
    var zoom = this.map.getZoom();
    return this.getResolutionForZoom(zoom);
  },
  getExtent: function() {
    return this.map.calculateBounds();
  },
  getZoomForExtent: function(extent, closest) {
    var viewSize = this.map.getSize();
    var idealResolution = Math.max(
      extent.getWidth() / viewSize.w,
      extent.getHeight() / viewSize.h
    );
    return this.getZoomForResolution(idealResolution, closest);
  },
  getDataExtent: function() {},
  getResolutionForZoom: function(zoom) {
    zoom = Math.max(0, Math.min(zoom, this.resolutions.length - 1));
    var resolution;
    if (this.map.fractionalZoom) {
      var low = Math.floor(zoom);
      var high = Math.ceil(zoom);
      resolution =
        this.resolutions[low] -
        (zoom - low) * (this.resolutions[low] - this.resolutions[high]);
    } else {
      resolution = this.resolutions[Math.round(zoom)];
    }
    return resolution;
  },
  getZoomForResolution: function(resolution, closest) {
    var zoom, i, len;
    if (this.map.fractionalZoom) {
      var lowZoom = 0;
      var highZoom = this.resolutions.length - 1;
      var highRes = this.resolutions[lowZoom];
      var lowRes = this.resolutions[highZoom];
      var res;
      for (i = 0, len = this.resolutions.length; i < len; ++i) {
        res = this.resolutions[i];
        if (res >= resolution) {
          highRes = res;
          lowZoom = i;
        }
        if (res <= resolution) {
          lowRes = res;
          highZoom = i;
          break;
        }
      }
      var dRes = highRes - lowRes;
      if (dRes > 0) {
        zoom = lowZoom + (highRes - resolution) / dRes;
      } else {
        zoom = lowZoom;
      }
    } else {
      var diff;
      var minDiff = Number.POSITIVE_INFINITY;
      for (i = 0, len = this.resolutions.length; i < len; i++) {
        if (closest) {
          diff = Math.abs(this.resolutions[i] - resolution);
          if (diff > minDiff) {
            break;
          }
          minDiff = diff;
        } else {
          if (this.resolutions[i] < resolution) {
            break;
          }
        }
      }
      zoom = Math.max(0, i - 1);
    }
    return zoom;
  },
  getLonLatFromViewPortPx: function(viewPortPx) {
    var lonlat = null;
    var map = this.map;
    if (viewPortPx != null && map.minPx) {
      var res = map.getResolution();
      var maxExtent = map.getMaxExtent({ restricted: true });
      var lon = (viewPortPx.x - map.minPx.x) * res + maxExtent.left;
      var lat = (map.minPx.y - viewPortPx.y) * res + maxExtent.top;
      lonlat = new OpenLayers.LonLat(lon, lat);
      if (this.wrapDateLine) {
        lonlat = lonlat.wrapDateLine(this.maxExtent);
      }
    }
    return lonlat;
  },
  getViewPortPxFromLonLat: function(lonlat, resolution) {
    var px = null;
    if (lonlat != null) {
      resolution = resolution || this.map.getResolution();
      var extent = this.map.calculateBounds(null, resolution);
      px = new OpenLayers.Pixel(
        (1 / resolution) * (lonlat.lon - extent.left),
        (1 / resolution) * (extent.top - lonlat.lat)
      );
    }
    return px;
  },
  setOpacity: function(opacity) {
    if (opacity != this.opacity) {
      this.opacity = opacity;
      var childNodes = this.div.childNodes;
      for (var i = 0, len = childNodes.length; i < len; ++i) {
        var element = childNodes[i].firstChild || childNodes[i];
        var lastChild = childNodes[i].lastChild;
        if (lastChild && lastChild.nodeName.toLowerCase() === "iframe") {
          element = lastChild.parentNode;
        }
        OpenLayers.Util.modifyDOMElement(
          element,
          null,
          null,
          null,
          null,
          null,
          null,
          opacity
        );
      }
      if (this.map != null) {
        this.map.events.triggerEvent("changelayer", {
          layer: this,
          property: "opacity"
        });
      }
    }
  },
  getZIndex: function() {
    return this.div.style.zIndex;
  },
  setZIndex: function(zIndex) {
    this.div.style.zIndex = zIndex;
  },
  adjustBounds: function(bounds) {
    if (this.gutter) {
      var mapGutter = this.gutter * this.map.getResolution();
      bounds = new OpenLayers.Bounds(
        bounds.left - mapGutter,
        bounds.bottom - mapGutter,
        bounds.right + mapGutter,
        bounds.top + mapGutter
      );
    }
    if (this.wrapDateLine) {
      var wrappingOptions = {
        rightTolerance: this.getResolution(),
        leftTolerance: this.getResolution()
      };
      bounds = bounds.wrapDateLine(this.maxExtent, wrappingOptions);
    }
    return bounds;
  },
  CLASS_NAME: "OpenLayers.Layer"
});
OpenLayers.Layer.SphericalMercator = {
  getExtent: function() {
    var extent = null;
    if (this.sphericalMercator) {
      extent = this.map.calculateBounds();
    } else {
      extent = OpenLayers.Layer.FixedZoomLevels.prototype.getExtent.apply(this);
    }
    return extent;
  },
  getLonLatFromViewPortPx: function(viewPortPx) {
    return OpenLayers.Layer.prototype.getLonLatFromViewPortPx.apply(
      this,
      arguments
    );
  },
  getViewPortPxFromLonLat: function(lonlat) {
    return OpenLayers.Layer.prototype.getViewPortPxFromLonLat.apply(
      this,
      arguments
    );
  },
  initMercatorParameters: function() {
    this.RESOLUTIONS = [];
    var maxResolution = 156543.03390625;
    for (var zoom = 0; zoom <= this.MAX_ZOOM_LEVEL; ++zoom) {
      this.RESOLUTIONS[zoom] = maxResolution / Math.pow(2, zoom);
    }
    this.units = "m";
    this.projection = this.projection || "EPSG:900913";
  },
  forwardMercator: (function() {
    var gg = new OpenLayers.Projection("EPSG:4326");
    var sm = new OpenLayers.Projection("EPSG:900913");
    return function(lon, lat) {
      var point = OpenLayers.Projection.transform({ x: lon, y: lat }, gg, sm);
      return new OpenLayers.LonLat(point.x, point.y);
    };
  })(),
  inverseMercator: (function() {
    var gg = new OpenLayers.Projection("EPSG:4326");
    var sm = new OpenLayers.Projection("EPSG:900913");
    return function(x, y) {
      var point = OpenLayers.Projection.transform({ x: x, y: y }, sm, gg);
      return new OpenLayers.LonLat(point.x, point.y);
    };
  })()
};
OpenLayers.Layer.EventPane = OpenLayers.Class(OpenLayers.Layer, {
  smoothDragPan: true,
  isBaseLayer: true,
  isFixed: true,
  pane: null,
  mapObject: null,
  initialize: function(name, options) {
    OpenLayers.Layer.prototype.initialize.apply(this, arguments);
    if (this.pane == null) {
      this.pane = OpenLayers.Util.createDiv(this.div.id + "_EventPane");
    }
  },
  destroy: function() {
    this.mapObject = null;
    this.pane = null;
    OpenLayers.Layer.prototype.destroy.apply(this, arguments);
  },
  setMap: function(map) {
    OpenLayers.Layer.prototype.setMap.apply(this, arguments);
    this.pane.style.zIndex = parseInt(this.div.style.zIndex) + 1;
    this.pane.style.display = this.div.style.display;
    this.pane.style.width = "100%";
    this.pane.style.height = "100%";
    if (OpenLayers.BROWSER_NAME == "msie") {
      this.pane.style.background =
        "url(" + OpenLayers.Util.getImageLocation("blank.gif") + ")";
    }
    if (this.isFixed) {
      this.map.viewPortDiv.appendChild(this.pane);
    } else {
      this.map.layerContainerDiv.appendChild(this.pane);
    }
    this.loadMapObject();
    if (this.mapObject == null) {
      this.loadWarningMessage();
    }
  },
  removeMap: function(map) {
    if (this.pane && this.pane.parentNode) {
      this.pane.parentNode.removeChild(this.pane);
    }
    OpenLayers.Layer.prototype.removeMap.apply(this, arguments);
  },
  loadWarningMessage: function() {
    this.div.style.backgroundColor = "darkblue";
    var viewSize = this.map.getSize();
    var msgW = Math.min(viewSize.w, 300);
    var msgH = Math.min(viewSize.h, 200);
    var size = new OpenLayers.Size(msgW, msgH);
    var centerPx = new OpenLayers.Pixel(viewSize.w / 2, viewSize.h / 2);
    var topLeft = centerPx.add(-size.w / 2, -size.h / 2);
    var div = OpenLayers.Util.createDiv(
      this.name + "_warning",
      topLeft,
      size,
      null,
      null,
      null,
      "auto"
    );
    div.style.padding = "7px";
    div.style.backgroundColor = "yellow";
    div.innerHTML = this.getWarningHTML();
    this.div.appendChild(div);
  },
  getWarningHTML: function() {
    return "";
  },
  display: function(display) {
    OpenLayers.Layer.prototype.display.apply(this, arguments);
    this.pane.style.display = this.div.style.display;
  },
  setZIndex: function(zIndex) {
    OpenLayers.Layer.prototype.setZIndex.apply(this, arguments);
    this.pane.style.zIndex = parseInt(this.div.style.zIndex) + 1;
  },
  moveByPx: function(dx, dy) {
    OpenLayers.Layer.prototype.moveByPx.apply(this, arguments);
    if (this.dragPanMapObject) {
      this.dragPanMapObject(dx, -dy);
    } else {
      this.moveTo(this.map.getCachedCenter());
    }
  },
  moveTo: function(bounds, zoomChanged, dragging) {
    OpenLayers.Layer.prototype.moveTo.apply(this, arguments);
    if (this.mapObject != null) {
      var newCenter = this.map.getCenter();
      var newZoom = this.map.getZoom();
      if (newCenter != null) {
        var moOldCenter = this.getMapObjectCenter();
        var oldCenter = this.getOLLonLatFromMapObjectLonLat(moOldCenter);
        var moOldZoom = this.getMapObjectZoom();
        var oldZoom = this.getOLZoomFromMapObjectZoom(moOldZoom);
        if (!newCenter.equals(oldCenter) || newZoom != oldZoom) {
          if (
            !zoomChanged &&
            oldCenter &&
            this.dragPanMapObject &&
            this.smoothDragPan
          ) {
            var oldPx = this.map.getViewPortPxFromLonLat(oldCenter);
            var newPx = this.map.getViewPortPxFromLonLat(newCenter);
            this.dragPanMapObject(newPx.x - oldPx.x, oldPx.y - newPx.y);
          } else {
            var center = this.getMapObjectLonLatFromOLLonLat(newCenter);
            var zoom = this.getMapObjectZoomFromOLZoom(newZoom);
            this.setMapObjectCenter(center, zoom, dragging);
          }
        }
      }
    }
  },
  getLonLatFromViewPortPx: function(viewPortPx) {
    var lonlat = null;
    if (this.mapObject != null && this.getMapObjectCenter() != null) {
      var moPixel = this.getMapObjectPixelFromOLPixel(viewPortPx);
      var moLonLat = this.getMapObjectLonLatFromMapObjectPixel(moPixel);
      lonlat = this.getOLLonLatFromMapObjectLonLat(moLonLat);
    }
    return lonlat;
  },
  getViewPortPxFromLonLat: function(lonlat) {
    var viewPortPx = null;
    if (this.mapObject != null && this.getMapObjectCenter() != null) {
      var moLonLat = this.getMapObjectLonLatFromOLLonLat(lonlat);
      var moPixel = this.getMapObjectPixelFromMapObjectLonLat(moLonLat);
      viewPortPx = this.getOLPixelFromMapObjectPixel(moPixel);
    }
    return viewPortPx;
  },
  getOLLonLatFromMapObjectLonLat: function(moLonLat) {
    var olLonLat = null;
    if (moLonLat != null) {
      var lon = this.getLongitudeFromMapObjectLonLat(moLonLat);
      var lat = this.getLatitudeFromMapObjectLonLat(moLonLat);
      olLonLat = new OpenLayers.LonLat(lon, lat);
    }
    return olLonLat;
  },
  getMapObjectLonLatFromOLLonLat: function(olLonLat) {
    var moLatLng = null;
    if (olLonLat != null) {
      moLatLng = this.getMapObjectLonLatFromLonLat(olLonLat.lon, olLonLat.lat);
    }
    return moLatLng;
  },
  getOLPixelFromMapObjectPixel: function(moPixel) {
    var olPixel = null;
    if (moPixel != null) {
      var x = this.getXFromMapObjectPixel(moPixel);
      var y = this.getYFromMapObjectPixel(moPixel);
      olPixel = new OpenLayers.Pixel(x, y);
    }
    return olPixel;
  },
  getMapObjectPixelFromOLPixel: function(olPixel) {
    var moPixel = null;
    if (olPixel != null) {
      moPixel = this.getMapObjectPixelFromXY(olPixel.x, olPixel.y);
    }
    return moPixel;
  },
  CLASS_NAME: "OpenLayers.Layer.EventPane"
});
OpenLayers.Layer.FixedZoomLevels = OpenLayers.Class({
  initialize: function() {},
  initResolutions: function() {
    var props = ["minZoomLevel", "maxZoomLevel", "numZoomLevels"];
    for (var i = 0, len = props.length; i < len; i++) {
      var property = props[i];
      this[property] =
        this.options[property] != null
          ? this.options[property]
          : this.map[property];
    }
    if (this.minZoomLevel == null || this.minZoomLevel < this.MIN_ZOOM_LEVEL) {
      this.minZoomLevel = this.MIN_ZOOM_LEVEL;
    }
    var desiredZoomLevels;
    var limitZoomLevels = this.MAX_ZOOM_LEVEL - this.minZoomLevel + 1;
    if (
      (this.options.numZoomLevels == null &&
        this.options.maxZoomLevel != null) ||
      (this.numZoomLevels == null && this.maxZoomLevel != null)
    ) {
      desiredZoomLevels = this.maxZoomLevel - this.minZoomLevel + 1;
    } else {
      desiredZoomLevels = this.numZoomLevels;
    }
    if (desiredZoomLevels != null) {
      this.numZoomLevels = Math.min(desiredZoomLevels, limitZoomLevels);
    } else {
      this.numZoomLevels = limitZoomLevels;
    }
    this.maxZoomLevel = this.minZoomLevel + this.numZoomLevels - 1;
    if (this.RESOLUTIONS != null) {
      var resolutionsIndex = 0;
      this.resolutions = [];
      for (var i = this.minZoomLevel; i <= this.maxZoomLevel; i++) {
        this.resolutions[resolutionsIndex++] = this.RESOLUTIONS[i];
      }
      this.maxResolution = this.resolutions[0];
      this.minResolution = this.resolutions[this.resolutions.length - 1];
    }
  },
  getResolution: function() {
    if (this.resolutions != null) {
      return OpenLayers.Layer.prototype.getResolution.apply(this, arguments);
    } else {
      var resolution = null;
      var viewSize = this.map.getSize();
      var extent = this.getExtent();
      if (viewSize != null && extent != null) {
        resolution = Math.max(
          extent.getWidth() / viewSize.w,
          extent.getHeight() / viewSize.h
        );
      }
      return resolution;
    }
  },
  getExtent: function() {
    var size = this.map.getSize();
    var tl = this.getLonLatFromViewPortPx({ x: 0, y: 0 });
    var br = this.getLonLatFromViewPortPx({ x: size.w, y: size.h });
    if (tl != null && br != null) {
      return new OpenLayers.Bounds(tl.lon, br.lat, br.lon, tl.lat);
    } else {
      return null;
    }
  },
  getZoomForResolution: function(resolution) {
    if (this.resolutions != null) {
      return OpenLayers.Layer.prototype.getZoomForResolution.apply(
        this,
        arguments
      );
    } else {
      var extent = OpenLayers.Layer.prototype.getExtent.apply(this, []);
      return this.getZoomForExtent(extent);
    }
  },
  getOLZoomFromMapObjectZoom: function(moZoom) {
    var zoom = null;
    if (moZoom != null) {
      zoom = moZoom - this.minZoomLevel;
      if (this.map.baseLayer !== this) {
        zoom = this.map.baseLayer.getZoomForResolution(
          this.getResolutionForZoom(zoom)
        );
      }
    }
    return zoom;
  },
  getMapObjectZoomFromOLZoom: function(olZoom) {
    var zoom = null;
    if (olZoom != null) {
      zoom = olZoom + this.minZoomLevel;
      if (this.map.baseLayer !== this) {
        zoom = this.getZoomForResolution(
          this.map.baseLayer.getResolutionForZoom(zoom)
        );
      }
    }
    return zoom;
  },
  CLASS_NAME: "OpenLayers.Layer.FixedZoomLevels"
});
OpenLayers.Layer.Google = OpenLayers.Class(
  OpenLayers.Layer.EventPane,
  OpenLayers.Layer.FixedZoomLevels,
  {
    MIN_ZOOM_LEVEL: 0,
    MAX_ZOOM_LEVEL: 21,
    RESOLUTIONS: [
      1.40625,
      0.703125,
      0.3515625,
      0.17578125,
      0.087890625,
      0.0439453125,
      0.02197265625,
      0.010986328125,
      0.0054931640625,
      0.00274658203125,
      0.001373291015625,
      0.0006866455078125,
      0.00034332275390625,
      0.000171661376953125,
      0.0000858306884765625,
      0.00004291534423828125,
      0.00002145767211914062,
      0.00001072883605957031,
      0.00000536441802978515,
      0.00000268220901489257,
      0.0000013411045074462891,
      0.00000067055225372314453
    ],
    type: null,
    wrapDateLine: true,
    sphericalMercator: false,
    version: null,
    initialize: function(name, options) {
      options = options || {};
      if (!options.version) {
        options.version = typeof GMap2 === "function" ? "2" : "3";
      }
      var mixin =
        OpenLayers.Layer.Google["v" + options.version.replace(/\./g, "_")];
      if (mixin) {
        OpenLayers.Util.applyDefaults(options, mixin);
      } else {
        throw "Unsupported Google Maps API version: " + options.version;
      }
      OpenLayers.Util.applyDefaults(options, mixin.DEFAULTS);
      if (options.maxExtent) {
        options.maxExtent = options.maxExtent.clone();
      }
      OpenLayers.Layer.EventPane.prototype.initialize.apply(this, [
        name,
        options
      ]);
      OpenLayers.Layer.FixedZoomLevels.prototype.initialize.apply(this, [
        name,
        options
      ]);
      if (this.sphericalMercator) {
        OpenLayers.Util.extend(this, OpenLayers.Layer.SphericalMercator);
        this.initMercatorParameters();
      }
    },
    clone: function() {
      return new OpenLayers.Layer.Google(this.name, this.getOptions());
    },
    setVisibility: function(visible) {
      var opacity = this.opacity == null ? 1 : this.opacity;
      OpenLayers.Layer.EventPane.prototype.setVisibility.apply(this, arguments);
      this.setOpacity(opacity);
    },
    display: function(visible) {
      if (!this._dragging) {
        this.setGMapVisibility(visible);
      }
      OpenLayers.Layer.EventPane.prototype.display.apply(this, arguments);
    },
    moveTo: function(bounds, zoomChanged, dragging) {
      this._dragging = dragging;
      OpenLayers.Layer.EventPane.prototype.moveTo.apply(this, arguments);
      delete this._dragging;
    },
    setOpacity: function(opacity) {
      if (opacity !== this.opacity) {
        if (this.map != null) {
          this.map.events.triggerEvent("changelayer", {
            layer: this,
            property: "opacity"
          });
        }
        this.opacity = opacity;
      }
      if (this.getVisibility()) {
        var container = this.getMapContainer();
        OpenLayers.Util.modifyDOMElement(
          container,
          null,
          null,
          null,
          null,
          null,
          null,
          opacity
        );
      }
    },
    destroy: function() {
      if (this.map) {
        this.setGMapVisibility(false);
        var cache = OpenLayers.Layer.Google.cache[this.map.id];
        if (cache && cache.count <= 1) {
          this.removeGMapElements();
        }
      }
      OpenLayers.Layer.EventPane.prototype.destroy.apply(this, arguments);
    },
    removeGMapElements: function() {
      var cache = OpenLayers.Layer.Google.cache[this.map.id];
      if (cache) {
        var container = this.mapObject && this.getMapContainer();
        if (container && container.parentNode) {
          container.parentNode.removeChild(container);
        }
        var termsOfUse = cache.termsOfUse;
        if (termsOfUse && termsOfUse.parentNode) {
          termsOfUse.parentNode.removeChild(termsOfUse);
        }
        var poweredBy = cache.poweredBy;
        if (poweredBy && poweredBy.parentNode) {
          poweredBy.parentNode.removeChild(poweredBy);
        }
      }
    },
    removeMap: function(map) {
      if (this.visibility && this.mapObject) {
        this.setGMapVisibility(false);
      }
      var cache = OpenLayers.Layer.Google.cache[map.id];
      if (cache) {
        if (cache.count <= 1) {
          this.removeGMapElements();
          delete OpenLayers.Layer.Google.cache[map.id];
        } else {
          --cache.count;
        }
      }
      delete this.termsOfUse;
      delete this.poweredBy;
      delete this.mapObject;
      delete this.dragObject;
      OpenLayers.Layer.EventPane.prototype.removeMap.apply(this, arguments);
    },
    getOLBoundsFromMapObjectBounds: function(moBounds) {
      var olBounds = null;
      if (moBounds != null) {
        var sw = moBounds.getSouthWest();
        var ne = moBounds.getNorthEast();
        if (this.sphericalMercator) {
          sw = this.forwardMercator(sw.lng(), sw.lat());
          ne = this.forwardMercator(ne.lng(), ne.lat());
        } else {
          sw = new OpenLayers.LonLat(sw.lng(), sw.lat());
          ne = new OpenLayers.LonLat(ne.lng(), ne.lat());
        }
        olBounds = new OpenLayers.Bounds(sw.lon, sw.lat, ne.lon, ne.lat);
      }
      return olBounds;
    },
    getWarningHTML: function() {
      return OpenLayers.i18n("googleWarning");
    },
    getMapObjectCenter: function() {
      return this.mapObject.getCenter();
    },
    getMapObjectZoom: function() {
      return this.mapObject.getZoom();
    },
    getLongitudeFromMapObjectLonLat: function(moLonLat) {
      return this.sphericalMercator
        ? this.forwardMercator(moLonLat.lng(), moLonLat.lat()).lon
        : moLonLat.lng();
    },
    getLatitudeFromMapObjectLonLat: function(moLonLat) {
      var lat = this.sphericalMercator
        ? this.forwardMercator(moLonLat.lng(), moLonLat.lat()).lat
        : moLonLat.lat();
      return lat;
    },
    getXFromMapObjectPixel: function(moPixel) {
      return moPixel.x;
    },
    getYFromMapObjectPixel: function(moPixel) {
      return moPixel.y;
    },
    CLASS_NAME: "OpenLayers.Layer.Google"
  }
);
OpenLayers.Layer.Google.cache = {};
OpenLayers.Layer.Google.v2 = {
  termsOfUse: null,
  poweredBy: null,
  dragObject: null,
  loadMapObject: function() {
    if (!this.type) {
      this.type = G_NORMAL_MAP;
    }
    var mapObject, termsOfUse, poweredBy;
    var cache = OpenLayers.Layer.Google.cache[this.map.id];
    if (cache) {
      mapObject = cache.mapObject;
      termsOfUse = cache.termsOfUse;
      poweredBy = cache.poweredBy;
      ++cache.count;
    } else {
      var container = this.map.viewPortDiv;
      var div = document.createElement("div");
      div.id = this.map.id + "_GMap2Container";
      div.style.position = "absolute";
      div.style.width = "100%";
      div.style.height = "100%";
      container.appendChild(div);
      try {
        mapObject = new GMap2(div);
        termsOfUse = div.lastChild;
        container.appendChild(termsOfUse);
        termsOfUse.style.zIndex = "1100";
        termsOfUse.style.right = "";
        termsOfUse.style.bottom = "";
        termsOfUse.className = "olLayerGoogleCopyright";
        poweredBy = div.lastChild;
        container.appendChild(poweredBy);
        poweredBy.style.zIndex = "1100";
        poweredBy.style.right = "";
        poweredBy.style.bottom = "";
        poweredBy.className = "olLayerGooglePoweredBy gmnoprint";
      } catch (e) {
        throw e;
      }
      OpenLayers.Layer.Google.cache[this.map.id] = {
        mapObject: mapObject,
        termsOfUse: termsOfUse,
        poweredBy: poweredBy,
        count: 1
      };
    }
    this.mapObject = mapObject;
    this.termsOfUse = termsOfUse;
    this.poweredBy = poweredBy;
    if (
      OpenLayers.Util.indexOf(this.mapObject.getMapTypes(), this.type) === -1
    ) {
      this.mapObject.addMapType(this.type);
    }
    if (typeof mapObject.getDragObject == "function") {
      this.dragObject = mapObject.getDragObject();
    } else {
      this.dragPanMapObject = null;
    }
    if (this.isBaseLayer === false) {
      this.setGMapVisibility(this.div.style.display !== "none");
    }
  },
  onMapResize: function() {
    if (this.visibility && this.mapObject.isLoaded()) {
      this.mapObject.checkResize();
    } else {
      if (!this._resized) {
        var layer = this;
        var handle = GEvent.addListener(this.mapObject, "load", function() {
          GEvent.removeListener(handle);
          delete layer._resized;
          layer.mapObject.checkResize();
          layer.moveTo(layer.map.getCenter(), layer.map.getZoom());
        });
      }
      this._resized = true;
    }
  },
  setGMapVisibility: function(visible) {
    var cache = OpenLayers.Layer.Google.cache[this.map.id];
    if (cache) {
      var container = this.mapObject.getContainer();
      if (visible === true) {
        this.mapObject.setMapType(this.type);
        container.style.display = "";
        this.termsOfUse.style.left = "";
        this.termsOfUse.style.display = "";
        this.poweredBy.style.display = "";
        cache.displayed = this.id;
      } else {
        if (cache.displayed === this.id) {
          delete cache.displayed;
        }
        if (!cache.displayed) {
          container.style.display = "none";
          this.termsOfUse.style.display = "none";
          this.termsOfUse.style.left = "-9999px";
          this.poweredBy.style.display = "none";
        }
      }
    }
  },
  getMapContainer: function() {
    return this.mapObject.getContainer();
  },
  getMapObjectBoundsFromOLBounds: function(olBounds) {
    var moBounds = null;
    if (olBounds != null) {
      var sw = this.sphericalMercator
        ? this.inverseMercator(olBounds.bottom, olBounds.left)
        : new OpenLayers.LonLat(olBounds.bottom, olBounds.left);
      var ne = this.sphericalMercator
        ? this.inverseMercator(olBounds.top, olBounds.right)
        : new OpenLayers.LonLat(olBounds.top, olBounds.right);
      moBounds = new GLatLngBounds(
        new GLatLng(sw.lat, sw.lon),
        new GLatLng(ne.lat, ne.lon)
      );
    }
    return moBounds;
  },
  setMapObjectCenter: function(center, zoom) {
    this.mapObject.setCenter(center, zoom);
  },
  dragPanMapObject: function(dX, dY) {
    this.dragObject.moveBy(new GSize(-dX, dY));
  },
  getMapObjectLonLatFromMapObjectPixel: function(moPixel) {
    return this.mapObject.fromContainerPixelToLatLng(moPixel);
  },
  getMapObjectPixelFromMapObjectLonLat: function(moLonLat) {
    return this.mapObject.fromLatLngToContainerPixel(moLonLat);
  },
  getMapObjectZoomFromMapObjectBounds: function(moBounds) {
    return this.mapObject.getBoundsZoomLevel(moBounds);
  },
  getMapObjectLonLatFromLonLat: function(lon, lat) {
    var gLatLng;
    if (this.sphericalMercator) {
      var lonlat = this.inverseMercator(lon, lat);
      gLatLng = new GLatLng(lonlat.lat, lonlat.lon);
    } else {
      gLatLng = new GLatLng(lat, lon);
    }
    return gLatLng;
  },
  getMapObjectPixelFromXY: function(x, y) {
    return new GPoint(x, y);
  }
};
OpenLayers.Geometry = OpenLayers.Class({
  id: null,
  parent: null,
  bounds: null,
  initialize: function() {
    this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
  },
  destroy: function() {
    this.id = null;
    this.bounds = null;
  },
  clone: function() {
    return new OpenLayers.Geometry();
  },
  setBounds: function(bounds) {
    if (bounds) {
      this.bounds = bounds.clone();
    }
  },
  clearBounds: function() {
    this.bounds = null;
    if (this.parent) {
      this.parent.clearBounds();
    }
  },
  extendBounds: function(newBounds) {
    var bounds = this.getBounds();
    if (!bounds) {
      this.setBounds(newBounds);
    } else {
      this.bounds.extend(newBounds);
    }
  },
  getBounds: function() {
    if (this.bounds == null) {
      this.calculateBounds();
    }
    return this.bounds;
  },
  calculateBounds: function() {},
  distanceTo: function(geometry, options) {},
  getVertices: function(nodes) {},
  atPoint: function(lonlat, toleranceLon, toleranceLat) {
    var atPoint = false;
    var bounds = this.getBounds();
    if (bounds != null && lonlat != null) {
      var dX = toleranceLon != null ? toleranceLon : 0;
      var dY = toleranceLat != null ? toleranceLat : 0;
      var toleranceBounds = new OpenLayers.Bounds(
        this.bounds.left - dX,
        this.bounds.bottom - dY,
        this.bounds.right + dX,
        this.bounds.top + dY
      );
      atPoint = toleranceBounds.containsLonLat(lonlat);
    }
    return atPoint;
  },
  getLength: function() {
    return 0.0;
  },
  getArea: function() {
    return 0.0;
  },
  getCentroid: function() {
    return null;
  },
  toString: function() {
    var string;
    if (OpenLayers.Format && OpenLayers.Format.WKT) {
      string = OpenLayers.Format.WKT.prototype.write(
        new OpenLayers.Feature.Vector(this)
      );
    } else {
      string = Object.prototype.toString.call(this);
    }
    return string;
  },
  CLASS_NAME: "OpenLayers.Geometry"
});
OpenLayers.Geometry.fromWKT = function(wkt) {
  var geom;
  if (OpenLayers.Format && OpenLayers.Format.WKT) {
    var format = OpenLayers.Geometry.fromWKT.format;
    if (!format) {
      format = new OpenLayers.Format.WKT();
      OpenLayers.Geometry.fromWKT.format = format;
    }
    var result = format.read(wkt);
    if (result instanceof OpenLayers.Feature.Vector) {
      geom = result.geometry;
    } else if (OpenLayers.Util.isArray(result)) {
      var len = result.length;
      var components = new Array(len);
      for (var i = 0; i < len; ++i) {
        components[i] = result[i].geometry;
      }
      geom = new OpenLayers.Geometry.Collection(components);
    }
  }
  return geom;
};
OpenLayers.Geometry.segmentsIntersect = function(seg1, seg2, options) {
  var point = options && options.point;
  var tolerance = options && options.tolerance;
  var intersection = false;
  var x11_21 = seg1.x1 - seg2.x1;
  var y11_21 = seg1.y1 - seg2.y1;
  var x12_11 = seg1.x2 - seg1.x1;
  var y12_11 = seg1.y2 - seg1.y1;
  var y22_21 = seg2.y2 - seg2.y1;
  var x22_21 = seg2.x2 - seg2.x1;
  var d = y22_21 * x12_11 - x22_21 * y12_11;
  var n1 = x22_21 * y11_21 - y22_21 * x11_21;
  var n2 = x12_11 * y11_21 - y12_11 * x11_21;
  if (d == 0) {
    if (n1 == 0 && n2 == 0) {
      intersection = true;
    }
  } else {
    var along1 = n1 / d;
    var along2 = n2 / d;
    if (along1 >= 0 && along1 <= 1 && along2 >= 0 && along2 <= 1) {
      if (!point) {
        intersection = true;
      } else {
        var x = seg1.x1 + along1 * x12_11;
        var y = seg1.y1 + along1 * y12_11;
        intersection = new OpenLayers.Geometry.Point(x, y);
      }
    }
  }
  if (tolerance) {
    var dist;
    if (intersection) {
      if (point) {
        var segs = [seg1, seg2];
        var seg, x, y;
        outer: for (var i = 0; i < 2; ++i) {
          seg = segs[i];
          for (var j = 1; j < 3; ++j) {
            x = seg["x" + j];
            y = seg["y" + j];
            dist = Math.sqrt(
              Math.pow(x - intersection.x, 2) + Math.pow(y - intersection.y, 2)
            );
            if (dist < tolerance) {
              intersection.x = x;
              intersection.y = y;
              break outer;
            }
          }
        }
      }
    } else {
      var segs = [seg1, seg2];
      var source, target, x, y, p, result;
      outer: for (var i = 0; i < 2; ++i) {
        source = segs[i];
        target = segs[(i + 1) % 2];
        for (var j = 1; j < 3; ++j) {
          p = { x: source["x" + j], y: source["y" + j] };
          result = OpenLayers.Geometry.distanceToSegment(p, target);
          if (result.distance < tolerance) {
            if (point) {
              intersection = new OpenLayers.Geometry.Point(p.x, p.y);
            } else {
              intersection = true;
            }
            break outer;
          }
        }
      }
    }
  }
  return intersection;
};
OpenLayers.Geometry.distanceToSegment = function(point, segment) {
  var x0 = point.x;
  var y0 = point.y;
  var x1 = segment.x1;
  var y1 = segment.y1;
  var x2 = segment.x2;
  var y2 = segment.y2;
  var dx = x2 - x1;
  var dy = y2 - y1;
  var along =
    (dx * (x0 - x1) + dy * (y0 - y1)) / (Math.pow(dx, 2) + Math.pow(dy, 2));
  var x, y;
  if (along <= 0.0) {
    x = x1;
    y = y1;
  } else if (along >= 1.0) {
    x = x2;
    y = y2;
  } else {
    x = x1 + along * dx;
    y = y1 + along * dy;
  }
  return {
    distance: Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2)),
    x: x,
    y: y
  };
};
OpenLayers.Geometry.Collection = OpenLayers.Class(OpenLayers.Geometry, {
  components: null,
  componentTypes: null,
  initialize: function(components) {
    OpenLayers.Geometry.prototype.initialize.apply(this, arguments);
    this.components = [];
    if (components != null) {
      this.addComponents(components);
    }
  },
  destroy: function() {
    this.components.length = 0;
    this.components = null;
    OpenLayers.Geometry.prototype.destroy.apply(this, arguments);
  },
  clone: function() {
    var geometry = eval("new " + this.CLASS_NAME + "()");
    for (var i = 0, len = this.components.length; i < len; i++) {
      geometry.addComponent(this.components[i].clone());
    }
    OpenLayers.Util.applyDefaults(geometry, this);
    return geometry;
  },
  getComponentsString: function() {
    var strings = [];
    for (var i = 0, len = this.components.length; i < len; i++) {
      strings.push(this.components[i].toShortString());
    }
    return strings.join(",");
  },
  calculateBounds: function() {
    this.bounds = null;
    var bounds = new OpenLayers.Bounds();
    var components = this.components;
    if (components) {
      for (var i = 0, len = components.length; i < len; i++) {
        bounds.extend(components[i].getBounds());
      }
    }
    if (
      bounds.left != null &&
      bounds.bottom != null &&
      bounds.right != null &&
      bounds.top != null
    ) {
      this.setBounds(bounds);
    }
  },
  addComponents: function(components) {
    if (!OpenLayers.Util.isArray(components)) {
      components = [components];
    }
    for (var i = 0, len = components.length; i < len; i++) {
      this.addComponent(components[i]);
    }
  },
  addComponent: function(component, index) {
    var added = false;
    if (component) {
      if (
        this.componentTypes == null ||
        OpenLayers.Util.indexOf(this.componentTypes, component.CLASS_NAME) > -1
      ) {
        if (index != null && index < this.components.length) {
          var components1 = this.components.slice(0, index);
          var components2 = this.components.slice(
            index,
            this.components.length
          );
          components1.push(component);
          this.components = components1.concat(components2);
        } else {
          this.components.push(component);
        }
        component.parent = this;
        this.clearBounds();
        added = true;
      }
    }
    return added;
  },
  removeComponents: function(components) {
    var removed = false;
    if (!OpenLayers.Util.isArray(components)) {
      components = [components];
    }
    for (var i = components.length - 1; i >= 0; --i) {
      removed = this.removeComponent(components[i]) || removed;
    }
    return removed;
  },
  removeComponent: function(component) {
    OpenLayers.Util.removeItem(this.components, component);
    this.clearBounds();
    return true;
  },
  getLength: function() {
    var length = 0.0;
    for (var i = 0, len = this.components.length; i < len; i++) {
      length += this.components[i].getLength();
    }
    return length;
  },
  getArea: function() {
    var area = 0.0;
    for (var i = 0, len = this.components.length; i < len; i++) {
      area += this.components[i].getArea();
    }
    return area;
  },
  getGeodesicArea: function(projection) {
    var area = 0.0;
    for (var i = 0, len = this.components.length; i < len; i++) {
      area += this.components[i].getGeodesicArea(projection);
    }
    return area;
  },
  getCentroid: function(weighted) {
    if (!weighted) {
      return this.components.length && this.components[0].getCentroid();
    }
    var len = this.components.length;
    if (!len) {
      return false;
    }
    var areas = [];
    var centroids = [];
    var areaSum = 0;
    var minArea = Number.MAX_VALUE;
    var component;
    for (var i = 0; i < len; ++i) {
      component = this.components[i];
      var area = component.getArea();
      var centroid = component.getCentroid(true);
      if (isNaN(area) || isNaN(centroid.x) || isNaN(centroid.y)) {
        continue;
      }
      areas.push(area);
      areaSum += area;
      minArea = area < minArea && area > 0 ? area : minArea;
      centroids.push(centroid);
    }
    len = areas.length;
    if (areaSum === 0) {
      for (var i = 0; i < len; ++i) {
        areas[i] = 1;
      }
      areaSum = areas.length;
    } else {
      for (var i = 0; i < len; ++i) {
        areas[i] /= minArea;
      }
      areaSum /= minArea;
    }
    var xSum = 0,
      ySum = 0,
      centroid,
      area;
    for (var i = 0; i < len; ++i) {
      centroid = centroids[i];
      area = areas[i];
      xSum += centroid.x * area;
      ySum += centroid.y * area;
    }
    return new OpenLayers.Geometry.Point(xSum / areaSum, ySum / areaSum);
  },
  getGeodesicLength: function(projection) {
    var length = 0.0;
    for (var i = 0, len = this.components.length; i < len; i++) {
      length += this.components[i].getGeodesicLength(projection);
    }
    return length;
  },
  move: function(x, y) {
    for (var i = 0, len = this.components.length; i < len; i++) {
      this.components[i].move(x, y);
    }
  },
  rotate: function(angle, origin) {
    for (var i = 0, len = this.components.length; i < len; ++i) {
      this.components[i].rotate(angle, origin);
    }
  },
  resize: function(scale, origin, ratio) {
    for (var i = 0; i < this.components.length; ++i) {
      this.components[i].resize(scale, origin, ratio);
    }
    return this;
  },
  distanceTo: function(geometry, options) {
    var edge = !(options && options.edge === false);
    var details = edge && options && options.details;
    var result, best, distance;
    var min = Number.POSITIVE_INFINITY;
    for (var i = 0, len = this.components.length; i < len; ++i) {
      result = this.components[i].distanceTo(geometry, options);
      distance = details ? result.distance : result;
      if (distance < min) {
        min = distance;
        best = result;
        if (min == 0) {
          break;
        }
      }
    }
    return best;
  },
  equals: function(geometry) {
    var equivalent = true;
    if (
      !geometry ||
      !geometry.CLASS_NAME ||
      this.CLASS_NAME != geometry.CLASS_NAME
    ) {
      equivalent = false;
    } else if (
      !OpenLayers.Util.isArray(geometry.components) ||
      geometry.components.length != this.components.length
    ) {
      equivalent = false;
    } else {
      for (var i = 0, len = this.components.length; i < len; ++i) {
        if (!this.components[i].equals(geometry.components[i])) {
          equivalent = false;
          break;
        }
      }
    }
    return equivalent;
  },
  transform: function(source, dest) {
    if (source && dest) {
      for (var i = 0, len = this.components.length; i < len; i++) {
        var component = this.components[i];
        component.transform(source, dest);
      }
      this.bounds = null;
    }
    return this;
  },
  intersects: function(geometry) {
    var intersect = false;
    for (var i = 0, len = this.components.length; i < len; ++i) {
      intersect = geometry.intersects(this.components[i]);
      if (intersect) {
        break;
      }
    }
    return intersect;
  },
  getVertices: function(nodes) {
    var vertices = [];
    for (var i = 0, len = this.components.length; i < len; ++i) {
      Array.prototype.push.apply(
        vertices,
        this.components[i].getVertices(nodes)
      );
    }
    return vertices;
  },
  CLASS_NAME: "OpenLayers.Geometry.Collection"
});
OpenLayers.Geometry.Point = OpenLayers.Class(OpenLayers.Geometry, {
  x: null,
  y: null,
  initialize: function(x, y) {
    OpenLayers.Geometry.prototype.initialize.apply(this, arguments);
    this.x = parseFloat(x);
    this.y = parseFloat(y);
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Geometry.Point(this.x, this.y);
    }
    OpenLayers.Util.applyDefaults(obj, this);
    return obj;
  },
  calculateBounds: function() {
    this.bounds = new OpenLayers.Bounds(this.x, this.y, this.x, this.y);
  },
  distanceTo: function(geometry, options) {
    var edge = !(options && options.edge === false);
    var details = edge && options && options.details;
    var distance, x0, y0, x1, y1, result;
    if (geometry instanceof OpenLayers.Geometry.Point) {
      x0 = this.x;
      y0 = this.y;
      x1 = geometry.x;
      y1 = geometry.y;
      distance = Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2));
      result = !details
        ? distance
        : { x0: x0, y0: y0, x1: x1, y1: y1, distance: distance };
    } else {
      result = geometry.distanceTo(this, options);
      if (details) {
        result = {
          x0: result.x1,
          y0: result.y1,
          x1: result.x0,
          y1: result.y0,
          distance: result.distance
        };
      }
    }
    return result;
  },
  equals: function(geom) {
    var equals = false;
    if (geom != null) {
      equals =
        (this.x == geom.x && this.y == geom.y) ||
        (isNaN(this.x) && isNaN(this.y) && isNaN(geom.x) && isNaN(geom.y));
    }
    return equals;
  },
  toShortString: function() {
    return this.x + ", " + this.y;
  },
  move: function(x, y) {
    this.x = this.x + x;
    this.y = this.y + y;
    this.clearBounds();
  },
  rotate: function(angle, origin) {
    angle *= Math.PI / 180;
    var radius = this.distanceTo(origin);
    var theta = angle + Math.atan2(this.y - origin.y, this.x - origin.x);
    this.x = origin.x + radius * Math.cos(theta);
    this.y = origin.y + radius * Math.sin(theta);
    this.clearBounds();
  },
  getCentroid: function() {
    return new OpenLayers.Geometry.Point(this.x, this.y);
  },
  resize: function(scale, origin, ratio) {
    ratio = ratio == undefined ? 1 : ratio;
    this.x = origin.x + scale * ratio * (this.x - origin.x);
    this.y = origin.y + scale * (this.y - origin.y);
    this.clearBounds();
    return this;
  },
  intersects: function(geometry) {
    var intersect = false;
    if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
      intersect = this.equals(geometry);
    } else {
      intersect = geometry.intersects(this);
    }
    return intersect;
  },
  transform: function(source, dest) {
    if (source && dest) {
      OpenLayers.Projection.transform(this, source, dest);
      this.bounds = null;
    }
    return this;
  },
  getVertices: function(nodes) {
    return [this];
  },
  CLASS_NAME: "OpenLayers.Geometry.Point"
});
OpenLayers.Geometry.MultiPoint = OpenLayers.Class(
  OpenLayers.Geometry.Collection,
  {
    componentTypes: ["OpenLayers.Geometry.Point"],
    addPoint: function(point, index) {
      this.addComponent(point, index);
    },
    removePoint: function(point) {
      this.removeComponent(point);
    },
    CLASS_NAME: "OpenLayers.Geometry.MultiPoint"
  }
);
OpenLayers.Geometry.Curve = OpenLayers.Class(OpenLayers.Geometry.MultiPoint, {
  componentTypes: ["OpenLayers.Geometry.Point"],
  getLength: function() {
    var length = 0.0;
    if (this.components && this.components.length > 1) {
      for (var i = 1, len = this.components.length; i < len; i++) {
        length += this.components[i - 1].distanceTo(this.components[i]);
      }
    }
    return length;
  },
  getGeodesicLength: function(projection) {
    var geom = this;
    if (projection) {
      var gg = new OpenLayers.Projection("EPSG:4326");
      if (!gg.equals(projection)) {
        geom = this.clone().transform(projection, gg);
      }
    }
    var length = 0.0;
    if (geom.components && geom.components.length > 1) {
      var p1, p2;
      for (var i = 1, len = geom.components.length; i < len; i++) {
        p1 = geom.components[i - 1];
        p2 = geom.components[i];
        length += OpenLayers.Util.distVincenty(
          { lon: p1.x, lat: p1.y },
          { lon: p2.x, lat: p2.y }
        );
      }
    }
    return length * 1000;
  },
  CLASS_NAME: "OpenLayers.Geometry.Curve"
});
OpenLayers.Geometry.LineString = OpenLayers.Class(OpenLayers.Geometry.Curve, {
  removeComponent: function(point) {
    var removed = this.components && this.components.length > 2;
    if (removed) {
      OpenLayers.Geometry.Collection.prototype.removeComponent.apply(
        this,
        arguments
      );
    }
    return removed;
  },
  intersects: function(geometry) {
    var intersect = false;
    var type = geometry.CLASS_NAME;
    if (
      type == "OpenLayers.Geometry.LineString" ||
      type == "OpenLayers.Geometry.LinearRing" ||
      type == "OpenLayers.Geometry.Point"
    ) {
      var segs1 = this.getSortedSegments();
      var segs2;
      if (type == "OpenLayers.Geometry.Point") {
        segs2 = [
          { x1: geometry.x, y1: geometry.y, x2: geometry.x, y2: geometry.y }
        ];
      } else {
        segs2 = geometry.getSortedSegments();
      }
      var seg1, seg1x1, seg1x2, seg1y1, seg1y2, seg2, seg2y1, seg2y2;
      outer: for (var i = 0, len = segs1.length; i < len; ++i) {
        seg1 = segs1[i];
        seg1x1 = seg1.x1;
        seg1x2 = seg1.x2;
        seg1y1 = seg1.y1;
        seg1y2 = seg1.y2;
        inner: for (var j = 0, jlen = segs2.length; j < jlen; ++j) {
          seg2 = segs2[j];
          if (seg2.x1 > seg1x2) {
            break;
          }
          if (seg2.x2 < seg1x1) {
            continue;
          }
          seg2y1 = seg2.y1;
          seg2y2 = seg2.y2;
          if (Math.min(seg2y1, seg2y2) > Math.max(seg1y1, seg1y2)) {
            continue;
          }
          if (Math.max(seg2y1, seg2y2) < Math.min(seg1y1, seg1y2)) {
            continue;
          }
          if (OpenLayers.Geometry.segmentsIntersect(seg1, seg2)) {
            intersect = true;
            break outer;
          }
        }
      }
    } else {
      intersect = geometry.intersects(this);
    }
    return intersect;
  },
  getSortedSegments: function() {
    var numSeg = this.components.length - 1;
    var segments = new Array(numSeg),
      point1,
      point2;
    for (var i = 0; i < numSeg; ++i) {
      point1 = this.components[i];
      point2 = this.components[i + 1];
      if (point1.x < point2.x) {
        segments[i] = {
          x1: point1.x,
          y1: point1.y,
          x2: point2.x,
          y2: point2.y
        };
      } else {
        segments[i] = {
          x1: point2.x,
          y1: point2.y,
          x2: point1.x,
          y2: point1.y
        };
      }
    }
    function byX1(seg1, seg2) {
      return seg1.x1 - seg2.x1;
    }
    return segments.sort(byX1);
  },
  splitWithSegment: function(seg, options) {
    var edge = !(options && options.edge === false);
    var tolerance = options && options.tolerance;
    var lines = [];
    var verts = this.getVertices();
    var points = [];
    var intersections = [];
    var split = false;
    var vert1, vert2, point;
    var node, vertex, target;
    var interOptions = { point: true, tolerance: tolerance };
    var result = null;
    for (var i = 0, stop = verts.length - 2; i <= stop; ++i) {
      vert1 = verts[i];
      points.push(vert1.clone());
      vert2 = verts[i + 1];
      target = { x1: vert1.x, y1: vert1.y, x2: vert2.x, y2: vert2.y };
      point = OpenLayers.Geometry.segmentsIntersect(seg, target, interOptions);
      if (point instanceof OpenLayers.Geometry.Point) {
        if (
          (point.x === seg.x1 && point.y === seg.y1) ||
          (point.x === seg.x2 && point.y === seg.y2) ||
          point.equals(vert1) ||
          point.equals(vert2)
        ) {
          vertex = true;
        } else {
          vertex = false;
        }
        if (vertex || edge) {
          if (!point.equals(intersections[intersections.length - 1])) {
            intersections.push(point.clone());
          }
          if (i === 0) {
            if (point.equals(vert1)) {
              continue;
            }
          }
          if (point.equals(vert2)) {
            continue;
          }
          split = true;
          if (!point.equals(vert1)) {
            points.push(point);
          }
          lines.push(new OpenLayers.Geometry.LineString(points));
          points = [point.clone()];
        }
      }
    }
    if (split) {
      points.push(vert2.clone());
      lines.push(new OpenLayers.Geometry.LineString(points));
    }
    if (intersections.length > 0) {
      var xDir = seg.x1 < seg.x2 ? 1 : -1;
      var yDir = seg.y1 < seg.y2 ? 1 : -1;
      result = {
        lines: lines,
        points: intersections.sort(function(p1, p2) {
          return xDir * p1.x - xDir * p2.x || yDir * p1.y - yDir * p2.y;
        })
      };
    }
    return result;
  },
  split: function(target, options) {
    var results = null;
    var mutual = options && options.mutual;
    var sourceSplit, targetSplit, sourceParts, targetParts;
    if (target instanceof OpenLayers.Geometry.LineString) {
      var verts = this.getVertices();
      var vert1, vert2, seg, splits, lines, point;
      var points = [];
      sourceParts = [];
      for (var i = 0, stop = verts.length - 2; i <= stop; ++i) {
        vert1 = verts[i];
        vert2 = verts[i + 1];
        seg = { x1: vert1.x, y1: vert1.y, x2: vert2.x, y2: vert2.y };
        targetParts = targetParts || [target];
        if (mutual) {
          points.push(vert1.clone());
        }
        for (var j = 0; j < targetParts.length; ++j) {
          splits = targetParts[j].splitWithSegment(seg, options);
          if (splits) {
            lines = splits.lines;
            if (lines.length > 0) {
              lines.unshift(j, 1);
              Array.prototype.splice.apply(targetParts, lines);
              j += lines.length - 2;
            }
            if (mutual) {
              for (var k = 0, len = splits.points.length; k < len; ++k) {
                point = splits.points[k];
                if (!point.equals(vert1)) {
                  points.push(point);
                  sourceParts.push(new OpenLayers.Geometry.LineString(points));
                  if (point.equals(vert2)) {
                    points = [];
                  } else {
                    points = [point.clone()];
                  }
                }
              }
            }
          }
        }
      }
      if (mutual && sourceParts.length > 0 && points.length > 0) {
        points.push(vert2.clone());
        sourceParts.push(new OpenLayers.Geometry.LineString(points));
      }
    } else {
      results = target.splitWith(this, options);
    }
    if (targetParts && targetParts.length > 1) {
      targetSplit = true;
    } else {
      targetParts = [];
    }
    if (sourceParts && sourceParts.length > 1) {
      sourceSplit = true;
    } else {
      sourceParts = [];
    }
    if (targetSplit || sourceSplit) {
      if (mutual) {
        results = [sourceParts, targetParts];
      } else {
        results = targetParts;
      }
    }
    return results;
  },
  splitWith: function(geometry, options) {
    return geometry.split(this, options);
  },
  getVertices: function(nodes) {
    var vertices;
    if (nodes === true) {
      vertices = [
        this.components[0],
        this.components[this.components.length - 1]
      ];
    } else if (nodes === false) {
      vertices = this.components.slice(1, this.components.length - 1);
    } else {
      vertices = this.components.slice();
    }
    return vertices;
  },
  distanceTo: function(geometry, options) {
    var edge = !(options && options.edge === false);
    var details = edge && options && options.details;
    var result,
      best = {};
    var min = Number.POSITIVE_INFINITY;
    if (geometry instanceof OpenLayers.Geometry.Point) {
      var segs = this.getSortedSegments();
      var x = geometry.x;
      var y = geometry.y;
      var seg;
      for (var i = 0, len = segs.length; i < len; ++i) {
        seg = segs[i];
        result = OpenLayers.Geometry.distanceToSegment(geometry, seg);
        if (result.distance < min) {
          min = result.distance;
          best = result;
          if (min === 0) {
            break;
          }
        } else {
          if (
            seg.x2 > x &&
            ((y > seg.y1 && y < seg.y2) || (y < seg.y1 && y > seg.y2))
          ) {
            break;
          }
        }
      }
      if (details) {
        best = {
          distance: best.distance,
          x0: best.x,
          y0: best.y,
          x1: x,
          y1: y
        };
      } else {
        best = best.distance;
      }
    } else if (geometry instanceof OpenLayers.Geometry.LineString) {
      var segs0 = this.getSortedSegments();
      var segs1 = geometry.getSortedSegments();
      var seg0, seg1, intersection, x0, y0;
      var len1 = segs1.length;
      var interOptions = { point: true };
      outer: for (var i = 0, len = segs0.length; i < len; ++i) {
        seg0 = segs0[i];
        x0 = seg0.x1;
        y0 = seg0.y1;
        for (var j = 0; j < len1; ++j) {
          seg1 = segs1[j];
          intersection = OpenLayers.Geometry.segmentsIntersect(
            seg0,
            seg1,
            interOptions
          );
          if (intersection) {
            min = 0;
            best = {
              distance: 0,
              x0: intersection.x,
              y0: intersection.y,
              x1: intersection.x,
              y1: intersection.y
            };
            break outer;
          } else {
            result = OpenLayers.Geometry.distanceToSegment(
              { x: x0, y: y0 },
              seg1
            );
            if (result.distance < min) {
              min = result.distance;
              best = {
                distance: min,
                x0: x0,
                y0: y0,
                x1: result.x,
                y1: result.y
              };
            }
          }
        }
      }
      if (!details) {
        best = best.distance;
      }
      if (min !== 0) {
        if (seg0) {
          result = geometry.distanceTo(
            new OpenLayers.Geometry.Point(seg0.x2, seg0.y2),
            options
          );
          var dist = details ? result.distance : result;
          if (dist < min) {
            if (details) {
              best = {
                distance: min,
                x0: result.x1,
                y0: result.y1,
                x1: result.x0,
                y1: result.y0
              };
            } else {
              best = dist;
            }
          }
        }
      }
    } else {
      best = geometry.distanceTo(this, options);
      if (details) {
        best = {
          distance: best.distance,
          x0: best.x1,
          y0: best.y1,
          x1: best.x0,
          y1: best.y0
        };
      }
    }
    return best;
  },
  simplify: function(tolerance) {
    if (this && this !== null) {
      var points = this.getVertices();
      if (points.length < 3) {
        return this;
      }
      var compareNumbers = function(a, b) {
        return a - b;
      };
      var douglasPeuckerReduction = function(
        points,
        firstPoint,
        lastPoint,
        tolerance
      ) {
        var maxDistance = 0;
        var indexFarthest = 0;
        for (var index = firstPoint, distance; index < lastPoint; index++) {
          distance = perpendicularDistance(
            points[firstPoint],
            points[lastPoint],
            points[index]
          );
          if (distance > maxDistance) {
            maxDistance = distance;
            indexFarthest = index;
          }
        }
        if (maxDistance > tolerance && indexFarthest != firstPoint) {
          pointIndexsToKeep.push(indexFarthest);
          douglasPeuckerReduction(points, firstPoint, indexFarthest, tolerance);
          douglasPeuckerReduction(points, indexFarthest, lastPoint, tolerance);
        }
      };
      var perpendicularDistance = function(point1, point2, point) {
        var area = Math.abs(
          0.5 *
            (point1.x * point2.y +
              point2.x * point.y +
              point.x * point1.y -
              point2.x * point1.y -
              point.x * point2.y -
              point1.x * point.y)
        );
        var bottom = Math.sqrt(
          Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2)
        );
        var height = (area / bottom) * 2;
        return height;
      };
      var firstPoint = 0;
      var lastPoint = points.length - 1;
      var pointIndexsToKeep = [];
      pointIndexsToKeep.push(firstPoint);
      pointIndexsToKeep.push(lastPoint);
      while (points[firstPoint].equals(points[lastPoint])) {
        lastPoint--;
        pointIndexsToKeep.push(lastPoint);
      }
      douglasPeuckerReduction(points, firstPoint, lastPoint, tolerance);
      var returnPoints = [];
      pointIndexsToKeep.sort(compareNumbers);
      for (var index = 0; index < pointIndexsToKeep.length; index++) {
        returnPoints.push(points[pointIndexsToKeep[index]]);
      }
      return new OpenLayers.Geometry.LineString(returnPoints);
    } else {
      return this;
    }
  },
  CLASS_NAME: "OpenLayers.Geometry.LineString"
});
OpenLayers.Geometry.LinearRing = OpenLayers.Class(
  OpenLayers.Geometry.LineString,
  {
    componentTypes: ["OpenLayers.Geometry.Point"],
    addComponent: function(point, index) {
      var added = false;
      var lastPoint = this.components.pop();
      if (index != null || !point.equals(lastPoint)) {
        added = OpenLayers.Geometry.Collection.prototype.addComponent.apply(
          this,
          arguments
        );
      }
      var firstPoint = this.components[0];
      OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, [
        firstPoint
      ]);
      return added;
    },
    removeComponent: function(point) {
      var removed = this.components && this.components.length > 3;
      if (removed) {
        this.components.pop();
        OpenLayers.Geometry.Collection.prototype.removeComponent.apply(
          this,
          arguments
        );
        var firstPoint = this.components[0];
        OpenLayers.Geometry.Collection.prototype.addComponent.apply(this, [
          firstPoint
        ]);
      }
      return removed;
    },
    move: function(x, y) {
      for (var i = 0, len = this.components.length; i < len - 1; i++) {
        this.components[i].move(x, y);
      }
    },
    rotate: function(angle, origin) {
      for (var i = 0, len = this.components.length; i < len - 1; ++i) {
        this.components[i].rotate(angle, origin);
      }
    },
    resize: function(scale, origin, ratio) {
      for (var i = 0, len = this.components.length; i < len - 1; ++i) {
        this.components[i].resize(scale, origin, ratio);
      }
      return this;
    },
    transform: function(source, dest) {
      if (source && dest) {
        for (var i = 0, len = this.components.length; i < len - 1; i++) {
          var component = this.components[i];
          component.transform(source, dest);
        }
        this.bounds = null;
      }
      return this;
    },
    getCentroid: function() {
      if (this.components && this.components.length > 2) {
        var sumX = 0.0;
        var sumY = 0.0;
        for (var i = 0; i < this.components.length - 1; i++) {
          var b = this.components[i];
          var c = this.components[i + 1];
          sumX += (b.x + c.x) * (b.x * c.y - c.x * b.y);
          sumY += (b.y + c.y) * (b.x * c.y - c.x * b.y);
        }
        var area = -1 * this.getArea();
        var x = sumX / (6 * area);
        var y = sumY / (6 * area);
        return new OpenLayers.Geometry.Point(x, y);
      } else {
        return null;
      }
    },
    getArea: function() {
      var area = 0.0;
      if (this.components && this.components.length > 2) {
        var sum = 0.0;
        for (var i = 0, len = this.components.length; i < len - 1; i++) {
          var b = this.components[i];
          var c = this.components[i + 1];
          sum += (b.x + c.x) * (c.y - b.y);
        }
        area = -sum / 2.0;
      }
      return area;
    },
    getGeodesicArea: function(projection) {
      var ring = this;
      if (projection) {
        var gg = new OpenLayers.Projection("EPSG:4326");
        if (!gg.equals(projection)) {
          ring = this.clone().transform(projection, gg);
        }
      }
      var area = 0.0;
      var len = ring.components && ring.components.length;
      if (len > 2) {
        var p1, p2;
        for (var i = 0; i < len - 1; i++) {
          p1 = ring.components[i];
          p2 = ring.components[i + 1];
          area +=
            OpenLayers.Util.rad(p2.x - p1.x) *
            (2 +
              Math.sin(OpenLayers.Util.rad(p1.y)) +
              Math.sin(OpenLayers.Util.rad(p2.y)));
        }
        area = (area * 6378137.0 * 6378137.0) / 2.0;
      }
      return area;
    },
    containsPoint: function(point) {
      var approx = OpenLayers.Number.limitSigDigs;
      var digs = 14;
      var px = approx(point.x, digs);
      var py = approx(point.y, digs);
      function getX(y, x1, y1, x2, y2) {
        return (y - y2) * ((x2 - x1) / (y2 - y1)) + x2;
      }
      var numSeg = this.components.length - 1;
      var start, end, x1, y1, x2, y2, cx, cy;
      var crosses = 0;
      for (var i = 0; i < numSeg; ++i) {
        start = this.components[i];
        x1 = approx(start.x, digs);
        y1 = approx(start.y, digs);
        end = this.components[i + 1];
        x2 = approx(end.x, digs);
        y2 = approx(end.y, digs);
        if (y1 == y2) {
          if (py == y1) {
            if (
              (x1 <= x2 && (px >= x1 && px <= x2)) ||
              (x1 >= x2 && (px <= x1 && px >= x2))
            ) {
              crosses = -1;
              break;
            }
          }
          continue;
        }
        cx = approx(getX(py, x1, y1, x2, y2), digs);
        if (cx == px) {
          if (
            (y1 < y2 && (py >= y1 && py <= y2)) ||
            (y1 > y2 && (py <= y1 && py >= y2))
          ) {
            crosses = -1;
            break;
          }
        }
        if (cx <= px) {
          continue;
        }
        if (x1 != x2 && (cx < Math.min(x1, x2) || cx > Math.max(x1, x2))) {
          continue;
        }
        if (
          (y1 < y2 && (py >= y1 && py < y2)) ||
          (y1 > y2 && (py < y1 && py >= y2))
        ) {
          ++crosses;
        }
      }
      var contained = crosses == -1 ? 1 : !!(crosses & 1);
      return contained;
    },
    intersects: function(geometry) {
      var intersect = false;
      if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
        intersect = this.containsPoint(geometry);
      } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString") {
        intersect = geometry.intersects(this);
      } else if (geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") {
        intersect = OpenLayers.Geometry.LineString.prototype.intersects.apply(
          this,
          [geometry]
        );
      } else {
        for (var i = 0, len = geometry.components.length; i < len; ++i) {
          intersect = geometry.components[i].intersects(this);
          if (intersect) {
            break;
          }
        }
      }
      return intersect;
    },
    getVertices: function(nodes) {
      return nodes === true
        ? []
        : this.components.slice(0, this.components.length - 1);
    },
    CLASS_NAME: "OpenLayers.Geometry.LinearRing"
  }
);
OpenLayers.Layer.HTTPRequest = OpenLayers.Class(OpenLayers.Layer, {
  URL_HASH_FACTOR: (Math.sqrt(5) - 1) / 2,
  url: null,
  params: null,
  reproject: false,
  initialize: function(name, url, params, options) {
    OpenLayers.Layer.prototype.initialize.apply(this, [name, options]);
    this.url = url;
    if (!this.params) {
      this.params = OpenLayers.Util.extend({}, params);
    }
  },
  destroy: function() {
    this.url = null;
    this.params = null;
    OpenLayers.Layer.prototype.destroy.apply(this, arguments);
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.HTTPRequest(
        this.name,
        this.url,
        this.params,
        this.getOptions()
      );
    }
    obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]);
    return obj;
  },
  setUrl: function(newUrl) {
    this.url = newUrl;
  },
  mergeNewParams: function(newParams) {
    this.params = OpenLayers.Util.extend(this.params, newParams);
    var ret = this.redraw();
    if (this.map != null) {
      this.map.events.triggerEvent("changelayer", {
        layer: this,
        property: "params"
      });
    }
    return ret;
  },
  redraw: function(force) {
    if (force) {
      return this.mergeNewParams({ _olSalt: Math.random() });
    } else {
      return OpenLayers.Layer.prototype.redraw.apply(this, []);
    }
  },
  selectUrl: function(paramString, urls) {
    var product = 1;
    for (var i = 0, len = paramString.length; i < len; i++) {
      product *= paramString.charCodeAt(i) * this.URL_HASH_FACTOR;
      product -= Math.floor(product);
    }
    return urls[Math.floor(product * urls.length)];
  },
  getFullRequestString: function(newParams, altUrl) {
    var url = altUrl || this.url;
    var allParams = OpenLayers.Util.extend({}, this.params);
    allParams = OpenLayers.Util.extend(allParams, newParams);
    var paramsString = OpenLayers.Util.getParameterString(allParams);
    if (OpenLayers.Util.isArray(url)) {
      url = this.selectUrl(paramsString, url);
    }
    var urlParams = OpenLayers.Util.upperCaseObject(
      OpenLayers.Util.getParameters(url)
    );
    for (var key in allParams) {
      if (key.toUpperCase() in urlParams) {
        delete allParams[key];
      }
    }
    paramsString = OpenLayers.Util.getParameterString(allParams);
    return OpenLayers.Util.urlAppend(url, paramsString);
  },
  CLASS_NAME: "OpenLayers.Layer.HTTPRequest"
});
OpenLayers.Tile = OpenLayers.Class({
  events: null,
  eventListeners: null,
  id: null,
  layer: null,
  url: null,
  bounds: null,
  size: null,
  position: null,
  isLoading: false,
  initialize: function(layer, position, bounds, url, size, options) {
    this.layer = layer;
    this.position = position.clone();
    this.setBounds(bounds);
    this.url = url;
    if (size) {
      this.size = size.clone();
    }
    this.id = OpenLayers.Util.createUniqueID("Tile_");
    OpenLayers.Util.extend(this, options);
    this.events = new OpenLayers.Events(this);
    if (this.eventListeners instanceof Object) {
      this.events.on(this.eventListeners);
    }
  },
  unload: function() {
    if (this.isLoading) {
      this.isLoading = false;
      this.events.triggerEvent("unload");
    }
  },
  destroy: function() {
    this.layer = null;
    this.bounds = null;
    this.size = null;
    this.position = null;
    if (this.eventListeners) {
      this.events.un(this.eventListeners);
    }
    this.events.destroy();
    this.eventListeners = null;
    this.events = null;
  },
  draw: function(deferred) {
    if (!deferred) {
      this.clear();
    }
    var draw = this.shouldDraw();
    if (draw && !deferred) {
      draw = this.events.triggerEvent("beforedraw") !== false;
    }
    return draw;
  },
  shouldDraw: function() {
    var withinMaxExtent = false,
      maxExtent = this.layer.maxExtent;
    if (maxExtent) {
      var map = this.layer.map;
      var worldBounds = map.baseLayer.wrapDateLine && map.getMaxExtent();
      if (
        this.bounds.intersectsBounds(maxExtent, {
          inclusive: false,
          worldBounds: worldBounds
        })
      ) {
        withinMaxExtent = true;
      }
    }
    return withinMaxExtent || this.layer.displayOutsideMaxExtent;
  },
  setBounds: function(bounds) {
    bounds = bounds.clone();
    if (this.layer.map.baseLayer.wrapDateLine) {
      var worldExtent = this.layer.map.getMaxExtent(),
        tolerance = this.layer.map.getResolution();
      bounds = bounds.wrapDateLine(worldExtent, {
        leftTolerance: tolerance,
        rightTolerance: tolerance
      });
    }
    this.bounds = bounds;
  },
  moveTo: function(bounds, position, redraw) {
    if (redraw == null) {
      redraw = true;
    }
    this.setBounds(bounds);
    this.position = position.clone();
    if (redraw) {
      this.draw();
    }
  },
  clear: function(draw) {},
  CLASS_NAME: "OpenLayers.Tile"
});
OpenLayers.Tile.Image = OpenLayers.Class(OpenLayers.Tile, {
  url: null,
  imgDiv: null,
  frame: null,
  imageReloadAttempts: null,
  layerAlphaHack: null,
  asyncRequestId: null,
  blankImageUrl:
    "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAQAIBRAA7",
  maxGetUrlLength: null,
  canvasContext: null,
  crossOriginKeyword: null,
  initialize: function(layer, position, bounds, url, size, options) {
    OpenLayers.Tile.prototype.initialize.apply(this, arguments);
    this.url = url;
    this.layerAlphaHack = this.layer.alpha && OpenLayers.Util.alphaHack();
    if (
      this.maxGetUrlLength != null ||
      this.layer.gutter ||
      this.layerAlphaHack
    ) {
      this.frame = document.createElement("div");
      this.frame.style.position = "absolute";
      this.frame.style.overflow = "hidden";
    }
    if (this.maxGetUrlLength != null) {
      OpenLayers.Util.extend(this, OpenLayers.Tile.Image.IFrame);
    }
  },
  destroy: function() {
    if (this.imgDiv) {
      this.clear();
      this.imgDiv = null;
      this.frame = null;
    }
    this.asyncRequestId = null;
    OpenLayers.Tile.prototype.destroy.apply(this, arguments);
  },
  draw: function() {
    var drawn = OpenLayers.Tile.prototype.draw.apply(this, arguments);
    if (drawn) {
      if (this.layer != this.layer.map.baseLayer && this.layer.reproject) {
        this.bounds = this.getBoundsFromBaseLayer(this.position);
      }
      if (this.isLoading) {
        this._loadEvent = "reload";
      } else {
        this.isLoading = true;
        this._loadEvent = "loadstart";
      }
      this.positionTile();
      this.renderTile();
    } else {
      this.unload();
    }
    return drawn;
  },
  renderTile: function() {
    this.layer.div.appendChild(this.getTile());
    if (this.layer.async) {
      var id = (this.asyncRequestId = (this.asyncRequestId || 0) + 1);
      this.layer.getURLasync(
        this.bounds,
        function(url) {
          if (id == this.asyncRequestId) {
            this.url = url;
            this.initImage();
          }
        },
        this
      );
    } else {
      this.url = this.layer.getURL(this.bounds);
      this.initImage();
    }
  },
  positionTile: function() {
    var style = this.getTile().style,
      size = this.frame ? this.size : this.layer.getImageSize(this.bounds);
    style.left = this.position.x + "%";
    style.top = this.position.y + "%";
    style.width = size.w + "%";
    style.height = size.h + "%";
  },
  clear: function() {
    OpenLayers.Tile.prototype.clear.apply(this, arguments);
    var img = this.imgDiv;
    if (img) {
      OpenLayers.Event.stopObservingElement(img);
      var tile = this.getTile();
      if (tile.parentNode === this.layer.div) {
        this.layer.div.removeChild(tile);
      }
      this.setImgSrc();
      if (this.layerAlphaHack === true) {
        img.style.filter = "";
      }
      OpenLayers.Element.removeClass(img, "olImageLoadError");
    }
    this.canvasContext = null;
  },
  getImage: function() {
    if (!this.imgDiv) {
      this.imgDiv = document.createElement("img");
      this.imgDiv.className = "olTileImage";
      this.imgDiv.galleryImg = "no";
      var style = this.imgDiv.style;
      if (this.frame) {
        var left = 0,
          top = 0;
        if (this.layer.gutter) {
          left = (this.layer.gutter / this.layer.tileSize.w) * 100;
          top = (this.layer.gutter / this.layer.tileSize.h) * 100;
        }
        style.left = -left + "%";
        style.top = -top + "%";
        style.width = 2 * left + 100 + "%";
        style.height = 2 * top + 100 + "%";
      }
      style.visibility = "hidden";
      style.opacity = 0;
      if (this.layer.opacity < 1) {
        style.filter = "alpha(opacity=" + this.layer.opacity * 100 + ")";
      }
      style.position = "absolute";
      if (this.layerAlphaHack) {
        style.paddingTop = style.height;
        style.height = "0";
        style.width = "100%";
      }
      if (this.frame) {
        this.frame.appendChild(this.imgDiv);
      }
    }
    return this.imgDiv;
  },
  initImage: function() {
    this.events.triggerEvent(this._loadEvent);
    var img = this.getImage();
    if (this.url && img.getAttribute("src") == this.url) {
      this.onImageLoad();
    } else {
      var load = OpenLayers.Function.bind(function() {
        OpenLayers.Event.stopObservingElement(img);
        OpenLayers.Event.observe(
          img,
          "load",
          OpenLayers.Function.bind(this.onImageLoad, this)
        );
        OpenLayers.Event.observe(
          img,
          "error",
          OpenLayers.Function.bind(this.onImageError, this)
        );
        this.imageReloadAttempts = 0;
        this.setImgSrc(this.url);
      }, this);
      if (img.getAttribute("src") == this.blankImageUrl) {
        load();
      } else {
        OpenLayers.Event.observe(img, "load", load);
        OpenLayers.Event.observe(img, "error", load);
        if (this.crossOriginKeyword) {
          img.removeAttribute("crossorigin");
        }
        img.src = this.blankImageUrl;
      }
    }
  },
  setImgSrc: function(url) {
    var img = this.imgDiv;
    img.style.visibility = "hidden";
    img.style.opacity = 0;
    if (url) {
      if (this.crossOriginKeyword) {
        if (url.substr(0, 5) !== "data:") {
          img.setAttribute("crossorigin", this.crossOriginKeyword);
        } else {
          img.removeAttribute("crossorigin");
        }
      }
      img.src = url;
    }
  },
  getTile: function() {
    return this.frame ? this.frame : this.getImage();
  },
  createBackBuffer: function() {
    if (!this.imgDiv || this.isLoading) {
      return;
    }
    var backBuffer;
    if (this.frame) {
      backBuffer = this.frame.cloneNode(false);
      backBuffer.appendChild(this.imgDiv);
    } else {
      backBuffer = this.imgDiv;
    }
    this.imgDiv = null;
    return backBuffer;
  },
  onImageLoad: function() {
    var img = this.imgDiv;
    OpenLayers.Event.stopObservingElement(img);
    img.style.visibility = "inherit";
    img.style.opacity = this.layer.opacity;
    this.isLoading = false;
    this.canvasContext = null;
    this.events.triggerEvent("loadend");
    if (
      parseFloat(navigator.appVersion.split("MSIE")[1]) < 7 &&
      this.layer &&
      this.layer.div
    ) {
      var span = document.createElement("span");
      span.style.display = "none";
      var layerDiv = this.layer.div;
      layerDiv.appendChild(span);
      window.setTimeout(function() {
        span.parentNode === layerDiv && span.parentNode.removeChild(span);
      }, 0);
    }
    if (this.layerAlphaHack === true) {
      img.style.filter =
        "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" +
        img.src +
        "', sizingMethod='scale')";
    }
  },
  onImageError: function() {
    var img = this.imgDiv;
    if (img.src != null) {
      this.imageReloadAttempts++;
      if (this.imageReloadAttempts <= OpenLayers.IMAGE_RELOAD_ATTEMPTS) {
        this.setImgSrc(this.layer.getURL(this.bounds));
      } else {
        OpenLayers.Element.addClass(img, "olImageLoadError");
        this.events.triggerEvent("loaderror");
        this.onImageLoad();
      }
    }
  },
  getCanvasContext: function() {
    if (OpenLayers.CANVAS_SUPPORTED && this.imgDiv && !this.isLoading) {
      if (!this.canvasContext) {
        var canvas = document.createElement("canvas");
        canvas.width = this.size.w;
        canvas.height = this.size.h;
        this.canvasContext = canvas.getContext("2d");
        this.canvasContext.drawImage(this.imgDiv, 0, 0);
      }
      return this.canvasContext;
    }
  },
  CLASS_NAME: "OpenLayers.Tile.Image"
});
OpenLayers.Layer.Grid = OpenLayers.Class(OpenLayers.Layer.HTTPRequest, {
  tileSize: null,
  tileOriginCorner: "bl",
  tileOrigin: null,
  tileOptions: null,
  tileClass: OpenLayers.Tile.Image,
  grid: null,
  singleTile: false,
  ratio: 1.5,
  buffer: 0,
  transitionEffect: null,
  numLoadingTiles: 0,
  tileLoadingDelay: 85,
  serverResolutions: null,
  moveTimerId: null,
  deferMoveGriddedTiles: null,
  tileQueueId: null,
  tileQueue: null,
  loading: false,
  backBuffer: null,
  gridResolution: null,
  backBufferResolution: null,
  backBufferLonLat: null,
  backBufferTimerId: null,
  removeBackBufferDelay: null,
  className: null,
  initialize: function(name, url, params, options) {
    OpenLayers.Layer.HTTPRequest.prototype.initialize.apply(this, arguments);
    this.grid = [];
    this.tileQueue = [];
    if (this.removeBackBufferDelay === null) {
      this.removeBackBufferDelay = this.singleTile ? 0 : 2500;
    }
    if (this.className === null) {
      this.className = this.singleTile
        ? "olLayerGridSingleTile"
        : "olLayerGrid";
    }
    if (!OpenLayers.Animation.isNative) {
      this.deferMoveGriddedTiles = OpenLayers.Function.bind(function() {
        this.moveGriddedTiles(true);
        this.moveTimerId = null;
      }, this);
    }
  },
  setMap: function(map) {
    OpenLayers.Layer.HTTPRequest.prototype.setMap.call(this, map);
    OpenLayers.Element.addClass(this.div, this.className);
  },
  removeMap: function(map) {
    if (this.moveTimerId !== null) {
      window.clearTimeout(this.moveTimerId);
      this.moveTimerId = null;
    }
    this.clearTileQueue();
    if (this.backBufferTimerId !== null) {
      window.clearTimeout(this.backBufferTimerId);
      this.backBufferTimerId = null;
    }
  },
  destroy: function() {
    this.removeBackBuffer();
    this.clearGrid();
    this.grid = null;
    this.tileSize = null;
    OpenLayers.Layer.HTTPRequest.prototype.destroy.apply(this, arguments);
  },
  clearGrid: function() {
    this.clearTileQueue();
    if (this.grid) {
      for (var iRow = 0, len = this.grid.length; iRow < len; iRow++) {
        var row = this.grid[iRow];
        for (var iCol = 0, clen = row.length; iCol < clen; iCol++) {
          var tile = row[iCol];
          this.destroyTile(tile);
        }
      }
      this.grid = [];
      this.gridResolution = null;
    }
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.Grid(
        this.name,
        this.url,
        this.params,
        this.getOptions()
      );
    }
    obj = OpenLayers.Layer.HTTPRequest.prototype.clone.apply(this, [obj]);
    if (this.tileSize != null) {
      obj.tileSize = this.tileSize.clone();
    }
    obj.grid = [];
    obj.gridResolution = null;
    obj.backBuffer = null;
    obj.backBufferTimerId = null;
    obj.tileQueue = [];
    obj.tileQueueId = null;
    obj.loading = false;
    obj.moveTimerId = null;
    return obj;
  },
  moveTo: function(bounds, zoomChanged, dragging) {
    OpenLayers.Layer.HTTPRequest.prototype.moveTo.apply(this, arguments);
    bounds = bounds || this.map.getExtent();
    if (bounds != null) {
      var forceReTile = !this.grid.length || zoomChanged;
      var tilesBounds = this.getTilesBounds();
      var resolution = this.map.getResolution();
      var serverResolution = this.getServerResolution(resolution);
      if (this.singleTile) {
        if (forceReTile || (!dragging && !tilesBounds.containsBounds(bounds))) {
          if (zoomChanged && this.transitionEffect !== "resize") {
            this.removeBackBuffer();
          }
          if (!zoomChanged || this.transitionEffect === "resize") {
            this.applyBackBuffer(serverResolution);
          }
          this.initSingleTile(bounds);
        }
      } else {
        forceReTile =
          forceReTile ||
          !tilesBounds.intersectsBounds(bounds, {
            worldBounds:
              this.map.baseLayer.wrapDateLine && this.map.getMaxExtent()
          });
        if (resolution !== serverResolution) {
          bounds = this.map.calculateBounds(null, serverResolution);
          if (forceReTile) {
            var scale = serverResolution / resolution;
            this.transformDiv(scale);
          }
        } else {
          this.div.style.width = "100%";
          this.div.style.height = "100%";
          this.div.style.left = "0%";
          this.div.style.top = "0%";
        }
        if (forceReTile) {
          if (zoomChanged && this.transitionEffect === "resize") {
            this.applyBackBuffer(serverResolution);
          }
          this.initGriddedTiles(bounds);
        } else {
          this.moveGriddedTiles();
        }
      }
    }
  },
  getTileData: function(loc) {
    var data = null,
      x = loc.lon,
      y = loc.lat,
      numRows = this.grid.length;
    if (this.map && numRows) {
      var res = this.map.getResolution(),
        tileWidth = this.tileSize.w,
        tileHeight = this.tileSize.h,
        bounds = this.grid[0][0].bounds,
        left = bounds.left,
        top = bounds.top;
      if (x < left) {
        if (this.map.baseLayer.wrapDateLine) {
          var worldWidth = this.map.getMaxExtent().getWidth();
          var worldsAway = Math.ceil((left - x) / worldWidth);
          x += worldWidth * worldsAway;
        }
      }
      var dtx = (x - left) / (res * tileWidth);
      var dty = (top - y) / (res * tileHeight);
      var col = Math.floor(dtx);
      var row = Math.floor(dty);
      if (row >= 0 && row < numRows) {
        var tile = this.grid[row][col];
        if (tile) {
          data = {
            tile: tile,
            i: Math.floor((dtx - col) * tileWidth),
            j: Math.floor((dty - row) * tileHeight)
          };
        }
      }
    }
    return data;
  },
  queueTileDraw: function(evt) {
    var tile = evt.object;
    if (!~OpenLayers.Util.indexOf(this.tileQueue, tile)) {
      this.tileQueue.push(tile);
    }
    if (!this.tileQueueId) {
      this.tileQueueId = OpenLayers.Animation.start(
        OpenLayers.Function.bind(this.drawTileFromQueue, this),
        null,
        this.div
      );
    }
    return false;
  },
  drawTileFromQueue: function() {
    if (this.tileQueue.length === 0) {
      this.clearTileQueue();
    } else {
      this.tileQueue.shift().draw(true);
    }
  },
  clearTileQueue: function() {
    OpenLayers.Animation.stop(this.tileQueueId);
    this.tileQueueId = null;
    this.tileQueue = [];
  },
  destroyTile: function(tile) {
    this.removeTileMonitoringHooks(tile);
    tile.destroy();
  },
  getServerResolution: function(resolution) {
    resolution = resolution || this.map.getResolution();
    if (
      this.serverResolutions &&
      OpenLayers.Util.indexOf(this.serverResolutions, resolution) === -1
    ) {
      var i, serverResolution;
      for (i = this.serverResolutions.length - 1; i >= 0; i--) {
        serverResolution = this.serverResolutions[i];
        if (serverResolution > resolution) {
          resolution = serverResolution;
          break;
        }
      }
      if (i === -1) {
        throw "no appropriate resolution in serverResolutions";
      }
    }
    return resolution;
  },
  getServerZoom: function() {
    var resolution = this.getServerResolution();
    return this.serverResolutions
      ? OpenLayers.Util.indexOf(this.serverResolutions, resolution)
      : this.map.getZoomForResolution(resolution) + (this.zoomOffset || 0);
  },
  transformDiv: function(scale) {
    this.div.style.width = 100 * scale + "%";
    this.div.style.height = 100 * scale + "%";
    var size = this.map.getSize();
    var lcX = parseInt(this.map.layerContainerDiv.style.left, 10);
    var lcY = parseInt(this.map.layerContainerDiv.style.top, 10);
    var x = (lcX - size.w / 2.0) * (scale - 1);
    var y = (lcY - size.h / 2.0) * (scale - 1);
    this.div.style.left = x + "%";
    this.div.style.top = y + "%";
  },
  getResolutionScale: function() {
    return parseInt(this.div.style.width, 10) / 100;
  },
  applyBackBuffer: function(resolution) {
    if (this.backBufferTimerId !== null) {
      this.removeBackBuffer();
    }
    var backBuffer = this.backBuffer;
    if (!backBuffer) {
      backBuffer = this.createBackBuffer();
      if (!backBuffer) {
        return;
      }
      this.div.insertBefore(backBuffer, this.div.firstChild);
      this.backBuffer = backBuffer;
      var topLeftTileBounds = this.grid[0][0].bounds;
      this.backBufferLonLat = {
        lon: topLeftTileBounds.left,
        lat: topLeftTileBounds.top
      };
      this.backBufferResolution = this.gridResolution;
    }
    var style = backBuffer.style;
    var ratio = this.backBufferResolution / resolution;
    style.width = 100 * ratio + "%";
    style.height = 100 * ratio + "%";
    var position = this.getViewPortPxFromLonLat(
      this.backBufferLonLat,
      resolution
    );
    var leftOffset = parseInt(this.map.layerContainerDiv.style.left, 10);
    var topOffset = parseInt(this.map.layerContainerDiv.style.top, 10);
    backBuffer.style.left = Math.round(position.x - leftOffset) + "%";
    backBuffer.style.top = Math.round(position.y - topOffset) + "%";
  },
  createBackBuffer: function() {
    var backBuffer;
    if (this.grid.length > 0) {
      backBuffer = document.createElement("div");
      backBuffer.id = this.div.id + "_bb";
      backBuffer.className = "olBackBuffer";
      backBuffer.style.position = "absolute";
      backBuffer.style.width = "100%";
      backBuffer.style.height = "100%";
      for (var i = 0, lenI = this.grid.length; i < lenI; i++) {
        for (var j = 0, lenJ = this.grid[i].length; j < lenJ; j++) {
          var tile = this.grid[i][j].createBackBuffer();
          if (!tile) {
            continue;
          }
          tile.style.top = i * this.tileSize.h + "%";
          tile.style.left = j * this.tileSize.w + "%";
          backBuffer.appendChild(tile);
        }
      }
    }
    return backBuffer;
  },
  removeBackBuffer: function() {
    if (this.backBuffer) {
      this.div.removeChild(this.backBuffer);
      this.backBuffer = null;
      this.backBufferResolution = null;
      if (this.backBufferTimerId !== null) {
        window.clearTimeout(this.backBufferTimerId);
        this.backBufferTimerId = null;
      }
    }
  },
  moveByPx: function(dx, dy) {
    if (!this.singleTile) {
      this.moveGriddedTiles();
    }
  },
  setTileSize: function(size) {
    if (this.singleTile) {
      size = this.map.getSize();
      size.h = parseInt(size.h * this.ratio);
      size.w = parseInt(size.w * this.ratio);
    }
    OpenLayers.Layer.HTTPRequest.prototype.setTileSize.apply(this, [size]);
  },
  getTilesBounds: function() {
    var bounds = null;
    var length = this.grid.length;
    if (length) {
      var bottomLeftTileBounds = this.grid[length - 1][0].bounds,
        width = this.grid[0].length * bottomLeftTileBounds.getWidth(),
        height = this.grid.length * bottomLeftTileBounds.getHeight();
      bounds = new OpenLayers.Bounds(
        bottomLeftTileBounds.left,
        bottomLeftTileBounds.bottom,
        bottomLeftTileBounds.left + width,
        bottomLeftTileBounds.bottom + height
      );
    }
    return bounds;
  },
  initSingleTile: function(bounds) {
    this.clearTileQueue();
    var center = bounds.getCenterLonLat();
    var tileWidth = bounds.getWidth() * this.ratio;
    var tileHeight = bounds.getHeight() * this.ratio;
    var tileBounds = new OpenLayers.Bounds(
      center.lon - tileWidth / 2,
      center.lat - tileHeight / 2,
      center.lon + tileWidth / 2,
      center.lat + tileHeight / 2
    );
    var px = this.map.getLayerPxFromLonLat({
      lon: tileBounds.left,
      lat: tileBounds.top
    });
    if (!this.grid.length) {
      this.grid[0] = [];
    }
    var tile = this.grid[0][0];
    if (!tile) {
      tile = this.addTile(tileBounds, px);
      this.addTileMonitoringHooks(tile);
      tile.draw();
      this.grid[0][0] = tile;
    } else {
      tile.moveTo(tileBounds, px);
    }
    this.removeExcessTiles(1, 1);
    this.gridResolution = this.getServerResolution();
  },
  calculateGridLayout: function(bounds, origin, resolution) {
    var tilelon = resolution * this.tileSize.w;
    var tilelat = resolution * this.tileSize.h;
    var offsetlon = bounds.left - origin.lon;
    var tilecol = Math.floor(offsetlon / tilelon) - this.buffer;
    var tilecolremain = offsetlon / tilelon - tilecol;
    var tileoffsetx = -tilecolremain * this.tileSize.w;
    var tileoffsetlon = origin.lon + tilecol * tilelon;
    var offsetlat = bounds.top - (origin.lat + tilelat);
    var tilerow = Math.ceil(offsetlat / tilelat) + this.buffer;
    var tilerowremain = tilerow - offsetlat / tilelat;
    var tileoffsety = -tilerowremain * this.tileSize.h;
    var tileoffsetlat = origin.lat + tilerow * tilelat;
    return {
      tilelon: tilelon,
      tilelat: tilelat,
      tileoffsetlon: tileoffsetlon,
      tileoffsetlat: tileoffsetlat,
      tileoffsetx: tileoffsetx,
      tileoffsety: tileoffsety
    };
  },
  getTileOrigin: function() {
    var origin = this.tileOrigin;
    if (!origin) {
      var extent = this.getMaxExtent();
      var edges = {
        tl: ["left", "top"],
        tr: ["right", "top"],
        bl: ["left", "bottom"],
        br: ["right", "bottom"]
      }[this.tileOriginCorner];
      origin = new OpenLayers.LonLat(extent[edges[0]], extent[edges[1]]);
    }
    return origin;
  },
  initGriddedTiles: function(bounds) {
    this.clearTileQueue();
    var viewSize = this.map.getSize();
    var minRows =
      Math.ceil(viewSize.h / this.tileSize.h) + Math.max(1, 2 * this.buffer);
    var minCols =
      Math.ceil(viewSize.w / this.tileSize.w) + Math.max(1, 2 * this.buffer);
    var origin = this.getTileOrigin();
    var resolution = this.getServerResolution();
    var tileLayout = this.calculateGridLayout(bounds, origin, resolution);
    var tileoffsetx = Math.round(tileLayout.tileoffsetx);
    var tileoffsety = Math.round(tileLayout.tileoffsety);
    var tileoffsetlon = tileLayout.tileoffsetlon;
    var tileoffsetlat = tileLayout.tileoffsetlat;
    var tilelon = tileLayout.tilelon;
    var tilelat = tileLayout.tilelat;
    var startX = tileoffsetx;
    var startLon = tileoffsetlon;
    var rowidx = 0;
    var layerContainerDivLeft = parseInt(this.map.layerContainerDiv.style.left);
    var layerContainerDivTop = parseInt(this.map.layerContainerDiv.style.top);
    var tileData = [],
      center = this.map.getCenter();
    do {
      var row = this.grid[rowidx++];
      if (!row) {
        row = [];
        this.grid.push(row);
      }
      tileoffsetlon = startLon;
      tileoffsetx = startX;
      var colidx = 0;
      do {
        var tileBounds = new OpenLayers.Bounds(
          tileoffsetlon,
          tileoffsetlat,
          tileoffsetlon + tilelon,
          tileoffsetlat + tilelat
        );
        var x = tileoffsetx;
        x -= layerContainerDivLeft;
        var y = tileoffsety;
        y -= layerContainerDivTop;
        var px = new OpenLayers.Pixel(x, y);
        var tile = row[colidx++];
        if (!tile) {
          tile = this.addTile(tileBounds, px);
          this.addTileMonitoringHooks(tile);
          row.push(tile);
        } else {
          tile.moveTo(tileBounds, px, false);
        }
        var tileCenter = tileBounds.getCenterLonLat();
        tileData.push({
          tile: tile,
          distance:
            Math.pow(tileCenter.lon - center.lon, 2) +
            Math.pow(tileCenter.lat - center.lat, 2)
        });
        tileoffsetlon += tilelon;
        tileoffsetx += this.tileSize.w;
      } while (
        tileoffsetlon <= bounds.right + tilelon * this.buffer ||
        colidx < minCols
      );
      tileoffsetlat -= tilelat;
      tileoffsety += this.tileSize.h;
    } while (
      tileoffsetlat >= bounds.bottom - tilelat * this.buffer ||
      rowidx < minRows
    );
    this.removeExcessTiles(rowidx, colidx);
    this.gridResolution = this.getServerResolution();
    tileData.sort(function(a, b) {
      return a.distance - b.distance;
    });
    for (var i = 0, ii = tileData.length; i < ii; ++i) {
      tileData[i].tile.draw();
    }
  },
  getMaxExtent: function() {
    return this.maxExtent;
  },
  addTile: function(bounds, position) {
    var tile = new this.tileClass(
      this,
      position,
      bounds,
      null,
      this.tileSize,
      this.tileOptions
    );
    tile.events.register("beforedraw", this, this.queueTileDraw);
    return tile;
  },
  addTileMonitoringHooks: function(tile) {
    tile.onLoadStart = function() {
      if (this.loading === false) {
        this.loading = true;
        this.events.triggerEvent("loadstart");
      }
      this.events.triggerEvent("tileloadstart", { tile: tile });
      this.numLoadingTiles++;
    };
    tile.onLoadEnd = function() {
      this.numLoadingTiles--;
      this.events.triggerEvent("tileloaded", { tile: tile });
      if (this.tileQueue.length === 0 && this.numLoadingTiles === 0) {
        this.loading = false;
        this.events.triggerEvent("loadend");
        if (this.backBuffer) {
          this.backBufferTimerId = window.setTimeout(
            OpenLayers.Function.bind(this.removeBackBuffer, this),
            this.removeBackBufferDelay
          );
        }
      }
    };
    tile.onLoadError = function() {
      this.events.triggerEvent("tileerror", { tile: tile });
    };
    tile.events.on({
      loadstart: tile.onLoadStart,
      loadend: tile.onLoadEnd,
      unload: tile.onLoadEnd,
      loaderror: tile.onLoadError,
      scope: this
    });
  },
  removeTileMonitoringHooks: function(tile) {
    tile.unload();
    tile.events.un({
      loadstart: tile.onLoadStart,
      loadend: tile.onLoadEnd,
      unload: tile.onLoadEnd,
      loaderror: tile.onLoadError,
      scope: this
    });
  },
  moveGriddedTiles: function(deferred) {
    if (!deferred && !OpenLayers.Animation.isNative) {
      if (this.moveTimerId != null) {
        window.clearTimeout(this.moveTimerId);
      }
      this.moveTimerId = window.setTimeout(
        this.deferMoveGriddedTiles,
        this.tileLoadingDelay
      );
      return;
    }
    var buffer = this.buffer || 1;
    var scale = this.getResolutionScale();
    while (true) {
      var tlViewPort = {
        x:
          this.grid[0][0].position.x * scale +
          parseInt(this.div.style.left, 10) +
          parseInt(this.map.layerContainerDiv.style.left),
        y:
          this.grid[0][0].position.y * scale +
          parseInt(this.div.style.top, 10) +
          parseInt(this.map.layerContainerDiv.style.top)
      };
      var tileSize = { w: this.tileSize.w * scale, h: this.tileSize.h * scale };
      if (tlViewPort.x > -tileSize.w * (buffer - 1)) {
        this.shiftColumn(true);
      } else if (tlViewPort.x < -tileSize.w * buffer) {
        this.shiftColumn(false);
      } else if (tlViewPort.y > -tileSize.h * (buffer - 1)) {
        this.shiftRow(true);
      } else if (tlViewPort.y < -tileSize.h * buffer) {
        this.shiftRow(false);
      } else {
        break;
      }
    }
  },
  shiftRow: function(prepend) {
    var modelRowIndex = prepend ? 0 : this.grid.length - 1;
    var grid = this.grid;
    var modelRow = grid[modelRowIndex];
    var resolution = this.getServerResolution();
    var deltaY = prepend ? -this.tileSize.h : this.tileSize.h;
    var deltaLat = resolution * -deltaY;
    var row = prepend ? grid.pop() : grid.shift();
    for (var i = 0, len = modelRow.length; i < len; i++) {
      var modelTile = modelRow[i];
      var bounds = modelTile.bounds.clone();
      var position = modelTile.position.clone();
      bounds.bottom = bounds.bottom + deltaLat;
      bounds.top = bounds.top + deltaLat;
      position.y = position.y + deltaY;
      row[i].moveTo(bounds, position);
    }
    if (prepend) {
      grid.unshift(row);
    } else {
      grid.push(row);
    }
  },
  shiftColumn: function(prepend) {
    var deltaX = prepend ? -this.tileSize.w : this.tileSize.w;
    var resolution = this.getServerResolution();
    var deltaLon = resolution * deltaX;
    for (var i = 0, len = this.grid.length; i < len; i++) {
      var row = this.grid[i];
      var modelTileIndex = prepend ? 0 : row.length - 1;
      var modelTile = row[modelTileIndex];
      var bounds = modelTile.bounds.clone();
      var position = modelTile.position.clone();
      bounds.left = bounds.left + deltaLon;
      bounds.right = bounds.right + deltaLon;
      position.x = position.x + deltaX;
      var tile = prepend ? this.grid[i].pop() : this.grid[i].shift();
      tile.moveTo(bounds, position);
      if (prepend) {
        row.unshift(tile);
      } else {
        row.push(tile);
      }
    }
  },
  removeExcessTiles: function(rows, columns) {
    var i, l;
    while (this.grid.length > rows) {
      var row = this.grid.pop();
      for (i = 0, l = row.length; i < l; i++) {
        var tile = row[i];
        this.destroyTile(tile);
      }
    }
    for (i = 0, l = this.grid.length; i < l; i++) {
      while (this.grid[i].length > columns) {
        var row = this.grid[i];
        var tile = row.pop();
        this.destroyTile(tile);
      }
    }
  },
  onMapResize: function() {
    if (this.singleTile) {
      this.clearGrid();
      this.setTileSize();
    }
  },
  getTileBounds: function(viewPortPx) {
    var maxExtent = this.maxExtent;
    var resolution = this.getResolution();
    var tileMapWidth = resolution * this.tileSize.w;
    var tileMapHeight = resolution * this.tileSize.h;
    var mapPoint = this.getLonLatFromViewPortPx(viewPortPx);
    var tileLeft =
      maxExtent.left +
      tileMapWidth * Math.floor((mapPoint.lon - maxExtent.left) / tileMapWidth);
    var tileBottom =
      maxExtent.bottom +
      tileMapHeight *
        Math.floor((mapPoint.lat - maxExtent.bottom) / tileMapHeight);
    return new OpenLayers.Bounds(
      tileLeft,
      tileBottom,
      tileLeft + tileMapWidth,
      tileBottom + tileMapHeight
    );
  },
  CLASS_NAME: "OpenLayers.Layer.Grid"
});
OpenLayers.Layer.XYZ = OpenLayers.Class(OpenLayers.Layer.Grid, {
  isBaseLayer: true,
  sphericalMercator: false,
  zoomOffset: 0,
  serverResolutions: null,
  initialize: function(name, url, options) {
    if ((options && options.sphericalMercator) || this.sphericalMercator) {
      options = OpenLayers.Util.extend(
        { projection: "EPSG:900913", numZoomLevels: 19 },
        options
      );
    }
    OpenLayers.Layer.Grid.prototype.initialize.apply(this, [
      name || this.name,
      url || this.url,
      {},
      options
    ]);
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.XYZ(this.name, this.url, this.getOptions());
    }
    obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
    return obj;
  },
  getURL: function(bounds) {
    var xyz = this.getXYZ(bounds);
    var url = this.url;
    if (OpenLayers.Util.isArray(url)) {
      var s = "" + xyz.x + xyz.y + xyz.z;
      url = this.selectUrl(s, url);
    }
    return OpenLayers.String.format(url, xyz);
  },
  getXYZ: function(bounds) {
    var res = this.getServerResolution();
    var x = Math.round(
      (bounds.left - this.maxExtent.left) / (res * this.tileSize.w)
    );
    var y = Math.round(
      (this.maxExtent.top - bounds.top) / (res * this.tileSize.h)
    );
    var z = this.getServerZoom();
    if (this.wrapDateLine) {
      var limit = Math.pow(2, z);
      x = ((x % limit) + limit) % limit;
    }
    return { x: x, y: y, z: z };
  },
  setMap: function(map) {
    OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments);
    if (!this.tileOrigin) {
      this.tileOrigin = new OpenLayers.LonLat(
        this.maxExtent.left,
        this.maxExtent.bottom
      );
    }
  },
  CLASS_NAME: "OpenLayers.Layer.XYZ"
});
OpenLayers.Layer.OSM = OpenLayers.Class(OpenLayers.Layer.XYZ, {
  name: "OpenStreetMap",
  url: [
    "http://a.tile.openstreetmap.org/${z}/${x}/${y}.png",
    "http://b.tile.openstreetmap.org/${z}/${x}/${y}.png",
    "http://c.tile.openstreetmap.org/${z}/${x}/${y}.png"
  ],
  attribution:
    "Data CC-By-SA by <a href='http://openstreetmap.org/'>OpenStreetMap</a>",
  sphericalMercator: true,
  wrapDateLine: true,
  tileOptions: null,
  initialize: function(name, url, options) {
    OpenLayers.Layer.XYZ.prototype.initialize.apply(this, arguments);
    this.tileOptions = OpenLayers.Util.extend(
      { crossOriginKeyword: "anonymous" },
      this.options && this.options.tileOptions
    );
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.OSM(this.name, this.url, this.getOptions());
    }
    obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]);
    return obj;
  },
  CLASS_NAME: "OpenLayers.Layer.OSM"
});
OpenLayers.Layer.Bing = OpenLayers.Class(OpenLayers.Layer.XYZ, {
  key: null,
  serverResolutions: [
    156543.03390625,
    78271.516953125,
    39135.7584765625,
    19567.87923828125,
    9783.939619140625,
    4891.9698095703125,
    2445.9849047851562,
    1222.9924523925781,
    611.4962261962891,
    305.74811309814453,
    152.87405654907226,
    76.43702827453613,
    38.218514137268066,
    19.109257068634033,
    9.554628534317017,
    4.777314267158508,
    2.388657133579254,
    1.194328566789627,
    0.5971642833948135,
    0.29858214169740677,
    0.14929107084870338,
    0.07464553542435169
  ],
  attributionTemplate:
    '<span class="olBingAttribution ${type}">' +
    '<div><a target="_blank" href="http://www.bing.com/maps/">' +
    '<img src="${logo}" /></a></div>${copyrights}' +
    '<a style="white-space: nowrap" target="_blank" ' +
    'href="http://www.microsoft.com/maps/product/terms.html">' +
    "Terms of Use</a></span>",
  metadata: null,
  type: "Road",
  culture: "en-US",
  metadataParams: null,
  tileOptions: null,
  initialize: function(options) {
    options = OpenLayers.Util.applyDefaults(
      { sphericalMercator: true },
      options
    );
    var name = options.name || "Bing " + (options.type || this.type);
    var newArgs = [name, null, options];
    OpenLayers.Layer.XYZ.prototype.initialize.apply(this, newArgs);
    this.tileOptions = OpenLayers.Util.extend(
      { crossOriginKeyword: "anonymous" },
      this.options.tileOptions
    );
    this.loadMetadata();
  },
  loadMetadata: function() {
    this._callbackId = "_callback_" + this.id.replace(/\./g, "_");
    window[this._callbackId] = OpenLayers.Function.bind(
      OpenLayers.Layer.Bing.processMetadata,
      this
    );
    var params = OpenLayers.Util.applyDefaults(
      { key: this.key, jsonp: this._callbackId, include: "ImageryProviders" },
      this.metadataParams
    );
    var url =
      "http://dev.virtualearth.net/REST/v1/Imagery/Metadata/" +
      this.type +
      "?" +
      OpenLayers.Util.getParameterString(params);
    var script = document.createElement("script");
    script.type = "text/javascript";
    script.src = url;
    script.id = this._callbackId;
    document.getElementsByTagName("head")[0].appendChild(script);
  },
  initLayer: function() {
    var res = this.metadata.resourceSets[0].resources[0];
    var url = res.imageUrl.replace("{quadkey}", "${quadkey}");
    url = url.replace("{culture}", this.culture);
    this.url = [];
    for (var i = 0; i < res.imageUrlSubdomains.length; ++i) {
      this.url.push(url.replace("{subdomain}", res.imageUrlSubdomains[i]));
    }
    this.addOptions(
      {
        maxResolution: Math.min(
          this.serverResolutions[res.zoomMin],
          this.maxResolution || Number.POSITIVE_INFINITY
        ),
        numZoomLevels: Math.min(
          res.zoomMax + 1 - res.zoomMin,
          this.numZoomLevels
        )
      },
      true
    );
  },
  getURL: function(bounds) {
    if (!this.url) {
      return;
    }
    var xyz = this.getXYZ(bounds),
      x = xyz.x,
      y = xyz.y,
      z = xyz.z;
    var quadDigits = [];
    for (var i = z; i > 0; --i) {
      var digit = "0";
      var mask = 1 << (i - 1);
      if ((x & mask) != 0) {
        digit++;
      }
      if ((y & mask) != 0) {
        digit++;
        digit++;
      }
      quadDigits.push(digit);
    }
    var quadKey = quadDigits.join("");
    var url = this.selectUrl("" + x + y + z, this.url);
    return OpenLayers.String.format(url, { quadkey: quadKey });
  },
  updateAttribution: function() {
    var metadata = this.metadata;
    if (!metadata.resourceSets || !this.map || !this.map.center) {
      return;
    }
    var res = metadata.resourceSets[0].resources[0];
    var extent = this.map
      .getExtent()
      .transform(
        this.map.getProjectionObject(),
        new OpenLayers.Projection("EPSG:4326")
      );
    var providers = res.imageryProviders,
      zoom = OpenLayers.Util.indexOf(
        this.serverResolutions,
        this.getServerResolution()
      ),
      copyrights = "",
      provider,
      i,
      ii,
      j,
      jj,
      bbox,
      coverage;
    for (i = 0, ii = providers.length; i < ii; ++i) {
      provider = providers[i];
      for (j = 0, jj = provider.coverageAreas.length; j < jj; ++j) {
        coverage = provider.coverageAreas[j];
        bbox = OpenLayers.Bounds.fromArray(coverage.bbox, true);
        if (
          extent.intersectsBounds(bbox) &&
          zoom <= coverage.zoomMax &&
          zoom >= coverage.zoomMin
        ) {
          copyrights += provider.attribution + " ";
        }
      }
    }
    this.attribution = OpenLayers.String.format(this.attributionTemplate, {
      type: this.type.toLowerCase(),
      logo: metadata.brandLogoUri,
      copyrights: copyrights
    });
    this.map &&
      this.map.events.triggerEvent("changelayer", {
        layer: this,
        property: "attribution"
      });
  },
  setMap: function() {
    OpenLayers.Layer.XYZ.prototype.setMap.apply(this, arguments);
    this.updateAttribution();
    this.map.events.register("moveend", this, this.updateAttribution);
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.Bing(this.options);
    }
    obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]);
    return obj;
  },
  destroy: function() {
    this.map &&
      this.map.events.unregister("moveend", this, this.updateAttribution);
    OpenLayers.Layer.XYZ.prototype.destroy.apply(this, arguments);
  },
  CLASS_NAME: "OpenLayers.Layer.Bing"
});
OpenLayers.Layer.Bing.processMetadata = function(metadata) {
  this.metadata = metadata;
  this.initLayer();
  var script = document.getElementById(this._callbackId);
  script.parentNode.removeChild(script);
  window[this._callbackId] = undefined;
  delete this._callbackId;
};
OpenLayers.Handler = OpenLayers.Class({
  id: null,
  control: null,
  map: null,
  keyMask: null,
  active: false,
  evt: null,
  initialize: function(control, callbacks, options) {
    OpenLayers.Util.extend(this, options);
    this.control = control;
    this.callbacks = callbacks;
    var map = this.map || control.map;
    if (map) {
      this.setMap(map);
    }
    this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
  },
  setMap: function(map) {
    this.map = map;
  },
  checkModifiers: function(evt) {
    if (this.keyMask == null) {
      return true;
    }
    var keyModifiers =
      (evt.shiftKey ? OpenLayers.Handler.MOD_SHIFT : 0) |
      (evt.ctrlKey ? OpenLayers.Handler.MOD_CTRL : 0) |
      (evt.altKey ? OpenLayers.Handler.MOD_ALT : 0);
    return keyModifiers == this.keyMask;
  },
  activate: function() {
    if (this.active) {
      return false;
    }
    var events = OpenLayers.Events.prototype.BROWSER_EVENTS;
    for (var i = 0, len = events.length; i < len; i++) {
      if (this[events[i]]) {
        this.register(events[i], this[events[i]]);
      }
    }
    this.active = true;
    return true;
  },
  deactivate: function() {
    if (!this.active) {
      return false;
    }
    var events = OpenLayers.Events.prototype.BROWSER_EVENTS;
    for (var i = 0, len = events.length; i < len; i++) {
      if (this[events[i]]) {
        this.unregister(events[i], this[events[i]]);
      }
    }
    this.active = false;
    return true;
  },
  callback: function(name, args) {
    if (name && this.callbacks[name]) {
      this.callbacks[name].apply(this.control, args);
    }
  },
  register: function(name, method) {
    this.map.events.registerPriority(name, this, method);
    this.map.events.registerPriority(name, this, this.setEvent);
  },
  unregister: function(name, method) {
    this.map.events.unregister(name, this, method);
    this.map.events.unregister(name, this, this.setEvent);
  },
  setEvent: function(evt) {
    this.evt = evt;
    return true;
  },
  destroy: function() {
    this.deactivate();
    this.control = this.map = null;
  },
  CLASS_NAME: "OpenLayers.Handler"
});
OpenLayers.Handler.MOD_NONE = 0;
OpenLayers.Handler.MOD_SHIFT = 1;
OpenLayers.Handler.MOD_CTRL = 2;
OpenLayers.Handler.MOD_ALT = 4;
OpenLayers.Handler.MouseWheel = OpenLayers.Class(OpenLayers.Handler, {
  wheelListener: null,
  mousePosition: null,
  interval: 0,
  delta: 0,
  cumulative: true,
  initialize: function(control, callbacks, options) {
    OpenLayers.Handler.prototype.initialize.apply(this, arguments);
    this.wheelListener = OpenLayers.Function.bindAsEventListener(
      this.onWheelEvent,
      this
    );
  },
  destroy: function() {
    OpenLayers.Handler.prototype.destroy.apply(this, arguments);
    this.wheelListener = null;
  },
  onWheelEvent: function(e) {
    if (!this.map || !this.checkModifiers(e)) {
      return;
    }
    var overScrollableDiv = false;
    var overLayerDiv = false;
    var overMapDiv = false;
    var elem = OpenLayers.Event.element(e);
    while (elem != null && !overMapDiv && !overScrollableDiv) {
      if (!overScrollableDiv) {
        try {
          if (elem.currentStyle) {
            overflow = elem.currentStyle["overflow"];
          } else {
            var style = document.defaultView.getComputedStyle(elem, null);
            var overflow = style.getPropertyValue("overflow");
          }
          overScrollableDiv =
            (overflow && overflow == "auto") || overflow == "scroll";
        } catch (err) {}
      }
      if (!overLayerDiv) {
        for (var i = 0, len = this.map.layers.length; i < len; i++) {
          if (
            elem == this.map.layers[i].div ||
            elem == this.map.layers[i].pane
          ) {
            overLayerDiv = true;
            break;
          }
        }
      }
      overMapDiv = elem == this.map.div;
      elem = elem.parentNode;
    }
    if (!overScrollableDiv && overMapDiv) {
      if (overLayerDiv) {
        var delta = 0;
        if (!e) {
          e = window.event;
        }
        if (e.wheelDelta) {
          delta = e.wheelDelta / 120;
          if (window.opera && window.opera.version() < 9.2) {
            delta = -delta;
          }
        } else if (e.detail) {
          delta = -e.detail / 3;
        }
        this.delta = this.delta + delta;
        if (this.interval) {
          window.clearTimeout(this._timeoutId);
          this._timeoutId = window.setTimeout(
            OpenLayers.Function.bind(function() {
              this.wheelZoom(e);
            }, this),
            this.interval
          );
        } else {
          this.wheelZoom(e);
        }
      }
      OpenLayers.Event.stop(e);
    }
  },
  wheelZoom: function(e) {
    var delta = this.delta;
    this.delta = 0;
    if (delta) {
      if (this.mousePosition) {
        e.xy = this.mousePosition;
      }
      if (!e.xy) {
        e.xy = this.map.getPixelFromLonLat(this.map.getCenter());
      }
      if (delta < 0) {
        this.callback("down", [e, this.cumulative ? delta : -1]);
      } else {
        this.callback("up", [e, this.cumulative ? delta : 1]);
      }
    }
  },
  mousemove: function(evt) {
    this.mousePosition = evt.xy;
  },
  activate: function(evt) {
    if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
      var wheelListener = this.wheelListener;
      OpenLayers.Event.observe(window, "DOMMouseScroll", wheelListener);
      OpenLayers.Event.observe(window, "mousewheel", wheelListener);
      OpenLayers.Event.observe(document, "mousewheel", wheelListener);
      return true;
    } else {
      return false;
    }
  },
  deactivate: function(evt) {
    if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
      var wheelListener = this.wheelListener;
      OpenLayers.Event.stopObserving(window, "DOMMouseScroll", wheelListener);
      OpenLayers.Event.stopObserving(window, "mousewheel", wheelListener);
      OpenLayers.Event.stopObserving(document, "mousewheel", wheelListener);
      return true;
    } else {
      return false;
    }
  },
  CLASS_NAME: "OpenLayers.Handler.MouseWheel"
});
OpenLayers.Geometry.MultiLineString = OpenLayers.Class(
  OpenLayers.Geometry.Collection,
  {
    componentTypes: ["OpenLayers.Geometry.LineString"],
    split: function(geometry, options) {
      var results = null;
      var mutual = options && options.mutual;
      var splits, sourceLine, sourceLines, sourceSplit, targetSplit;
      var sourceParts = [];
      var targetParts = [geometry];
      for (var i = 0, len = this.components.length; i < len; ++i) {
        sourceLine = this.components[i];
        sourceSplit = false;
        for (var j = 0; j < targetParts.length; ++j) {
          splits = sourceLine.split(targetParts[j], options);
          if (splits) {
            if (mutual) {
              sourceLines = splits[0];
              for (var k = 0, klen = sourceLines.length; k < klen; ++k) {
                if (k === 0 && sourceParts.length) {
                  sourceParts[sourceParts.length - 1].addComponent(
                    sourceLines[k]
                  );
                } else {
                  sourceParts.push(
                    new OpenLayers.Geometry.MultiLineString([sourceLines[k]])
                  );
                }
              }
              sourceSplit = true;
              splits = splits[1];
            }
            if (splits.length) {
              splits.unshift(j, 1);
              Array.prototype.splice.apply(targetParts, splits);
              break;
            }
          }
        }
        if (!sourceSplit) {
          if (sourceParts.length) {
            sourceParts[sourceParts.length - 1].addComponent(
              sourceLine.clone()
            );
          } else {
            sourceParts = [
              new OpenLayers.Geometry.MultiLineString(sourceLine.clone())
            ];
          }
        }
      }
      if (sourceParts && sourceParts.length > 1) {
        sourceSplit = true;
      } else {
        sourceParts = [];
      }
      if (targetParts && targetParts.length > 1) {
        targetSplit = true;
      } else {
        targetParts = [];
      }
      if (sourceSplit || targetSplit) {
        if (mutual) {
          results = [sourceParts, targetParts];
        } else {
          results = targetParts;
        }
      }
      return results;
    },
    splitWith: function(geometry, options) {
      var results = null;
      var mutual = options && options.mutual;
      var splits,
        targetLine,
        sourceLines,
        sourceSplit,
        targetSplit,
        sourceParts,
        targetParts;
      if (geometry instanceof OpenLayers.Geometry.LineString) {
        targetParts = [];
        sourceParts = [geometry];
        for (var i = 0, len = this.components.length; i < len; ++i) {
          targetSplit = false;
          targetLine = this.components[i];
          for (var j = 0; j < sourceParts.length; ++j) {
            splits = sourceParts[j].split(targetLine, options);
            if (splits) {
              if (mutual) {
                sourceLines = splits[0];
                if (sourceLines.length) {
                  sourceLines.unshift(j, 1);
                  Array.prototype.splice.apply(sourceParts, sourceLines);
                  j += sourceLines.length - 2;
                }
                splits = splits[1];
                if (splits.length === 0) {
                  splits = [targetLine.clone()];
                }
              }
              for (var k = 0, klen = splits.length; k < klen; ++k) {
                if (k === 0 && targetParts.length) {
                  targetParts[targetParts.length - 1].addComponent(splits[k]);
                } else {
                  targetParts.push(
                    new OpenLayers.Geometry.MultiLineString([splits[k]])
                  );
                }
              }
              targetSplit = true;
            }
          }
          if (!targetSplit) {
            if (targetParts.length) {
              targetParts[targetParts.length - 1].addComponent(
                targetLine.clone()
              );
            } else {
              targetParts = [
                new OpenLayers.Geometry.MultiLineString([targetLine.clone()])
              ];
            }
          }
        }
      } else {
        results = geometry.split(this);
      }
      if (sourceParts && sourceParts.length > 1) {
        sourceSplit = true;
      } else {
        sourceParts = [];
      }
      if (targetParts && targetParts.length > 1) {
        targetSplit = true;
      } else {
        targetParts = [];
      }
      if (sourceSplit || targetSplit) {
        if (mutual) {
          results = [sourceParts, targetParts];
        } else {
          results = targetParts;
        }
      }
      return results;
    },
    CLASS_NAME: "OpenLayers.Geometry.MultiLineString"
  }
);
OpenLayers.Renderer = OpenLayers.Class({
  container: null,
  root: null,
  extent: null,
  locked: false,
  size: null,
  resolution: null,
  map: null,
  featureDx: 0,
  initialize: function(containerID, options) {
    this.container = OpenLayers.Util.getElement(containerID);
    OpenLayers.Util.extend(this, options);
  },
  destroy: function() {
    this.container = null;
    this.extent = null;
    this.size = null;
    this.resolution = null;
    this.map = null;
  },
  supported: function() {
    return false;
  },
  setExtent: function(extent, resolutionChanged) {
    this.extent = extent.clone();
    if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
      var ratio = extent.getWidth() / this.map.getExtent().getWidth(),
        extent = extent.scale(1 / ratio);
      this.extent = extent.wrapDateLine(this.map.getMaxExtent()).scale(ratio);
    }
    if (resolutionChanged) {
      this.resolution = null;
    }
    return true;
  },
  setSize: function(size) {
    this.size = size.clone();
    this.resolution = null;
  },
  getResolution: function() {
    this.resolution = this.resolution || this.map.getResolution();
    return this.resolution;
  },
  drawFeature: function(feature, style) {
    if (style == null) {
      style = feature.style;
    }
    if (feature.geometry) {
      var bounds = feature.geometry.getBounds();
      if (bounds) {
        var worldBounds;
        if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
          worldBounds = this.map.getMaxExtent();
        }
        if (
          !bounds.intersectsBounds(this.extent, { worldBounds: worldBounds })
        ) {
          style = { display: "none" };
        } else {
          this.calculateFeatureDx(bounds, worldBounds);
        }
        var rendered = this.drawGeometry(feature.geometry, style, feature.id);
        if (style.display != "none" && style.label && rendered !== false) {
          var location = feature.geometry.getCentroid();
          if (style.labelXOffset || style.labelYOffset) {
            var xOffset = isNaN(style.labelXOffset) ? 0 : style.labelXOffset;
            var yOffset = isNaN(style.labelYOffset) ? 0 : style.labelYOffset;
            var res = this.getResolution();
            location.move(xOffset * res, yOffset * res);
          }
          this.drawText(feature.id, style, location);
        } else {
          this.removeText(feature.id);
        }
        return rendered;
      }
    }
  },
  calculateFeatureDx: function(bounds, worldBounds) {
    this.featureDx = 0;
    if (worldBounds) {
      var worldWidth = worldBounds.getWidth(),
        rendererCenterX = (this.extent.left + this.extent.right) / 2,
        featureCenterX = (bounds.left + bounds.right) / 2,
        worldsAway = Math.round(
          (featureCenterX - rendererCenterX) / worldWidth
        );
      this.featureDx = worldsAway * worldWidth;
    }
  },
  drawGeometry: function(geometry, style, featureId) {},
  drawText: function(featureId, style, location) {},
  removeText: function(featureId) {},
  clear: function() {},
  getFeatureIdFromEvent: function(evt) {},
  eraseFeatures: function(features) {
    if (!OpenLayers.Util.isArray(features)) {
      features = [features];
    }
    for (var i = 0, len = features.length; i < len; ++i) {
      var feature = features[i];
      this.eraseGeometry(feature.geometry, feature.id);
      this.removeText(feature.id);
    }
  },
  eraseGeometry: function(geometry, featureId) {},
  moveRoot: function(renderer) {},
  getRenderLayerId: function() {
    return this.container.id;
  },
  applyDefaultSymbolizer: function(symbolizer) {
    var result = OpenLayers.Util.extend(
      {},
      OpenLayers.Renderer.defaultSymbolizer
    );
    if (symbolizer.stroke === false) {
      delete result.strokeWidth;
      delete result.strokeColor;
    }
    if (symbolizer.fill === false) {
      delete result.fillColor;
    }
    OpenLayers.Util.extend(result, symbolizer);
    return result;
  },
  CLASS_NAME: "OpenLayers.Renderer"
});
OpenLayers.Renderer.defaultSymbolizer = {
  fillColor: "#000000",
  strokeColor: "#000000",
  strokeWidth: 2,
  fillOpacity: 1,
  strokeOpacity: 1,
  pointRadius: 0,
  labelAlign: "cm"
};
OpenLayers.Renderer.symbol = {
  star: [
    350,
    75,
    379,
    161,
    469,
    161,
    397,
    215,
    423,
    301,
    350,
    250,
    277,
    301,
    303,
    215,
    231,
    161,
    321,
    161,
    350,
    75
  ],
  cross: [
    4,
    0,
    6,
    0,
    6,
    4,
    10,
    4,
    10,
    6,
    6,
    6,
    6,
    10,
    4,
    10,
    4,
    6,
    0,
    6,
    0,
    4,
    4,
    4,
    4,
    0
  ],
  x: [
    0,
    0,
    25,
    0,
    50,
    35,
    75,
    0,
    100,
    0,
    65,
    50,
    100,
    100,
    75,
    100,
    50,
    65,
    25,
    100,
    0,
    100,
    35,
    50,
    0,
    0
  ],
  square: [0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
  triangle: [0, 10, 10, 10, 5, 0, 0, 10]
};
OpenLayers.ElementsIndexer = OpenLayers.Class({
  maxZIndex: null,
  order: null,
  indices: null,
  compare: null,
  initialize: function(yOrdering) {
    this.compare = yOrdering
      ? OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER
      : OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER;
    this.clear();
  },
  insert: function(newNode) {
    if (this.exists(newNode)) {
      this.remove(newNode);
    }
    var nodeId = newNode.id;
    this.determineZIndex(newNode);
    var leftIndex = -1;
    var rightIndex = this.order.length;
    var middle;
    while (rightIndex - leftIndex > 1) {
      middle = parseInt((leftIndex + rightIndex) / 2);
      var placement = this.compare(
        this,
        newNode,
        OpenLayers.Util.getElement(this.order[middle])
      );
      if (placement > 0) {
        leftIndex = middle;
      } else {
        rightIndex = middle;
      }
    }
    this.order.splice(rightIndex, 0, nodeId);
    this.indices[nodeId] = this.getZIndex(newNode);
    return this.getNextElement(rightIndex);
  },
  remove: function(node) {
    var nodeId = node.id;
    var arrayIndex = OpenLayers.Util.indexOf(this.order, nodeId);
    if (arrayIndex >= 0) {
      this.order.splice(arrayIndex, 1);
      delete this.indices[nodeId];
      if (this.order.length > 0) {
        var lastId = this.order[this.order.length - 1];
        this.maxZIndex = this.indices[lastId];
      } else {
        this.maxZIndex = 0;
      }
    }
  },
  clear: function() {
    this.order = [];
    this.indices = {};
    this.maxZIndex = 0;
  },
  exists: function(node) {
    return this.indices[node.id] != null;
  },
  getZIndex: function(node) {
    return node._style.graphicZIndex;
  },
  determineZIndex: function(node) {
    var zIndex = node._style.graphicZIndex;
    if (zIndex == null) {
      zIndex = this.maxZIndex;
      node._style.graphicZIndex = zIndex;
    } else if (zIndex > this.maxZIndex) {
      this.maxZIndex = zIndex;
    }
  },
  getNextElement: function(index) {
    var nextIndex = index + 1;
    if (nextIndex < this.order.length) {
      var nextElement = OpenLayers.Util.getElement(this.order[nextIndex]);
      if (nextElement == undefined) {
        nextElement = this.getNextElement(nextIndex);
      }
      return nextElement;
    } else {
      return null;
    }
  },
  CLASS_NAME: "OpenLayers.ElementsIndexer"
});
OpenLayers.ElementsIndexer.IndexingMethods = {
  Z_ORDER: function(indexer, newNode, nextNode) {
    var newZIndex = indexer.getZIndex(newNode);
    var returnVal = 0;
    if (nextNode) {
      var nextZIndex = indexer.getZIndex(nextNode);
      returnVal = newZIndex - nextZIndex;
    }
    return returnVal;
  },
  Z_ORDER_DRAWING_ORDER: function(indexer, newNode, nextNode) {
    var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(
      indexer,
      newNode,
      nextNode
    );
    if (nextNode && returnVal == 0) {
      returnVal = 1;
    }
    return returnVal;
  },
  Z_ORDER_Y_ORDER: function(indexer, newNode, nextNode) {
    var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(
      indexer,
      newNode,
      nextNode
    );
    if (nextNode && returnVal === 0) {
      var result = nextNode._boundsBottom - newNode._boundsBottom;
      returnVal = result === 0 ? 1 : result;
    }
    return returnVal;
  }
};
OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
  rendererRoot: null,
  root: null,
  vectorRoot: null,
  textRoot: null,
  xmlns: null,
  xOffset: 0,
  indexer: null,
  BACKGROUND_ID_SUFFIX: "_background",
  LABEL_ID_SUFFIX: "_label",
  LABEL_OUTLINE_SUFFIX: "_outline",
  initialize: function(containerID, options) {
    OpenLayers.Renderer.prototype.initialize.apply(this, arguments);
    this.rendererRoot = this.createRenderRoot();
    this.root = this.createRoot("_root");
    this.vectorRoot = this.createRoot("_vroot");
    this.textRoot = this.createRoot("_troot");
    this.root.appendChild(this.vectorRoot);
    this.root.appendChild(this.textRoot);
    this.rendererRoot.appendChild(this.root);
    this.container.appendChild(this.rendererRoot);
    if (options && (options.zIndexing || options.yOrdering)) {
      this.indexer = new OpenLayers.ElementsIndexer(options.yOrdering);
    }
  },
  destroy: function() {
    this.clear();
    this.rendererRoot = null;
    this.root = null;
    this.xmlns = null;
    OpenLayers.Renderer.prototype.destroy.apply(this, arguments);
  },
  clear: function() {
    var child;
    var root = this.vectorRoot;
    if (root) {
      while ((child = root.firstChild)) {
        root.removeChild(child);
      }
    }
    root = this.textRoot;
    if (root) {
      while ((child = root.firstChild)) {
        root.removeChild(child);
      }
    }
    if (this.indexer) {
      this.indexer.clear();
    }
  },
  setExtent: function(extent, resolutionChanged) {
    var coordSysUnchanged = OpenLayers.Renderer.prototype.setExtent.apply(
      this,
      arguments
    );
    var resolution = this.getResolution();
    if (this.map.baseLayer && this.map.baseLayer.wrapDateLine) {
      var rightOfDateLine,
        ratio = extent.getWidth() / this.map.getExtent().getWidth(),
        extent = extent.scale(1 / ratio),
        world = this.map.getMaxExtent();
      if (world.right > extent.left && world.right < extent.right) {
        rightOfDateLine = true;
      } else if (world.left > extent.left && world.left < extent.right) {
        rightOfDateLine = false;
      }
      if (rightOfDateLine !== this.rightOfDateLine || resolutionChanged) {
        coordSysUnchanged = false;
        this.xOffset =
          rightOfDateLine === true ? world.getWidth() / resolution : 0;
      }
      this.rightOfDateLine = rightOfDateLine;
    }
    return coordSysUnchanged;
  },
  getNodeType: function(geometry, style) {},
  drawGeometry: function(geometry, style, featureId) {
    var className = geometry.CLASS_NAME;
    var rendered = true;
    if (
      className == "OpenLayers.Geometry.Collection" ||
      className == "OpenLayers.Geometry.MultiPoint" ||
      className == "OpenLayers.Geometry.MultiLineString" ||
      className == "OpenLayers.Geometry.MultiPolygon"
    ) {
      for (var i = 0, len = geometry.components.length; i < len; i++) {
        rendered =
          this.drawGeometry(geometry.components[i], style, featureId) &&
          rendered;
      }
      return rendered;
    }
    rendered = false;
    var removeBackground = false;
    if (style.display != "none") {
      if (style.backgroundGraphic) {
        this.redrawBackgroundNode(geometry.id, geometry, style, featureId);
      } else {
        removeBackground = true;
      }
      rendered = this.redrawNode(geometry.id, geometry, style, featureId);
    }
    if (rendered == false) {
      var node = document.getElementById(geometry.id);
      if (node) {
        if (node._style.backgroundGraphic) {
          removeBackground = true;
        }
        node.parentNode.removeChild(node);
      }
    }
    if (removeBackground) {
      var node = document.getElementById(
        geometry.id + this.BACKGROUND_ID_SUFFIX
      );
      if (node) {
        node.parentNode.removeChild(node);
      }
    }
    return rendered;
  },
  redrawNode: function(id, geometry, style, featureId) {
    style = this.applyDefaultSymbolizer(style);
    var node = this.nodeFactory(id, this.getNodeType(geometry, style));
    node._featureId = featureId;
    node._boundsBottom = geometry.getBounds().bottom;
    node._geometryClass = geometry.CLASS_NAME;
    node._style = style;
    var drawResult = this.drawGeometryNode(node, geometry, style);
    if (drawResult === false) {
      return false;
    }
    node = drawResult.node;
    if (this.indexer) {
      var insert = this.indexer.insert(node);
      if (insert) {
        this.vectorRoot.insertBefore(node, insert);
      } else {
        this.vectorRoot.appendChild(node);
      }
    } else {
      if (node.parentNode !== this.vectorRoot) {
        this.vectorRoot.appendChild(node);
      }
    }
    this.postDraw(node);
    return drawResult.complete;
  },
  redrawBackgroundNode: function(id, geometry, style, featureId) {
    var backgroundStyle = OpenLayers.Util.extend({}, style);
    backgroundStyle.externalGraphic = backgroundStyle.backgroundGraphic;
    backgroundStyle.graphicXOffset = backgroundStyle.backgroundXOffset;
    backgroundStyle.graphicYOffset = backgroundStyle.backgroundYOffset;
    backgroundStyle.graphicZIndex = backgroundStyle.backgroundGraphicZIndex;
    backgroundStyle.graphicWidth =
      backgroundStyle.backgroundWidth || backgroundStyle.graphicWidth;
    backgroundStyle.graphicHeight =
      backgroundStyle.backgroundHeight || backgroundStyle.graphicHeight;
    backgroundStyle.backgroundGraphic = null;
    backgroundStyle.backgroundXOffset = null;
    backgroundStyle.backgroundYOffset = null;
    backgroundStyle.backgroundGraphicZIndex = null;
    return this.redrawNode(
      id + this.BACKGROUND_ID_SUFFIX,
      geometry,
      backgroundStyle,
      null
    );
  },
  drawGeometryNode: function(node, geometry, style) {
    style = style || node._style;
    var options = {
      isFilled: style.fill === undefined ? true : style.fill,
      isStroked: style.stroke === undefined ? !!style.strokeWidth : style.stroke
    };
    var drawn;
    switch (geometry.CLASS_NAME) {
      case "OpenLayers.Geometry.Point":
        if (style.graphic === false) {
          options.isFilled = false;
          options.isStroked = false;
        }
        drawn = this.drawPoint(node, geometry);
        break;
      case "OpenLayers.Geometry.LineString":
        options.isFilled = false;
        drawn = this.drawLineString(node, geometry);
        break;
      case "OpenLayers.Geometry.LinearRing":
        drawn = this.drawLinearRing(node, geometry);
        break;
      case "OpenLayers.Geometry.Polygon":
        drawn = this.drawPolygon(node, geometry);
        break;
      case "OpenLayers.Geometry.Rectangle":
        drawn = this.drawRectangle(node, geometry);
        break;
      default:
        break;
    }
    node._options = options;
    if (drawn != false) {
      return {
        node: this.setStyle(node, style, options, geometry),
        complete: drawn
      };
    } else {
      return false;
    }
  },
  postDraw: function(node) {},
  drawPoint: function(node, geometry) {},
  drawLineString: function(node, geometry) {},
  drawLinearRing: function(node, geometry) {},
  drawPolygon: function(node, geometry) {},
  drawRectangle: function(node, geometry) {},
  drawCircle: function(node, geometry) {},
  removeText: function(featureId) {
    var label = document.getElementById(featureId + this.LABEL_ID_SUFFIX);
    if (label) {
      this.textRoot.removeChild(label);
    }
    var outline = document.getElementById(
      featureId + this.LABEL_OUTLINE_SUFFIX
    );
    if (outline) {
      this.textRoot.removeChild(outline);
    }
  },
  getFeatureIdFromEvent: function(evt) {
    var target = evt.target;
    var useElement = target && target.correspondingUseElement;
    var node = useElement ? useElement : target || evt.srcElement;
    return node._featureId;
  },
  eraseGeometry: function(geometry, featureId) {
    if (
      geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint" ||
      geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString" ||
      geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon" ||
      geometry.CLASS_NAME == "OpenLayers.Geometry.Collection"
    ) {
      for (var i = 0, len = geometry.components.length; i < len; i++) {
        this.eraseGeometry(geometry.components[i], featureId);
      }
    } else {
      var element = OpenLayers.Util.getElement(geometry.id);
      if (element && element.parentNode) {
        if (element.geometry) {
          element.geometry.destroy();
          element.geometry = null;
        }
        element.parentNode.removeChild(element);
        if (this.indexer) {
          this.indexer.remove(element);
        }
        if (element._style.backgroundGraphic) {
          var backgroundId = geometry.id + this.BACKGROUND_ID_SUFFIX;
          var bElem = OpenLayers.Util.getElement(backgroundId);
          if (bElem && bElem.parentNode) {
            bElem.parentNode.removeChild(bElem);
          }
        }
      }
    }
  },
  nodeFactory: function(id, type) {
    var node = OpenLayers.Util.getElement(id);
    if (node) {
      if (!this.nodeTypeCompare(node, type)) {
        node.parentNode.removeChild(node);
        node = this.nodeFactory(id, type);
      }
    } else {
      node = this.createNode(type, id);
    }
    return node;
  },
  nodeTypeCompare: function(node, type) {},
  createNode: function(type, id) {},
  moveRoot: function(renderer) {
    var root = this.root;
    if (renderer.root.parentNode == this.rendererRoot) {
      root = renderer.root;
    }
    root.parentNode.removeChild(root);
    renderer.rendererRoot.appendChild(root);
  },
  getRenderLayerId: function() {
    return this.root.parentNode.parentNode.id;
  },
  isComplexSymbol: function(graphicName) {
    return graphicName != "circle" && !!graphicName;
  },
  CLASS_NAME: "OpenLayers.Renderer.Elements"
});
OpenLayers.Control = OpenLayers.Class({
  id: null,
  map: null,
  div: null,
  type: null,
  allowSelection: false,
  displayClass: "",
  title: "",
  autoActivate: false,
  active: null,
  handler: null,
  eventListeners: null,
  events: null,
  initialize: function(options) {
    this.displayClass = this.CLASS_NAME.replace("OpenLayers.", "ol").replace(
      /\./g,
      ""
    );
    OpenLayers.Util.extend(this, options);
    this.events = new OpenLayers.Events(this);
    if (this.eventListeners instanceof Object) {
      this.events.on(this.eventListeners);
    }
    if (this.id == null) {
      this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
    }
  },
  destroy: function() {
    if (this.events) {
      if (this.eventListeners) {
        this.events.un(this.eventListeners);
      }
      this.events.destroy();
      this.events = null;
    }
    this.eventListeners = null;
    if (this.handler) {
      this.handler.destroy();
      this.handler = null;
    }
    if (this.handlers) {
      for (var key in this.handlers) {
        if (
          this.handlers.hasOwnProperty(key) &&
          typeof this.handlers[key].destroy == "function"
        ) {
          this.handlers[key].destroy();
        }
      }
      this.handlers = null;
    }
    if (this.map) {
      this.map.removeControl(this);
      this.map = null;
    }
    this.div = null;
  },
  setMap: function(map) {
    this.map = map;
    if (this.handler) {
      this.handler.setMap(map);
    }
  },
  draw: function(px) {
    if (this.div == null) {
      this.div = OpenLayers.Util.createDiv(this.id);
      this.div.className = this.displayClass;
      if (!this.allowSelection) {
        this.div.className += " olControlNoSelect";
        this.div.setAttribute("unselectable", "on", 0);
        this.div.onselectstart = OpenLayers.Function.False;
      }
      if (this.title != "") {
        this.div.title = this.title;
      }
    }
    if (px != null) {
      this.position = px.clone();
    }
    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.y + "px";
    }
  },
  activate: function() {
    if (this.active) {
      return false;
    }
    if (this.handler) {
      this.handler.activate();
    }
    this.active = true;
    if (this.map) {
      OpenLayers.Element.addClass(
        this.map.viewPortDiv,
        this.displayClass.replace(/ /g, "") + "Active"
      );
    }
    this.events.triggerEvent("activate");
    return true;
  },
  deactivate: function() {
    if (this.active) {
      if (this.handler) {
        this.handler.deactivate();
      }
      this.active = false;
      if (this.map) {
        OpenLayers.Element.removeClass(
          this.map.viewPortDiv,
          this.displayClass.replace(/ /g, "") + "Active"
        );
      }
      this.events.triggerEvent("deactivate");
      return true;
    }
    return false;
  },
  CLASS_NAME: "OpenLayers.Control"
});
OpenLayers.Control.TYPE_BUTTON = 1;
OpenLayers.Control.TYPE_TOGGLE = 2;
OpenLayers.Control.TYPE_TOOL = 3;
OpenLayers.Control.Panel = OpenLayers.Class(OpenLayers.Control, {
  controls: null,
  autoActivate: true,
  defaultControl: null,
  saveState: false,
  allowDepress: false,
  activeState: null,
  initialize: function(options) {
    OpenLayers.Control.prototype.initialize.apply(this, [options]);
    this.controls = [];
    this.activeState = {};
  },
  destroy: function() {
    if (this.map) {
      this.map.events.unregister("buttonclick", this, this.onButtonClick);
    }
    OpenLayers.Control.prototype.destroy.apply(this, arguments);
    for (var ctl, i = this.controls.length - 1; i >= 0; i--) {
      ctl = this.controls[i];
      if (ctl.events) {
        ctl.events.un({ activate: this.iconOn, deactivate: this.iconOff });
      }
      ctl.panel_div = null;
    }
    this.activeState = null;
  },
  activate: function() {
    if (OpenLayers.Control.prototype.activate.apply(this, arguments)) {
      var control;
      for (var i = 0, len = this.controls.length; i < len; i++) {
        control = this.controls[i];
        if (
          control === this.defaultControl ||
          (this.saveState && this.activeState[control.id])
        ) {
          control.activate();
        }
      }
      if (this.saveState === true) {
        this.defaultControl = null;
      }
      this.redraw();
      return true;
    } else {
      return false;
    }
  },
  deactivate: function() {
    if (OpenLayers.Control.prototype.deactivate.apply(this, arguments)) {
      var control;
      for (var i = 0, len = this.controls.length; i < len; i++) {
        control = this.controls[i];
        this.activeState[control.id] = control.deactivate();
      }
      this.redraw();
      return true;
    } else {
      return false;
    }
  },
  draw: function() {
    OpenLayers.Control.prototype.draw.apply(this, arguments);
    if (this.outsideViewport) {
      this.events.attachToElement(this.div);
      this.events.register("buttonclick", this, this.onButtonClick);
    } else {
      this.map.events.register("buttonclick", this, this.onButtonClick);
    }
    this.addControlsToMap(this.controls);
    return this.div;
  },
  redraw: function() {
    for (var l = this.div.childNodes.length, i = l - 1; i >= 0; i--) {
      this.div.removeChild(this.div.childNodes[i]);
    }
    this.div.innerHTML = "";
    if (this.active) {
      for (var i = 0, len = this.controls.length; i < len; i++) {
        this.div.appendChild(this.controls[i].panel_div);
      }
    }
  },
  activateControl: function(control) {
    if (!this.active) {
      return false;
    }
    if (control.type == OpenLayers.Control.TYPE_BUTTON) {
      control.trigger();
      return;
    }
    if (control.type == OpenLayers.Control.TYPE_TOGGLE) {
      if (control.active) {
        control.deactivate();
      } else {
        control.activate();
      }
      return;
    }
    if (this.allowDepress && control.active) {
      control.deactivate();
    } else {
      var c;
      for (var i = 0, len = this.controls.length; i < len; i++) {
        c = this.controls[i];
        if (
          c != control &&
          (c.type === OpenLayers.Control.TYPE_TOOL || c.type == null)
        ) {
          c.deactivate();
        }
      }
      control.activate();
    }
  },
  addControls: function(controls) {
    if (!OpenLayers.Util.isArray(controls)) {
      controls = [controls];
    }
    this.controls = this.controls.concat(controls);
    for (var i = 0, len = controls.length; i < len; i++) {
      var control = controls[i],
        element = this.createControlMarkup(control);
      OpenLayers.Element.addClass(
        element,
        control.displayClass + "ItemInactive"
      );
      OpenLayers.Element.addClass(element, "olButton");
      if (control.title != "" && !element.title) {
        element.title = control.title;
      }
      control.panel_div = element;
    }
    if (this.map) {
      this.addControlsToMap(controls);
      this.redraw();
    }
  },
  createControlMarkup: function(control) {
    return document.createElement("div");
  },
  addControlsToMap: function(controls) {
    var control;
    for (var i = 0, len = controls.length; i < len; i++) {
      control = controls[i];
      if (control.autoActivate === true) {
        control.autoActivate = false;
        this.map.addControl(control);
        control.autoActivate = true;
      } else {
        this.map.addControl(control);
        control.deactivate();
      }
      control.events.on({ activate: this.iconOn, deactivate: this.iconOff });
    }
  },
  iconOn: function() {
    var d = this.panel_div;
    var re = new RegExp("\\b(" + this.displayClass + "Item)Inactive\\b");
    d.className = d.className.replace(re, "$1Active");
  },
  iconOff: function() {
    var d = this.panel_div;
    var re = new RegExp("\\b(" + this.displayClass + "Item)Active\\b");
    d.className = d.className.replace(re, "$1Inactive");
  },
  onButtonClick: function(evt) {
    var controls = this.controls,
      button = evt.buttonElement;
    for (var i = controls.length - 1; i >= 0; --i) {
      if (controls[i].panel_div === button) {
        this.activateControl(controls[i]);
        break;
      }
    }
  },
  getControlsBy: function(property, match) {
    var test = typeof match.test == "function";
    var found = OpenLayers.Array.filter(this.controls, function(item) {
      return item[property] == match || (test && match.test(item[property]));
    });
    return found;
  },
  getControlsByName: function(match) {
    return this.getControlsBy("name", match);
  },
  getControlsByClass: function(match) {
    return this.getControlsBy("CLASS_NAME", match);
  },
  CLASS_NAME: "OpenLayers.Control.Panel"
});
OpenLayers.Strategy = OpenLayers.Class({
  layer: null,
  options: null,
  active: null,
  autoActivate: true,
  autoDestroy: true,
  initialize: function(options) {
    OpenLayers.Util.extend(this, options);
    this.options = options;
    this.active = false;
  },
  destroy: function() {
    this.deactivate();
    this.layer = null;
    this.options = null;
  },
  setLayer: function(layer) {
    this.layer = layer;
  },
  activate: function() {
    if (!this.active) {
      this.active = true;
      return true;
    }
    return false;
  },
  deactivate: function() {
    if (this.active) {
      this.active = false;
      return true;
    }
    return false;
  },
  CLASS_NAME: "OpenLayers.Strategy"
});
OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
  preload: false,
  activate: function() {
    if (OpenLayers.Strategy.prototype.activate.apply(this, arguments)) {
      this.layer.events.on({ refresh: this.load, scope: this });
      if (this.layer.visibility == true || this.preload) {
        this.load();
      } else {
        this.layer.events.on({ visibilitychanged: this.load, scope: this });
      }
      return true;
    }
    return false;
  },
  deactivate: function() {
    var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
    if (deactivated) {
      this.layer.events.un({
        refresh: this.load,
        visibilitychanged: this.load,
        scope: this
      });
    }
    return deactivated;
  },
  load: function(options) {
    var layer = this.layer;
    layer.events.triggerEvent("loadstart");
    layer.protocol.read(
      OpenLayers.Util.applyDefaults(
        {
          callback: OpenLayers.Function.bind(
            this.merge,
            this,
            layer.map.getProjectionObject()
          ),
          filter: layer.filter
        },
        options
      )
    );
    layer.events.un({ visibilitychanged: this.load, scope: this });
  },
  merge: function(mapProjection, resp) {
    var layer = this.layer;
    layer.destroyFeatures();
    var features = resp.features;
    if (features && features.length > 0) {
      if (!mapProjection.equals(layer.projection)) {
        var geom;
        for (var i = 0, len = features.length; i < len; ++i) {
          geom = features[i].geometry;
          if (geom) {
            geom.transform(layer.projection, mapProjection);
          }
        }
      }
      layer.addFeatures(features);
    }
    layer.events.triggerEvent("loadend");
  },
  CLASS_NAME: "OpenLayers.Strategy.Fixed"
});
OpenLayers.Control.Zoom = OpenLayers.Class(OpenLayers.Control, {
  zoomInText: "+",
  zoomInId: "olZoomInLink",
  zoomOutText: "-",
  zoomOutId: "olZoomOutLink",
  draw: function() {
    var div = OpenLayers.Control.prototype.draw.apply(this),
      links = this.getOrCreateLinks(div),
      zoomIn = links.zoomIn,
      zoomOut = links.zoomOut,
      eventsInstance = this.map.events;
    if (zoomOut.parentNode !== div) {
      eventsInstance = this.events;
      eventsInstance.attachToElement(zoomOut.parentNode);
    }
    eventsInstance.register("buttonclick", this, this.onZoomClick);
    this.zoomInLink = zoomIn;
    this.zoomOutLink = zoomOut;
    return div;
  },
  getOrCreateLinks: function(el) {
    var zoomIn = document.getElementById(this.zoomInId),
      zoomOut = document.getElementById(this.zoomOutId);
    if (!zoomIn) {
      zoomIn = document.createElement("a");
      zoomIn.href = "#zoomIn";
      zoomIn.appendChild(document.createTextNode(this.zoomInText));
      zoomIn.className = "olControlZoomIn";
      el.appendChild(zoomIn);
    }
    OpenLayers.Element.addClass(zoomIn, "olButton");
    if (!zoomOut) {
      zoomOut = document.createElement("a");
      zoomOut.href = "#zoomOut";
      zoomOut.appendChild(document.createTextNode(this.zoomOutText));
      zoomOut.className = "olControlZoomOut";
      el.appendChild(zoomOut);
    }
    OpenLayers.Element.addClass(zoomOut, "olButton");
    return { zoomIn: zoomIn, zoomOut: zoomOut };
  },
  onZoomClick: function(evt) {
    var button = evt.buttonElement;
    if (button === this.zoomInLink) {
      this.map.zoomIn();
    } else if (button === this.zoomOutLink) {
      this.map.zoomOut();
    }
  },
  destroy: function() {
    if (this.map) {
      this.map.events.unregister("buttonclick", this, this.onZoomClick);
    }
    delete this.zoomInLink;
    delete this.zoomOutLink;
    OpenLayers.Control.prototype.destroy.apply(this);
  },
  CLASS_NAME: "OpenLayers.Control.Zoom"
});
OpenLayers.Geometry.Polygon = OpenLayers.Class(OpenLayers.Geometry.Collection, {
  componentTypes: ["OpenLayers.Geometry.LinearRing"],
  getArea: function() {
    var area = 0.0;
    if (this.components && this.components.length > 0) {
      area += Math.abs(this.components[0].getArea());
      for (var i = 1, len = this.components.length; i < len; i++) {
        area -= Math.abs(this.components[i].getArea());
      }
    }
    return area;
  },
  getGeodesicArea: function(projection) {
    var area = 0.0;
    if (this.components && this.components.length > 0) {
      area += Math.abs(this.components[0].getGeodesicArea(projection));
      for (var i = 1, len = this.components.length; i < len; i++) {
        area -= Math.abs(this.components[i].getGeodesicArea(projection));
      }
    }
    return area;
  },
  containsPoint: function(point) {
    var numRings = this.components.length;
    var contained = false;
    if (numRings > 0) {
      contained = this.components[0].containsPoint(point);
      if (contained !== 1) {
        if (contained && numRings > 1) {
          var hole;
          for (var i = 1; i < numRings; ++i) {
            hole = this.components[i].containsPoint(point);
            if (hole) {
              if (hole === 1) {
                contained = 1;
              } else {
                contained = false;
              }
              break;
            }
          }
        }
      }
    }
    return contained;
  },
  intersects: function(geometry) {
    var intersect = false;
    var i, len;
    if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
      intersect = this.containsPoint(geometry);
    } else if (
      geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" ||
      geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing"
    ) {
      for (i = 0, len = this.components.length; i < len; ++i) {
        intersect = geometry.intersects(this.components[i]);
        if (intersect) {
          break;
        }
      }
      if (!intersect) {
        for (i = 0, len = geometry.components.length; i < len; ++i) {
          intersect = this.containsPoint(geometry.components[i]);
          if (intersect) {
            break;
          }
        }
      }
    } else {
      for (i = 0, len = geometry.components.length; i < len; ++i) {
        intersect = this.intersects(geometry.components[i]);
        if (intersect) {
          break;
        }
      }
    }
    if (!intersect && geometry.CLASS_NAME == "OpenLayers.Geometry.Polygon") {
      var ring = this.components[0];
      for (i = 0, len = ring.components.length; i < len; ++i) {
        intersect = geometry.containsPoint(ring.components[i]);
        if (intersect) {
          break;
        }
      }
    }
    return intersect;
  },
  distanceTo: function(geometry, options) {
    var edge = !(options && options.edge === false);
    var result;
    if (!edge && this.intersects(geometry)) {
      result = 0;
    } else {
      result = OpenLayers.Geometry.Collection.prototype.distanceTo.apply(this, [
        geometry,
        options
      ]);
    }
    return result;
  },
  CLASS_NAME: "OpenLayers.Geometry.Polygon"
});
OpenLayers.Geometry.Polygon.createRegularPolygon = function(
  origin,
  radius,
  sides,
  rotation
) {
  var angle = Math.PI * (1 / sides - 1 / 2);
  if (rotation) {
    angle += (rotation / 180) * Math.PI;
  }
  var rotatedAngle, x, y;
  var points = [];
  for (var i = 0; i < sides; ++i) {
    rotatedAngle = angle + (i * 2 * Math.PI) / sides;
    x = origin.x + radius * Math.cos(rotatedAngle);
    y = origin.y + radius * Math.sin(rotatedAngle);
    points.push(new OpenLayers.Geometry.Point(x, y));
  }
  var ring = new OpenLayers.Geometry.LinearRing(points);
  return new OpenLayers.Geometry.Polygon([ring]);
};
OpenLayers.Geometry.MultiPolygon = OpenLayers.Class(
  OpenLayers.Geometry.Collection,
  {
    componentTypes: ["OpenLayers.Geometry.Polygon"],
    CLASS_NAME: "OpenLayers.Geometry.MultiPolygon"
  }
);
OpenLayers.Feature = OpenLayers.Class({
  layer: null,
  id: null,
  lonlat: null,
  data: null,
  marker: null,
  popupClass: null,
  popup: null,
  initialize: function(layer, lonlat, data) {
    this.layer = layer;
    this.lonlat = lonlat;
    this.data = data != null ? data : {};
    this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
  },
  destroy: function() {
    if (this.layer != null && this.layer.map != null) {
      if (this.popup != null) {
        this.layer.map.removePopup(this.popup);
      }
    }
    if (this.layer != null && this.marker != null) {
      this.layer.removeMarker(this.marker);
    }
    this.layer = null;
    this.id = null;
    this.lonlat = null;
    this.data = null;
    if (this.marker != null) {
      this.destroyMarker(this.marker);
      this.marker = null;
    }
    if (this.popup != null) {
      this.destroyPopup(this.popup);
      this.popup = null;
    }
  },
  onScreen: function() {
    var onScreen = false;
    if (this.layer != null && this.layer.map != null) {
      var screenBounds = this.layer.map.getExtent();
      onScreen = screenBounds.containsLonLat(this.lonlat);
    }
    return onScreen;
  },
  createMarker: function() {
    if (this.lonlat != null) {
      this.marker = new OpenLayers.Marker(this.lonlat, this.data.icon);
    }
    return this.marker;
  },
  destroyMarker: function() {
    this.marker.destroy();
  },
  createPopup: function(closeBox) {
    if (this.lonlat != null) {
      if (!this.popup) {
        var anchor = this.marker ? this.marker.icon : null;
        var popupClass = this.popupClass
          ? this.popupClass
          : OpenLayers.Popup.Anchored;
        this.popup = new popupClass(
          this.id + "_popup",
          this.lonlat,
          this.data.popupSize,
          this.data.popupContentHTML,
          anchor,
          closeBox
        );
      }
      if (this.data.overflow != null) {
        this.popup.contentDiv.style.overflow = this.data.overflow;
      }
      this.popup.feature = this;
    }
    return this.popup;
  },
  destroyPopup: function() {
    if (this.popup) {
      this.popup.feature = null;
      this.popup.destroy();
      this.popup = null;
    }
  },
  CLASS_NAME: "OpenLayers.Feature"
});
OpenLayers.State = {
  UNKNOWN: "Unknown",
  INSERT: "Insert",
  UPDATE: "Update",
  DELETE: "Delete"
};
OpenLayers.Feature.Vector = OpenLayers.Class(OpenLayers.Feature, {
  fid: null,
  geometry: null,
  attributes: null,
  bounds: null,
  state: null,
  style: null,
  url: null,
  renderIntent: "default",
  modified: null,
  initialize: function(geometry, attributes, style) {
    OpenLayers.Feature.prototype.initialize.apply(this, [
      null,
      null,
      attributes
    ]);
    this.lonlat = null;
    this.geometry = geometry ? geometry : null;
    this.state = null;
    this.attributes = {};
    if (attributes) {
      this.attributes = OpenLayers.Util.extend(this.attributes, attributes);
    }
    this.style = style ? style : null;
  },
  destroy: function() {
    if (this.layer) {
      this.layer.removeFeatures(this);
      this.layer = null;
    }
    this.geometry = null;
    this.modified = null;
    OpenLayers.Feature.prototype.destroy.apply(this, arguments);
  },
  clone: function() {
    return new OpenLayers.Feature.Vector(
      this.geometry ? this.geometry.clone() : null,
      this.attributes,
      this.style
    );
  },
  onScreen: function(boundsOnly) {
    var onScreen = false;
    if (this.layer && this.layer.map) {
      var screenBounds = this.layer.map.getExtent();
      if (boundsOnly) {
        var featureBounds = this.geometry.getBounds();
        onScreen = screenBounds.intersectsBounds(featureBounds);
      } else {
        var screenPoly = screenBounds.toGeometry();
        onScreen = screenPoly.intersects(this.geometry);
      }
    }
    return onScreen;
  },
  getVisibility: function() {
    return !(
      (this.style && this.style.display == "none") ||
      !this.layer ||
      (this.layer &&
        this.layer.styleMap &&
        this.layer.styleMap.createSymbolizer(this, this.renderIntent).display ==
          "none") ||
      (this.layer && !this.layer.getVisibility())
    );
  },
  createMarker: function() {
    return null;
  },
  destroyMarker: function() {},
  createPopup: function() {
    return null;
  },
  atPoint: function(lonlat, toleranceLon, toleranceLat) {
    var atPoint = false;
    if (this.geometry) {
      atPoint = this.geometry.atPoint(lonlat, toleranceLon, toleranceLat);
    }
    return atPoint;
  },
  destroyPopup: function() {},
  move: function(location) {
    if (!this.layer || !this.geometry.move) {
      return undefined;
    }
    var pixel;
    if (location.CLASS_NAME == "OpenLayers.LonLat") {
      pixel = this.layer.getViewPortPxFromLonLat(location);
    } else {
      pixel = location;
    }
    var lastPixel = this.layer.getViewPortPxFromLonLat(
      this.geometry.getBounds().getCenterLonLat()
    );
    var res = this.layer.map.getResolution();
    this.geometry.move(
      res * (pixel.x - lastPixel.x),
      res * (lastPixel.y - pixel.y)
    );
    this.layer.drawFeature(this);
    return lastPixel;
  },
  toState: function(state) {
    if (state == OpenLayers.State.UPDATE) {
      switch (this.state) {
        case OpenLayers.State.UNKNOWN:
        case OpenLayers.State.DELETE:
          this.state = state;
          break;
        case OpenLayers.State.UPDATE:
        case OpenLayers.State.INSERT:
          break;
      }
    } else if (state == OpenLayers.State.INSERT) {
      switch (this.state) {
        case OpenLayers.State.UNKNOWN:
          break;
        default:
          this.state = state;
          break;
      }
    } else if (state == OpenLayers.State.DELETE) {
      switch (this.state) {
        case OpenLayers.State.INSERT:
          break;
        case OpenLayers.State.DELETE:
          break;
        case OpenLayers.State.UNKNOWN:
        case OpenLayers.State.UPDATE:
          this.state = state;
          break;
      }
    } else if (state == OpenLayers.State.UNKNOWN) {
      this.state = state;
    }
  },
  CLASS_NAME: "OpenLayers.Feature.Vector"
});
OpenLayers.Feature.Vector.style = {
  default: {
    fillColor: "#ee9900",
    fillOpacity: 0.4,
    hoverFillColor: "white",
    hoverFillOpacity: 0.8,
    strokeColor: "#ee9900",
    strokeOpacity: 1,
    strokeWidth: 1,
    strokeLinecap: "round",
    strokeDashstyle: "solid",
    hoverStrokeColor: "red",
    hoverStrokeOpacity: 1,
    hoverStrokeWidth: 0.2,
    pointRadius: 6,
    hoverPointRadius: 1,
    hoverPointUnit: "%",
    pointerEvents: "visiblePainted",
    cursor: "inherit",
    fontColor: "#000000",
    labelAlign: "cm",
    labelOutlineColor: "white",
    labelOutlineWidth: 3
  },
  select: {
    fillColor: "blue",
    fillOpacity: 0.4,
    hoverFillColor: "white",
    hoverFillOpacity: 0.8,
    strokeColor: "blue",
    strokeOpacity: 1,
    strokeWidth: 2,
    strokeLinecap: "round",
    strokeDashstyle: "solid",
    hoverStrokeColor: "red",
    hoverStrokeOpacity: 1,
    hoverStrokeWidth: 0.2,
    pointRadius: 6,
    hoverPointRadius: 1,
    hoverPointUnit: "%",
    pointerEvents: "visiblePainted",
    cursor: "pointer",
    fontColor: "#000000",
    labelAlign: "cm",
    labelOutlineColor: "white",
    labelOutlineWidth: 3
  },
  temporary: {
    fillColor: "#66cccc",
    fillOpacity: 0.2,
    hoverFillColor: "white",
    hoverFillOpacity: 0.8,
    strokeColor: "#66cccc",
    strokeOpacity: 1,
    strokeLinecap: "round",
    strokeWidth: 2,
    strokeDashstyle: "solid",
    hoverStrokeColor: "red",
    hoverStrokeOpacity: 1,
    hoverStrokeWidth: 0.2,
    pointRadius: 6,
    hoverPointRadius: 1,
    hoverPointUnit: "%",
    pointerEvents: "visiblePainted",
    cursor: "inherit",
    fontColor: "#000000",
    labelAlign: "cm",
    labelOutlineColor: "white",
    labelOutlineWidth: 3
  },
  delete: { display: "none" }
};
OpenLayers.Style = OpenLayers.Class({
  id: null,
  name: null,
  title: null,
  description: null,
  layerName: null,
  isDefault: false,
  rules: null,
  context: null,
  defaultStyle: null,
  defaultsPerSymbolizer: false,
  propertyStyles: null,
  initialize: function(style, options) {
    OpenLayers.Util.extend(this, options);
    this.rules = [];
    if (options && options.rules) {
      this.addRules(options.rules);
    }
    this.setDefaultStyle(style || OpenLayers.Feature.Vector.style["default"]);
    this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
  },
  destroy: function() {
    for (var i = 0, len = this.rules.length; i < len; i++) {
      this.rules[i].destroy();
      this.rules[i] = null;
    }
    this.rules = null;
    this.defaultStyle = null;
  },
  createSymbolizer: function(feature) {
    var style = this.defaultsPerSymbolizer
      ? {}
      : this.createLiterals(
          OpenLayers.Util.extend({}, this.defaultStyle),
          feature
        );
    var rules = this.rules;
    var rule, context;
    var elseRules = [];
    var appliedRules = false;
    for (var i = 0, len = rules.length; i < len; i++) {
      rule = rules[i];
      var applies = rule.evaluate(feature);
      if (applies) {
        if (rule instanceof OpenLayers.Rule && rule.elseFilter) {
          elseRules.push(rule);
        } else {
          appliedRules = true;
          this.applySymbolizer(rule, style, feature);
        }
      }
    }
    if (appliedRules == false && elseRules.length > 0) {
      appliedRules = true;
      for (var i = 0, len = elseRules.length; i < len; i++) {
        this.applySymbolizer(elseRules[i], style, feature);
      }
    }
    if (rules.length > 0 && appliedRules == false) {
      style.display = "none";
    }
    if (style.label != null && typeof style.label !== "string") {
      style.label = String(style.label);
    }
    return style;
  },
  applySymbolizer: function(rule, style, feature) {
    var symbolizerPrefix = feature.geometry
      ? this.getSymbolizerPrefix(feature.geometry)
      : OpenLayers.Style.SYMBOLIZER_PREFIXES[0];
    var symbolizer = rule.symbolizer[symbolizerPrefix] || rule.symbolizer;
    if (this.defaultsPerSymbolizer === true) {
      var defaults = this.defaultStyle;
      OpenLayers.Util.applyDefaults(symbolizer, {
        pointRadius: defaults.pointRadius
      });
      if (symbolizer.stroke === true || symbolizer.graphic === true) {
        OpenLayers.Util.applyDefaults(symbolizer, {
          strokeWidth: defaults.strokeWidth,
          strokeColor: defaults.strokeColor,
          strokeOpacity: defaults.strokeOpacity,
          strokeDashstyle: defaults.strokeDashstyle,
          strokeLinecap: defaults.strokeLinecap
        });
      }
      if (symbolizer.fill === true || symbolizer.graphic === true) {
        OpenLayers.Util.applyDefaults(symbolizer, {
          fillColor: defaults.fillColor,
          fillOpacity: defaults.fillOpacity
        });
      }
      if (symbolizer.graphic === true) {
        OpenLayers.Util.applyDefaults(symbolizer, {
          pointRadius: this.defaultStyle.pointRadius,
          externalGraphic: this.defaultStyle.externalGraphic,
          graphicName: this.defaultStyle.graphicName,
          graphicOpacity: this.defaultStyle.graphicOpacity,
          graphicWidth: this.defaultStyle.graphicWidth,
          graphicHeight: this.defaultStyle.graphicHeight,
          graphicXOffset: this.defaultStyle.graphicXOffset,
          graphicYOffset: this.defaultStyle.graphicYOffset
        });
      }
    }
    return this.createLiterals(
      OpenLayers.Util.extend(style, symbolizer),
      feature
    );
  },
  createLiterals: function(style, feature) {
    var context = OpenLayers.Util.extend(
      {},
      feature.attributes || feature.data
    );
    OpenLayers.Util.extend(context, this.context);
    for (var i in this.propertyStyles) {
      style[i] = OpenLayers.Style.createLiteral(style[i], context, feature, i);
    }
    return style;
  },
  findPropertyStyles: function() {
    var propertyStyles = {};
    var style = this.defaultStyle;
    this.addPropertyStyles(propertyStyles, style);
    var rules = this.rules;
    var symbolizer, value;
    for (var i = 0, len = rules.length; i < len; i++) {
      symbolizer = rules[i].symbolizer;
      for (var key in symbolizer) {
        value = symbolizer[key];
        if (typeof value == "object") {
          this.addPropertyStyles(propertyStyles, value);
        } else {
          this.addPropertyStyles(propertyStyles, symbolizer);
          break;
        }
      }
    }
    return propertyStyles;
  },
  addPropertyStyles: function(propertyStyles, symbolizer) {
    var property;
    for (var key in symbolizer) {
      property = symbolizer[key];
      if (typeof property == "string" && property.match(/\$\{\w+\}/)) {
        propertyStyles[key] = true;
      }
    }
    return propertyStyles;
  },
  addRules: function(rules) {
    Array.prototype.push.apply(this.rules, rules);
    this.propertyStyles = this.findPropertyStyles();
  },
  setDefaultStyle: function(style) {
    this.defaultStyle = style;
    this.propertyStyles = this.findPropertyStyles();
  },
  getSymbolizerPrefix: function(geometry) {
    var prefixes = OpenLayers.Style.SYMBOLIZER_PREFIXES;
    for (var i = 0, len = prefixes.length; i < len; i++) {
      if (geometry.CLASS_NAME.indexOf(prefixes[i]) != -1) {
        return prefixes[i];
      }
    }
  },
  clone: function() {
    var options = OpenLayers.Util.extend({}, this);
    if (this.rules) {
      options.rules = [];
      for (var i = 0, len = this.rules.length; i < len; ++i) {
        options.rules.push(this.rules[i].clone());
      }
    }
    options.context = this.context && OpenLayers.Util.extend({}, this.context);
    var defaultStyle = OpenLayers.Util.extend({}, this.defaultStyle);
    return new OpenLayers.Style(defaultStyle, options);
  },
  CLASS_NAME: "OpenLayers.Style"
});
OpenLayers.Style.createLiteral = function(value, context, feature, property) {
  if (typeof value == "string" && value.indexOf("${") != -1) {
    value = OpenLayers.String.format(value, context, [feature, property]);
    value = isNaN(value) || !value ? value : parseFloat(value);
  }
  return value;
};
OpenLayers.Style.SYMBOLIZER_PREFIXES = [
  "Point",
  "Line",
  "Polygon",
  "Text",
  "Raster"
];
OpenLayers.Filter = OpenLayers.Class({
  initialize: function(options) {
    OpenLayers.Util.extend(this, options);
  },
  destroy: function() {},
  evaluate: function(context) {
    return true;
  },
  clone: function() {
    return null;
  },
  toString: function() {
    var string;
    if (OpenLayers.Format && OpenLayers.Format.CQL) {
      string = OpenLayers.Format.CQL.prototype.write(this);
    } else {
      string = Object.prototype.toString.call(this);
    }
    return string;
  },
  CLASS_NAME: "OpenLayers.Filter"
});
OpenLayers.Filter.Spatial = OpenLayers.Class(OpenLayers.Filter, {
  type: null,
  property: null,
  value: null,
  distance: null,
  distanceUnits: null,
  evaluate: function(feature) {
    var intersect = false;
    switch (this.type) {
      case OpenLayers.Filter.Spatial.BBOX:
      case OpenLayers.Filter.Spatial.INTERSECTS:
        if (feature.geometry) {
          var geom = this.value;
          if (this.value.CLASS_NAME == "OpenLayers.Bounds") {
            geom = this.value.toGeometry();
          }
          if (feature.geometry.intersects(geom)) {
            intersect = true;
          }
        }
        break;
      default:
        throw new Error("evaluate is not implemented for this filter type.");
    }
    return intersect;
  },
  clone: function() {
    var options = OpenLayers.Util.applyDefaults(
      { value: this.value && this.value.clone && this.value.clone() },
      this
    );
    return new OpenLayers.Filter.Spatial(options);
  },
  CLASS_NAME: "OpenLayers.Filter.Spatial"
});
OpenLayers.Filter.Spatial.BBOX = "BBOX";
OpenLayers.Filter.Spatial.INTERSECTS = "INTERSECTS";
OpenLayers.Filter.Spatial.DWITHIN = "DWITHIN";
OpenLayers.Filter.Spatial.WITHIN = "WITHIN";
OpenLayers.Filter.Spatial.CONTAINS = "CONTAINS";
OpenLayers.Strategy.BBOX = OpenLayers.Class(OpenLayers.Strategy, {
  bounds: null,
  resolution: null,
  ratio: 2,
  resFactor: null,
  response: null,
  activate: function() {
    var activated = OpenLayers.Strategy.prototype.activate.call(this);
    if (activated) {
      this.layer.events.on({
        moveend: this.update,
        refresh: this.update,
        visibilitychanged: this.update,
        scope: this
      });
      this.update();
    }
    return activated;
  },
  deactivate: function() {
    var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
    if (deactivated) {
      this.layer.events.un({
        moveend: this.update,
        refresh: this.update,
        visibilitychanged: this.update,
        scope: this
      });
    }
    return deactivated;
  },
  update: function(options) {
    var mapBounds = this.getMapBounds();
    if (
      mapBounds !== null &&
      ((options && options.force) ||
        (this.layer.visibility &&
          this.layer.calculateInRange() &&
          this.invalidBounds(mapBounds)))
    ) {
      this.calculateBounds(mapBounds);
      this.resolution = this.layer.map.getResolution();
      this.triggerRead(options);
    }
  },
  getMapBounds: function() {
    if (this.layer.map === null) {
      return null;
    }
    var bounds = this.layer.map.getExtent();
    if (
      bounds &&
      !this.layer.projection.equals(this.layer.map.getProjectionObject())
    ) {
      bounds = bounds
        .clone()
        .transform(this.layer.map.getProjectionObject(), this.layer.projection);
    }
    return bounds;
  },
  invalidBounds: function(mapBounds) {
    if (!mapBounds) {
      mapBounds = this.getMapBounds();
    }
    var invalid = !this.bounds || !this.bounds.containsBounds(mapBounds);
    if (!invalid && this.resFactor) {
      var ratio = this.resolution / this.layer.map.getResolution();
      invalid = ratio >= this.resFactor || ratio <= 1 / this.resFactor;
    }
    return invalid;
  },
  calculateBounds: function(mapBounds) {
    if (!mapBounds) {
      mapBounds = this.getMapBounds();
    }
    var center = mapBounds.getCenterLonLat();
    var dataWidth = mapBounds.getWidth() * this.ratio;
    var dataHeight = mapBounds.getHeight() * this.ratio;
    this.bounds = new OpenLayers.Bounds(
      center.lon - dataWidth / 2,
      center.lat - dataHeight / 2,
      center.lon + dataWidth / 2,
      center.lat + dataHeight / 2
    );
  },
  triggerRead: function(options) {
    if (this.response && !(options && options.noAbort === true)) {
      this.layer.protocol.abort(this.response);
      this.layer.events.triggerEvent("loadend");
    }
    this.layer.events.triggerEvent("loadstart");
    this.response = this.layer.protocol.read(
      OpenLayers.Util.applyDefaults(
        { filter: this.createFilter(), callback: this.merge, scope: this },
        options
      )
    );
  },
  createFilter: function() {
    var filter = new OpenLayers.Filter.Spatial({
      type: OpenLayers.Filter.Spatial.BBOX,
      value: this.bounds,
      projection: this.layer.projection
    });
    if (this.layer.filter) {
      filter = new OpenLayers.Filter.Logical({
        type: OpenLayers.Filter.Logical.AND,
        filters: [this.layer.filter, filter]
      });
    }
    return filter;
  },
  merge: function(resp) {
    this.layer.destroyFeatures();
    var features = resp.features;
    if (features && features.length > 0) {
      var remote = this.layer.projection;
      var local = this.layer.map.getProjectionObject();
      if (!local.equals(remote)) {
        var geom;
        for (var i = 0, len = features.length; i < len; ++i) {
          geom = features[i].geometry;
          if (geom) {
            geom.transform(remote, local);
          }
        }
      }
      this.layer.addFeatures(features);
    }
    this.response = null;
    this.layer.events.triggerEvent("loadend");
  },
  CLASS_NAME: "OpenLayers.Strategy.BBOX"
});
OpenLayers.Handler.Feature = OpenLayers.Class(OpenLayers.Handler, {
  EVENTMAP: {
    click: { in: "click", out: "clickout" },
    mousemove: { in: "over", out: "out" },
    dblclick: { in: "dblclick", out: null },
    mousedown: { in: null, out: null },
    mouseup: { in: null, out: null },
    touchstart: { in: "click", out: "clickout" }
  },
  feature: null,
  lastFeature: null,
  down: null,
  up: null,
  touch: false,
  clickTolerance: 4,
  geometryTypes: null,
  stopClick: true,
  stopDown: true,
  stopUp: false,
  initialize: function(control, layer, callbacks, options) {
    OpenLayers.Handler.prototype.initialize.apply(this, [
      control,
      callbacks,
      options
    ]);
    this.layer = layer;
  },
  touchstart: function(evt) {
    if (!this.touch) {
      this.touch = true;
      this.map.events.un({
        mousedown: this.mousedown,
        mouseup: this.mouseup,
        mousemove: this.mousemove,
        click: this.click,
        dblclick: this.dblclick,
        scope: this
      });
    }
    return OpenLayers.Event.isMultiTouch(evt) ? true : this.mousedown(evt);
  },
  touchmove: function(evt) {
    OpenLayers.Event.stop(evt);
  },
  mousedown: function(evt) {
    if (
      OpenLayers.Event.isLeftClick(evt) ||
      OpenLayers.Event.isSingleTouch(evt)
    ) {
      this.down = evt.xy;
    }
    return this.handle(evt) ? !this.stopDown : true;
  },
  mouseup: function(evt) {
    this.up = evt.xy;
    return this.handle(evt) ? !this.stopUp : true;
  },
  click: function(evt) {
    return this.handle(evt) ? !this.stopClick : true;
  },
  mousemove: function(evt) {
    if (!this.callbacks["over"] && !this.callbacks["out"]) {
      return true;
    }
    this.handle(evt);
    return true;
  },
  dblclick: function(evt) {
    return !this.handle(evt);
  },
  geometryTypeMatches: function(feature) {
    return (
      this.geometryTypes == null ||
      OpenLayers.Util.indexOf(this.geometryTypes, feature.geometry.CLASS_NAME) >
        -1
    );
  },
  handle: function(evt) {
    if (this.feature && !this.feature.layer) {
      this.feature = null;
    }
    var type = evt.type;
    var handled = false;
    var previouslyIn = !!this.feature;
    var click = type == "click" || type == "dblclick" || type == "touchstart";
    this.feature = this.layer.getFeatureFromEvent(evt);
    if (this.feature && !this.feature.layer) {
      this.feature = null;
    }
    if (this.lastFeature && !this.lastFeature.layer) {
      this.lastFeature = null;
    }
    if (this.feature) {
      if (type === "touchstart") {
        OpenLayers.Event.stop(evt);
      }
      var inNew = this.feature != this.lastFeature;
      if (this.geometryTypeMatches(this.feature)) {
        if (previouslyIn && inNew) {
          if (this.lastFeature) {
            this.triggerCallback(type, "out", [this.lastFeature]);
          }
          this.triggerCallback(type, "in", [this.feature]);
        } else if (!previouslyIn || click) {
          this.triggerCallback(type, "in", [this.feature]);
        }
        this.lastFeature = this.feature;
        handled = true;
      } else {
        if (this.lastFeature && ((previouslyIn && inNew) || click)) {
          this.triggerCallback(type, "out", [this.lastFeature]);
        }
        this.feature = null;
      }
    } else {
      if (this.lastFeature && (previouslyIn || click)) {
        this.triggerCallback(type, "out", [this.lastFeature]);
      }
    }
    return handled;
  },
  triggerCallback: function(type, mode, args) {
    var key = this.EVENTMAP[type][mode];
    if (key) {
      if (type == "click" && this.up && this.down) {
        var dpx = Math.sqrt(
          Math.pow(this.up.x - this.down.x, 2) +
            Math.pow(this.up.y - this.down.y, 2)
        );
        if (dpx <= this.clickTolerance) {
          this.callback(key, args);
        }
      } else {
        this.callback(key, args);
      }
    }
  },
  activate: function() {
    var activated = false;
    if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
      this.moveLayerToTop();
      this.map.events.on({
        removelayer: this.handleMapEvents,
        changelayer: this.handleMapEvents,
        scope: this
      });
      activated = true;
    }
    return activated;
  },
  deactivate: function() {
    var deactivated = false;
    if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
      this.moveLayerBack();
      this.feature = null;
      this.lastFeature = null;
      this.down = null;
      this.up = null;
      this.touch = false;
      this.map.events.un({
        removelayer: this.handleMapEvents,
        changelayer: this.handleMapEvents,
        scope: this
      });
      deactivated = true;
    }
    return deactivated;
  },
  handleMapEvents: function(evt) {
    if (evt.type == "removelayer" || evt.property == "order") {
      this.moveLayerToTop();
    }
  },
  moveLayerToTop: function() {
    var index =
      Math.max(this.map.Z_INDEX_BASE["Feature"] - 1, this.layer.getZIndex()) +
      1;
    this.layer.setZIndex(index);
  },
  moveLayerBack: function() {
    var index = this.layer.getZIndex() - 1;
    if (index >= this.map.Z_INDEX_BASE["Feature"]) {
      this.layer.setZIndex(index);
    } else {
      this.map.setLayerZIndex(this.layer, this.map.getLayerIndex(this.layer));
    }
  },
  CLASS_NAME: "OpenLayers.Handler.Feature"
});
OpenLayers.StyleMap = OpenLayers.Class({
  styles: null,
  extendDefault: true,
  initialize: function(style, options) {
    this.styles = {
      default: new OpenLayers.Style(OpenLayers.Feature.Vector.style["default"]),
      select: new OpenLayers.Style(OpenLayers.Feature.Vector.style["select"]),
      temporary: new OpenLayers.Style(
        OpenLayers.Feature.Vector.style["temporary"]
      ),
      delete: new OpenLayers.Style(OpenLayers.Feature.Vector.style["delete"])
    };
    if (style instanceof OpenLayers.Style) {
      this.styles["default"] = style;
      this.styles["select"] = style;
      this.styles["temporary"] = style;
      this.styles["delete"] = style;
    } else if (typeof style == "object") {
      for (var key in style) {
        if (style[key] instanceof OpenLayers.Style) {
          this.styles[key] = style[key];
        } else if (typeof style[key] == "object") {
          this.styles[key] = new OpenLayers.Style(style[key]);
        } else {
          this.styles["default"] = new OpenLayers.Style(style);
          this.styles["select"] = new OpenLayers.Style(style);
          this.styles["temporary"] = new OpenLayers.Style(style);
          this.styles["delete"] = new OpenLayers.Style(style);
          break;
        }
      }
    }
    OpenLayers.Util.extend(this, options);
  },
  destroy: function() {
    for (var key in this.styles) {
      this.styles[key].destroy();
    }
    this.styles = null;
  },
  createSymbolizer: function(feature, intent) {
    if (!feature) {
      feature = new OpenLayers.Feature.Vector();
    }
    if (!this.styles[intent]) {
      intent = "default";
    }
    feature.renderIntent = intent;
    var defaultSymbolizer = {};
    if (this.extendDefault && intent != "default") {
      defaultSymbolizer = this.styles["default"].createSymbolizer(feature);
    }
    return OpenLayers.Util.extend(
      defaultSymbolizer,
      this.styles[intent].createSymbolizer(feature)
    );
  },
  addUniqueValueRules: function(renderIntent, property, symbolizers, context) {
    var rules = [];
    for (var value in symbolizers) {
      rules.push(
        new OpenLayers.Rule({
          symbolizer: symbolizers[value],
          context: context,
          filter: new OpenLayers.Filter.Comparison({
            type: OpenLayers.Filter.Comparison.EQUAL_TO,
            property: property,
            value: value
          })
        })
      );
    }
    this.styles[renderIntent].addRules(rules);
  },
  CLASS_NAME: "OpenLayers.StyleMap"
});
OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
  isBaseLayer: false,
  isFixed: false,
  features: null,
  filter: null,
  selectedFeatures: null,
  unrenderedFeatures: null,
  reportError: true,
  style: null,
  styleMap: null,
  strategies: null,
  protocol: null,
  renderers: ["SVG", "VML", "Canvas"],
  renderer: null,
  rendererOptions: null,
  geometryType: null,
  drawn: false,
  ratio: 1,
  initialize: function(name, options) {
    OpenLayers.Layer.prototype.initialize.apply(this, arguments);
    if (!this.renderer || !this.renderer.supported()) {
      this.assignRenderer();
    }
    if (!this.renderer || !this.renderer.supported()) {
      this.renderer = null;
      this.displayError();
    }
    if (!this.styleMap) {
      this.styleMap = new OpenLayers.StyleMap();
    }
    this.features = [];
    this.selectedFeatures = [];
    this.unrenderedFeatures = {};
    if (this.strategies) {
      for (var i = 0, len = this.strategies.length; i < len; i++) {
        this.strategies[i].setLayer(this);
      }
    }
  },
  destroy: function() {
    if (this.strategies) {
      var strategy, i, len;
      for (i = 0, len = this.strategies.length; i < len; i++) {
        strategy = this.strategies[i];
        if (strategy.autoDestroy) {
          strategy.destroy();
        }
      }
      this.strategies = null;
    }
    if (this.protocol) {
      if (this.protocol.autoDestroy) {
        this.protocol.destroy();
      }
      this.protocol = null;
    }
    this.destroyFeatures();
    this.features = null;
    this.selectedFeatures = null;
    this.unrenderedFeatures = null;
    if (this.renderer) {
      this.renderer.destroy();
    }
    this.renderer = null;
    this.geometryType = null;
    this.drawn = null;
    OpenLayers.Layer.prototype.destroy.apply(this, arguments);
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.Vector(this.name, this.getOptions());
    }
    obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]);
    var features = this.features;
    var len = features.length;
    var clonedFeatures = new Array(len);
    for (var i = 0; i < len; ++i) {
      clonedFeatures[i] = features[i].clone();
    }
    obj.features = clonedFeatures;
    return obj;
  },
  refresh: function(obj) {
    if (this.calculateInRange() && this.visibility) {
      this.events.triggerEvent("refresh", obj);
    }
  },
  assignRenderer: function() {
    for (var i = 0, len = this.renderers.length; i < len; i++) {
      var rendererClass = this.renderers[i];
      var renderer =
        typeof rendererClass == "function"
          ? rendererClass
          : OpenLayers.Renderer[rendererClass];
      if (renderer && renderer.prototype.supported()) {
        this.renderer = new renderer(this.div, this.rendererOptions);
        break;
      }
    }
  },
  displayError: function() {
    if (this.reportError) {
      OpenLayers.Console.userError(
        OpenLayers.i18n("browserNotSupported", {
          renderers: this.renderers.join("\n")
        })
      );
    }
  },
  setMap: function(map) {
    OpenLayers.Layer.prototype.setMap.apply(this, arguments);
    if (!this.renderer) {
      this.map.removeLayer(this);
    } else {
      this.renderer.map = this.map;
      var newSize = this.map.getSize();
      newSize.w = newSize.w * this.ratio;
      newSize.h = newSize.h * this.ratio;
      this.renderer.setSize(newSize);
    }
  },
  afterAdd: function() {
    if (this.strategies) {
      var strategy, i, len;
      for (i = 0, len = this.strategies.length; i < len; i++) {
        strategy = this.strategies[i];
        if (strategy.autoActivate) {
          strategy.activate();
        }
      }
    }
  },
  removeMap: function(map) {
    this.drawn = false;
    if (this.strategies) {
      var strategy, i, len;
      for (i = 0, len = this.strategies.length; i < len; i++) {
        strategy = this.strategies[i];
        if (strategy.autoActivate) {
          strategy.deactivate();
        }
      }
    }
  },
  onMapResize: function() {
    OpenLayers.Layer.prototype.onMapResize.apply(this, arguments);
    var newSize = this.map.getSize();
    newSize.w = newSize.w * this.ratio;
    newSize.h = newSize.h * this.ratio;
    this.renderer.setSize(newSize);
  },
  moveTo: function(bounds, zoomChanged, dragging) {
    OpenLayers.Layer.prototype.moveTo.apply(this, arguments);
    var coordSysUnchanged = true;
    if (!dragging) {
      this.renderer.root.style.visibility = "hidden";
      var viewSize = this.map.getSize(),
        viewWidth = viewSize.w,
        viewHeight = viewSize.h,
        offsetLeft = (viewWidth / 2) * this.ratio - viewWidth / 2,
        offsetTop = (viewHeight / 2) * this.ratio - viewHeight / 2;
      offsetLeft += parseInt(this.map.layerContainerDiv.style.left, 10);
      offsetLeft = -Math.round(offsetLeft);
      offsetTop += parseInt(this.map.layerContainerDiv.style.top, 10);
      offsetTop = -Math.round(offsetTop);
      this.div.style.left = offsetLeft + "px";
      this.div.style.top = offsetTop + "px";
      var extent = this.map.getExtent().scale(this.ratio);
      coordSysUnchanged = this.renderer.setExtent(extent, zoomChanged);
      this.renderer.root.style.visibility = "visible";
      if (OpenLayers.IS_GECKO === true) {
        this.div.scrollLeft = this.div.scrollLeft;
      }
      if (!zoomChanged && coordSysUnchanged) {
        for (var i in this.unrenderedFeatures) {
          var feature = this.unrenderedFeatures[i];
          this.drawFeature(feature);
        }
      }
    }
    if (!this.drawn || zoomChanged || !coordSysUnchanged) {
      this.drawn = true;
      var feature;
      for (var i = 0, len = this.features.length; i < len; i++) {
        this.renderer.locked = i !== len - 1;
        feature = this.features[i];
        this.drawFeature(feature);
      }
    }
  },
  display: function(display) {
    OpenLayers.Layer.prototype.display.apply(this, arguments);
    var currentDisplay = this.div.style.display;
    if (currentDisplay != this.renderer.root.style.display) {
      this.renderer.root.style.display = currentDisplay;
    }
  },
  addFeatures: function(features, options) {
    if (!OpenLayers.Util.isArray(features)) {
      features = [features];
    }
    var notify = !options || !options.silent;
    if (notify) {
      var event = { features: features };
      var ret = this.events.triggerEvent("beforefeaturesadded", event);
      if (ret === false) {
        return;
      }
      features = event.features;
    }
    var featuresAdded = [];
    for (var i = 0, len = features.length; i < len; i++) {
      if (i != features.length - 1) {
        this.renderer.locked = true;
      } else {
        this.renderer.locked = false;
      }
      var feature = features[i];
      if (
        this.geometryType &&
        !(feature.geometry instanceof this.geometryType)
      ) {
        throw new TypeError(
          "addFeatures: component should be an " +
            this.geometryType.prototype.CLASS_NAME
        );
      }
      feature.layer = this;
      if (!feature.style && this.style) {
        feature.style = OpenLayers.Util.extend({}, this.style);
      }
      if (notify) {
        if (
          this.events.triggerEvent("beforefeatureadded", {
            feature: feature
          }) === false
        ) {
          continue;
        }
        this.preFeatureInsert(feature);
      }
      featuresAdded.push(feature);
      this.features.push(feature);
      this.drawFeature(feature);
      if (notify) {
        this.events.triggerEvent("featureadded", { feature: feature });
        this.onFeatureInsert(feature);
      }
    }
    if (notify) {
      this.events.triggerEvent("featuresadded", { features: featuresAdded });
    }
  },
  removeFeatures: function(features, options) {
    if (!features || features.length === 0) {
      return;
    }
    if (features === this.features) {
      return this.removeAllFeatures(options);
    }
    if (!OpenLayers.Util.isArray(features)) {
      features = [features];
    }
    if (features === this.selectedFeatures) {
      features = features.slice();
    }
    var notify = !options || !options.silent;
    if (notify) {
      this.events.triggerEvent("beforefeaturesremoved", { features: features });
    }
    for (var i = features.length - 1; i >= 0; i--) {
      if (i != 0 && features[i - 1].geometry) {
        this.renderer.locked = true;
      } else {
        this.renderer.locked = false;
      }
      var feature = features[i];
      delete this.unrenderedFeatures[feature.id];
      if (notify) {
        this.events.triggerEvent("beforefeatureremoved", { feature: feature });
      }
      this.features = OpenLayers.Util.removeItem(this.features, feature);
      feature.layer = null;
      if (feature.geometry) {
        this.renderer.eraseFeatures(feature);
      }
      if (OpenLayers.Util.indexOf(this.selectedFeatures, feature) != -1) {
        OpenLayers.Util.removeItem(this.selectedFeatures, feature);
      }
      if (notify) {
        this.events.triggerEvent("featureremoved", { feature: feature });
      }
    }
    if (notify) {
      this.events.triggerEvent("featuresremoved", { features: features });
    }
  },
  removeAllFeatures: function(options) {
    var notify = !options || !options.silent;
    var features = this.features;
    if (notify) {
      this.events.triggerEvent("beforefeaturesremoved", { features: features });
    }
    var feature;
    for (var i = features.length - 1; i >= 0; i--) {
      feature = features[i];
      if (notify) {
        this.events.triggerEvent("beforefeatureremoved", { feature: feature });
      }
      feature.layer = null;
      if (notify) {
        this.events.triggerEvent("featureremoved", { feature: feature });
      }
    }
    this.renderer.clear();
    this.features = [];
    this.unrenderedFeatures = {};
    this.selectedFeatures = [];
    if (notify) {
      this.events.triggerEvent("featuresremoved", { features: features });
    }
  },
  destroyFeatures: function(features, options) {
    var all = features == undefined;
    if (all) {
      features = this.features;
    }
    if (features) {
      this.removeFeatures(features, options);
      for (var i = features.length - 1; i >= 0; i--) {
        features[i].destroy();
      }
    }
  },
  drawFeature: function(feature, style) {
    if (!this.drawn) {
      return;
    }
    if (typeof style != "object") {
      if (!style && feature.state === OpenLayers.State.DELETE) {
        style = "delete";
      }
      var renderIntent = style || feature.renderIntent;
      style = feature.style || this.style;
      if (!style) {
        style = this.styleMap.createSymbolizer(feature, renderIntent);
      }
    }
    var drawn = this.renderer.drawFeature(feature, style);
    if (drawn === false || drawn === null) {
      this.unrenderedFeatures[feature.id] = feature;
    } else {
      delete this.unrenderedFeatures[feature.id];
    }
  },
  eraseFeatures: function(features) {
    this.renderer.eraseFeatures(features);
  },
  getFeatureFromEvent: function(evt) {
    if (!this.renderer) {
      throw new Error(
        "getFeatureFromEvent called on layer with no " +
          "renderer. This usually means you destroyed a " +
          "layer, but not some handler which is associated " +
          "with it."
      );
    }
    var feature = null;
    var featureId = this.renderer.getFeatureIdFromEvent(evt);
    if (featureId) {
      if (typeof featureId === "string") {
        feature = this.getFeatureById(featureId);
      } else {
        feature = featureId;
      }
    }
    return feature;
  },
  getFeatureBy: function(property, value) {
    var feature = null;
    for (var i = 0, len = this.features.length; i < len; ++i) {
      if (this.features[i][property] == value) {
        feature = this.features[i];
        break;
      }
    }
    return feature;
  },
  getFeatureById: function(featureId) {
    return this.getFeatureBy("id", featureId);
  },
  getFeatureByFid: function(featureFid) {
    return this.getFeatureBy("fid", featureFid);
  },
  getFeaturesByAttribute: function(attrName, attrValue) {
    var i,
      feature,
      len = this.features.length,
      foundFeatures = [];
    for (i = 0; i < len; i++) {
      feature = this.features[i];
      if (feature && feature.attributes) {
        if (feature.attributes[attrName] === attrValue) {
          foundFeatures.push(feature);
        }
      }
    }
    return foundFeatures;
  },
  onFeatureInsert: function(feature) {},
  preFeatureInsert: function(feature) {},
  getDataExtent: function() {
    var maxExtent = null;
    var features = this.features;
    if (features && features.length > 0) {
      var geometry = null;
      for (var i = 0, len = features.length; i < len; i++) {
        geometry = features[i].geometry;
        if (geometry) {
          if (maxExtent === null) {
            maxExtent = new OpenLayers.Bounds();
          }
          maxExtent.extend(geometry.getBounds());
        }
      }
    }
    return maxExtent;
  },
  CLASS_NAME: "OpenLayers.Layer.Vector"
});
OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(
  OpenLayers.Layer.Vector,
  {
    displayInLayerSwitcher: false,
    layers: null,
    display: function() {},
    getFeatureFromEvent: function(evt) {
      var layers = this.layers;
      var feature;
      for (var i = 0; i < layers.length; i++) {
        feature = layers[i].getFeatureFromEvent(evt);
        if (feature) {
          return feature;
        }
      }
    },
    setMap: function(map) {
      OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments);
      this.collectRoots();
      map.events.register("changelayer", this, this.handleChangeLayer);
    },
    removeMap: function(map) {
      map.events.unregister("changelayer", this, this.handleChangeLayer);
      this.resetRoots();
      OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments);
    },
    collectRoots: function() {
      var layer;
      for (var i = 0; i < this.map.layers.length; ++i) {
        layer = this.map.layers[i];
        if (OpenLayers.Util.indexOf(this.layers, layer) != -1) {
          layer.renderer.moveRoot(this.renderer);
        }
      }
    },
    resetRoots: function() {
      var layer;
      for (var i = 0; i < this.layers.length; ++i) {
        layer = this.layers[i];
        if (this.renderer && layer.renderer.getRenderLayerId() == this.id) {
          this.renderer.moveRoot(layer.renderer);
        }
      }
    },
    handleChangeLayer: function(evt) {
      var layer = evt.layer;
      if (
        evt.property == "order" &&
        OpenLayers.Util.indexOf(this.layers, layer) != -1
      ) {
        this.resetRoots();
        this.collectRoots();
      }
    },
    CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer"
  }
);
OpenLayers.Control.SelectFeature = OpenLayers.Class(OpenLayers.Control, {
  multipleKey: null,
  toggleKey: null,
  multiple: false,
  clickout: true,
  toggle: false,
  hover: false,
  highlightOnly: false,
  box: false,
  onBeforeSelect: function() {},
  onSelect: function() {},
  onUnselect: function() {},
  scope: null,
  geometryTypes: null,
  layer: null,
  layers: null,
  callbacks: null,
  selectStyle: null,
  renderIntent: "select",
  handlers: null,
  initialize: function(layers, options) {
    OpenLayers.Control.prototype.initialize.apply(this, [options]);
    if (this.scope === null) {
      this.scope = this;
    }
    this.initLayer(layers);
    var callbacks = {
      click: this.clickFeature,
      clickout: this.clickoutFeature
    };
    if (this.hover) {
      callbacks.over = this.overFeature;
      callbacks.out = this.outFeature;
    }
    this.callbacks = OpenLayers.Util.extend(callbacks, this.callbacks);
    this.handlers = {
      feature: new OpenLayers.Handler.Feature(
        this,
        this.layer,
        this.callbacks,
        { geometryTypes: this.geometryTypes }
      )
    };
    if (this.box) {
      this.handlers.box = new OpenLayers.Handler.Box(
        this,
        { done: this.selectBox },
        { boxDivClassName: "olHandlerBoxSelectFeature" }
      );
    }
  },
  initLayer: function(layers) {
    if (OpenLayers.Util.isArray(layers)) {
      this.layers = layers;
      this.layer = new OpenLayers.Layer.Vector.RootContainer(
        this.id + "_container",
        { layers: layers }
      );
    } else {
      this.layer = layers;
    }
  },
  destroy: function() {
    if (this.active && this.layers) {
      this.map.removeLayer(this.layer);
    }
    OpenLayers.Control.prototype.destroy.apply(this, arguments);
    if (this.layers) {
      this.layer.destroy();
    }
  },
  activate: function() {
    if (!this.active) {
      if (this.layers) {
        this.map.addLayer(this.layer);
      }
      this.handlers.feature.activate();
      if (this.box && this.handlers.box) {
        this.handlers.box.activate();
      }
    }
    return OpenLayers.Control.prototype.activate.apply(this, arguments);
  },
  deactivate: function() {
    if (this.active) {
      this.handlers.feature.deactivate();
      if (this.handlers.box) {
        this.handlers.box.deactivate();
      }
      if (this.layers) {
        this.map.removeLayer(this.layer);
      }
    }
    return OpenLayers.Control.prototype.deactivate.apply(this, arguments);
  },
  unselectAll: function(options) {
    var layers = this.layers || [this.layer];
    var layer, feature;
    for (var l = 0; l < layers.length; ++l) {
      layer = layers[l];
      for (var i = layer.selectedFeatures.length - 1; i >= 0; --i) {
        feature = layer.selectedFeatures[i];
        if (!options || options.except != feature) {
          this.unselect(feature);
        }
      }
    }
  },
  clickFeature: function(feature) {
    if (!this.hover) {
      var selected =
        OpenLayers.Util.indexOf(feature.layer.selectedFeatures, feature) > -1;
      if (selected) {
        if (this.toggleSelect()) {
          this.unselect(feature);
        } else if (!this.multipleSelect()) {
          this.unselectAll({ except: feature });
        }
      } else {
        if (!this.multipleSelect()) {
          this.unselectAll({ except: feature });
        }
        this.select(feature);
      }
    }
  },
  multipleSelect: function() {
    return (
      this.multiple ||
      (this.handlers.feature.evt && this.handlers.feature.evt[this.multipleKey])
    );
  },
  toggleSelect: function() {
    return (
      this.toggle ||
      (this.handlers.feature.evt && this.handlers.feature.evt[this.toggleKey])
    );
  },
  clickoutFeature: function(feature) {
    if (!this.hover && this.clickout) {
      this.unselectAll();
    }
  },
  overFeature: function(feature) {
    var layer = feature.layer;
    if (this.hover) {
      if (this.highlightOnly) {
        this.highlight(feature);
      } else if (
        OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1
      ) {
        this.select(feature);
      }
    }
  },
  outFeature: function(feature) {
    if (this.hover) {
      if (this.highlightOnly) {
        if (feature._lastHighlighter == this.id) {
          if (feature._prevHighlighter && feature._prevHighlighter != this.id) {
            delete feature._lastHighlighter;
            var control = this.map.getControl(feature._prevHighlighter);
            if (control) {
              control.highlight(feature);
            }
          } else {
            this.unhighlight(feature);
          }
        }
      } else {
        this.unselect(feature);
      }
    }
  },
  highlight: function(feature) {
    var layer = feature.layer;
    var cont = this.events.triggerEvent("beforefeaturehighlighted", {
      feature: feature
    });
    if (cont !== false) {
      feature._prevHighlighter = feature._lastHighlighter;
      feature._lastHighlighter = this.id;
      var style = this.selectStyle || this.renderIntent;
      layer.drawFeature(feature, style);
      this.events.triggerEvent("featurehighlighted", { feature: feature });
    }
  },
  unhighlight: function(feature) {
    var layer = feature.layer;
    if (feature._prevHighlighter == undefined) {
      delete feature._lastHighlighter;
    } else if (feature._prevHighlighter == this.id) {
      delete feature._prevHighlighter;
    } else {
      feature._lastHighlighter = feature._prevHighlighter;
      delete feature._prevHighlighter;
    }
    layer.drawFeature(
      feature,
      feature.style || feature.layer.style || "default"
    );
    this.events.triggerEvent("featureunhighlighted", { feature: feature });
  },
  select: function(feature) {
    var cont = this.onBeforeSelect.call(this.scope, feature);
    var layer = feature.layer;
    if (cont !== false) {
      cont = layer.events.triggerEvent("beforefeatureselected", {
        feature: feature
      });
      if (cont !== false) {
        layer.selectedFeatures.push(feature);
        this.highlight(feature);
        if (!this.handlers.feature.lastFeature) {
          this.handlers.feature.lastFeature = layer.selectedFeatures[0];
        }
        layer.events.triggerEvent("featureselected", { feature: feature });
        this.onSelect.call(this.scope, feature);
      }
    }
  },
  unselect: function(feature) {
    var layer = feature.layer;
    this.unhighlight(feature);
    OpenLayers.Util.removeItem(layer.selectedFeatures, feature);
    layer.events.triggerEvent("featureunselected", { feature: feature });
    this.onUnselect.call(this.scope, feature);
  },
  selectBox: function(position) {
    if (position instanceof OpenLayers.Bounds) {
      var minXY = this.map.getLonLatFromPixel({
        x: position.left,
        y: position.bottom
      });
      var maxXY = this.map.getLonLatFromPixel({
        x: position.right,
        y: position.top
      });
      var bounds = new OpenLayers.Bounds(
        minXY.lon,
        minXY.lat,
        maxXY.lon,
        maxXY.lat
      );
      if (!this.multipleSelect()) {
        this.unselectAll();
      }
      var prevMultiple = this.multiple;
      this.multiple = true;
      var layers = this.layers || [this.layer];
      this.events.triggerEvent("boxselectionstart", { layers: layers });
      var layer;
      for (var l = 0; l < layers.length; ++l) {
        layer = layers[l];
        for (var i = 0, len = layer.features.length; i < len; ++i) {
          var feature = layer.features[i];
          if (!feature.getVisibility()) {
            continue;
          }
          if (
            this.geometryTypes == null ||
            OpenLayers.Util.indexOf(
              this.geometryTypes,
              feature.geometry.CLASS_NAME
            ) > -1
          ) {
            if (bounds.toGeometry().intersects(feature.geometry)) {
              if (
                OpenLayers.Util.indexOf(layer.selectedFeatures, feature) == -1
              ) {
                this.select(feature);
              }
            }
          }
        }
      }
      this.multiple = prevMultiple;
      this.events.triggerEvent("boxselectionend", { layers: layers });
    }
  },
  setMap: function(map) {
    this.handlers.feature.setMap(map);
    if (this.box) {
      this.handlers.box.setMap(map);
    }
    OpenLayers.Control.prototype.setMap.apply(this, arguments);
  },
  setLayer: function(layers) {
    var isActive = this.active;
    this.unselectAll();
    this.deactivate();
    if (this.layers) {
      this.layer.destroy();
      this.layers = null;
    }
    this.initLayer(layers);
    this.handlers.feature.layer = this.layer;
    if (isActive) {
      this.activate();
    }
  },
  CLASS_NAME: "OpenLayers.Control.SelectFeature"
});
OpenLayers.Control.Attribution = OpenLayers.Class(OpenLayers.Control, {
  separator: ", ",
  template: "${layers}",
  destroy: function() {
    this.map.events.un({
      removelayer: this.updateAttribution,
      addlayer: this.updateAttribution,
      changelayer: this.updateAttribution,
      changebaselayer: this.updateAttribution,
      scope: this
    });
    OpenLayers.Control.prototype.destroy.apply(this, arguments);
  },
  draw: function() {
    OpenLayers.Control.prototype.draw.apply(this, arguments);
    this.map.events.on({
      changebaselayer: this.updateAttribution,
      changelayer: this.updateAttribution,
      addlayer: this.updateAttribution,
      removelayer: this.updateAttribution,
      scope: this
    });
    this.updateAttribution();
    return this.div;
  },
  updateAttribution: function() {
    var attributions = [];
    if (this.map && this.map.layers) {
      for (var i = 0, len = this.map.layers.length; i < len; i++) {
        var layer = this.map.layers[i];
        if (layer.attribution && layer.getVisibility()) {
          if (OpenLayers.Util.indexOf(attributions, layer.attribution) === -1) {
            attributions.push(layer.attribution);
          }
        }
      }
      this.div.innerHTML = OpenLayers.String.format(this.template, {
        layers: attributions.join(this.separator)
      });
    }
  },
  CLASS_NAME: "OpenLayers.Control.Attribution"
});
OpenLayers.Kinetic = OpenLayers.Class({
  threshold: 0,
  deceleration: 0.0035,
  nbPoints: 100,
  delay: 200,
  points: undefined,
  timerId: undefined,
  initialize: function(options) {
    OpenLayers.Util.extend(this, options);
  },
  begin: function() {
    OpenLayers.Animation.stop(this.timerId);
    this.timerId = undefined;
    this.points = [];
  },
  update: function(xy) {
    this.points.unshift({ xy: xy, tick: new Date().getTime() });
    if (this.points.length > this.nbPoints) {
      this.points.pop();
    }
  },
  end: function(xy) {
    var last,
      now = new Date().getTime();
    for (var i = 0, l = this.points.length, point; i < l; i++) {
      point = this.points[i];
      if (now - point.tick > this.delay) {
        break;
      }
      last = point;
    }
    if (!last) {
      return;
    }
    var time = new Date().getTime() - last.tick;
    var dist = Math.sqrt(
      Math.pow(xy.x - last.xy.x, 2) + Math.pow(xy.y - last.xy.y, 2)
    );
    var speed = dist / time;
    if (speed == 0 || speed < this.threshold) {
      return;
    }
    var theta = Math.asin((xy.y - last.xy.y) / dist);
    if (last.xy.x <= xy.x) {
      theta = Math.PI - theta;
    }
    return { speed: speed, theta: theta };
  },
  move: function(info, callback) {
    var v0 = info.speed;
    var fx = Math.cos(info.theta);
    var fy = -Math.sin(info.theta);
    var initialTime = new Date().getTime();
    var lastX = 0;
    var lastY = 0;
    var timerCallback = function() {
      if (this.timerId == null) {
        return;
      }
      var t = new Date().getTime() - initialTime;
      var p = (-this.deceleration * Math.pow(t, 2)) / 2.0 + v0 * t;
      var x = p * fx;
      var y = p * fy;
      var args = {};
      args.end = false;
      var v = -this.deceleration * t + v0;
      if (v <= 0) {
        OpenLayers.Animation.stop(this.timerId);
        this.timerId = null;
        args.end = true;
      }
      args.x = x - lastX;
      args.y = y - lastY;
      lastX = x;
      lastY = y;
      callback(args.x, args.y, args.end);
    };
    this.timerId = OpenLayers.Animation.start(
      OpenLayers.Function.bind(timerCallback, this)
    );
  },
  CLASS_NAME: "OpenLayers.Kinetic"
});
OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, {
  filters: null,
  type: null,
  initialize: function(options) {
    this.filters = [];
    OpenLayers.Filter.prototype.initialize.apply(this, [options]);
  },
  destroy: function() {
    this.filters = null;
    OpenLayers.Filter.prototype.destroy.apply(this);
  },
  evaluate: function(context) {
    var i, len;
    switch (this.type) {
      case OpenLayers.Filter.Logical.AND:
        for (i = 0, len = this.filters.length; i < len; i++) {
          if (this.filters[i].evaluate(context) == false) {
            return false;
          }
        }
        return true;
      case OpenLayers.Filter.Logical.OR:
        for (i = 0, len = this.filters.length; i < len; i++) {
          if (this.filters[i].evaluate(context) == true) {
            return true;
          }
        }
        return false;
      case OpenLayers.Filter.Logical.NOT:
        return !this.filters[0].evaluate(context);
    }
    return undefined;
  },
  clone: function() {
    var filters = [];
    for (var i = 0, len = this.filters.length; i < len; ++i) {
      filters.push(this.filters[i].clone());
    }
    return new OpenLayers.Filter.Logical({ type: this.type, filters: filters });
  },
  CLASS_NAME: "OpenLayers.Filter.Logical"
});
OpenLayers.Filter.Logical.AND = "&&";
OpenLayers.Filter.Logical.OR = "||";
OpenLayers.Filter.Logical.NOT = "!";
OpenLayers.Handler.Drag = OpenLayers.Class(OpenLayers.Handler, {
  started: false,
  stopDown: true,
  dragging: false,
  touch: false,
  last: null,
  start: null,
  lastMoveEvt: null,
  oldOnselectstart: null,
  interval: 0,
  timeoutId: null,
  documentDrag: false,
  documentEvents: null,
  initialize: function(control, callbacks, options) {
    OpenLayers.Handler.prototype.initialize.apply(this, arguments);
    if (this.documentDrag === true) {
      var me = this;
      this._docMove = function(evt) {
        me.mousemove({
          xy: { x: evt.clientX, y: evt.clientY },
          element: document
        });
      };
      this._docUp = function(evt) {
        me.mouseup({ xy: { x: evt.clientX, y: evt.clientY } });
      };
    }
  },
  dragstart: function(evt) {
    var propagate = true;
    this.dragging = false;
    if (
      this.checkModifiers(evt) &&
      (OpenLayers.Event.isLeftClick(evt) || OpenLayers.Event.isSingleTouch(evt))
    ) {
      this.started = true;
      this.start = evt.xy;
      this.last = evt.xy;
      OpenLayers.Element.addClass(this.map.viewPortDiv, "olDragDown");
      this.down(evt);
      this.callback("down", [evt.xy]);
      OpenLayers.Event.stop(evt);
      if (!this.oldOnselectstart) {
        this.oldOnselectstart = document.onselectstart
          ? document.onselectstart
          : OpenLayers.Function.True;
      }
      document.onselectstart = OpenLayers.Function.False;
      propagate = !this.stopDown;
    } else {
      this.started = false;
      this.start = null;
      this.last = null;
    }
    return propagate;
  },
  dragmove: function(evt) {
    this.lastMoveEvt = evt;
    if (
      this.started &&
      !this.timeoutId &&
      (evt.xy.x != this.last.x || evt.xy.y != this.last.y)
    ) {
      if (this.documentDrag === true && this.documentEvents) {
        if (evt.element === document) {
          this.adjustXY(evt);
          this.setEvent(evt);
        } else {
          this.removeDocumentEvents();
        }
      }
      if (this.interval > 0) {
        this.timeoutId = setTimeout(
          OpenLayers.Function.bind(this.removeTimeout, this),
          this.interval
        );
      }
      this.dragging = true;
      this.move(evt);
      this.callback("move", [evt.xy]);
      if (!this.oldOnselectstart) {
        this.oldOnselectstart = document.onselectstart;
        document.onselectstart = OpenLayers.Function.False;
      }
      this.last = evt.xy;
    }
    return true;
  },
  dragend: function(evt) {
    if (this.started) {
      if (this.documentDrag === true && this.documentEvents) {
        this.adjustXY(evt);
        this.removeDocumentEvents();
      }
      var dragged = this.start != this.last;
      this.started = false;
      this.dragging = false;
      OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown");
      this.up(evt);
      this.callback("up", [evt.xy]);
      if (dragged) {
        this.callback("done", [evt.xy]);
      }
      document.onselectstart = this.oldOnselectstart;
    }
    return true;
  },
  down: function(evt) {},
  move: function(evt) {},
  up: function(evt) {},
  out: function(evt) {},
  mousedown: function(evt) {
    return this.dragstart(evt);
  },
  touchstart: function(evt) {
    if (!this.touch) {
      this.touch = true;
      this.map.events.un({
        mousedown: this.mousedown,
        mouseup: this.mouseup,
        mousemove: this.mousemove,
        click: this.click,
        scope: this
      });
    }
    return this.dragstart(evt);
  },
  mousemove: function(evt) {
    return this.dragmove(evt);
  },
  touchmove: function(evt) {
    return this.dragmove(evt);
  },
  removeTimeout: function() {
    this.timeoutId = null;
    if (this.dragging) {
      this.mousemove(this.lastMoveEvt);
    }
  },
  mouseup: function(evt) {
    return this.dragend(evt);
  },
  touchend: function(evt) {
    evt.xy = this.last;
    return this.dragend(evt);
  },
  mouseout: function(evt) {
    if (this.started && OpenLayers.Util.mouseLeft(evt, this.map.viewPortDiv)) {
      if (this.documentDrag === true) {
        this.addDocumentEvents();
      } else {
        var dragged = this.start != this.last;
        this.started = false;
        this.dragging = false;
        OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown");
        this.out(evt);
        this.callback("out", []);
        if (dragged) {
          this.callback("done", [evt.xy]);
        }
        if (document.onselectstart) {
          document.onselectstart = this.oldOnselectstart;
        }
      }
    }
    return true;
  },
  click: function(evt) {
    return this.start == this.last;
  },
  activate: function() {
    var activated = false;
    if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
      this.dragging = false;
      activated = true;
    }
    return activated;
  },
  deactivate: function() {
    var deactivated = false;
    if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
      this.touch = false;
      this.started = false;
      this.dragging = false;
      this.start = null;
      this.last = null;
      deactivated = true;
      OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDragDown");
    }
    return deactivated;
  },
  adjustXY: function(evt) {
    var pos = OpenLayers.Util.pagePosition(this.map.viewPortDiv);
    evt.xy.x -= pos[0];
    evt.xy.y -= pos[1];
  },
  addDocumentEvents: function() {
    OpenLayers.Element.addClass(document.body, "olDragDown");
    this.documentEvents = true;
    OpenLayers.Event.observe(document, "mousemove", this._docMove);
    OpenLayers.Event.observe(document, "mouseup", this._docUp);
  },
  removeDocumentEvents: function() {
    OpenLayers.Element.removeClass(document.body, "olDragDown");
    this.documentEvents = false;
    OpenLayers.Event.stopObserving(document, "mousemove", this._docMove);
    OpenLayers.Event.stopObserving(document, "mouseup", this._docUp);
  },
  CLASS_NAME: "OpenLayers.Handler.Drag"
});
OpenLayers.Handler.Box = OpenLayers.Class(OpenLayers.Handler, {
  dragHandler: null,
  boxDivClassName: "olHandlerBoxZoomBox",
  boxOffsets: null,
  initialize: function(control, callbacks, options) {
    OpenLayers.Handler.prototype.initialize.apply(this, arguments);
    this.dragHandler = new OpenLayers.Handler.Drag(
      this,
      {
        down: this.startBox,
        move: this.moveBox,
        out: this.removeBox,
        up: this.endBox
      },
      { keyMask: this.keyMask }
    );
  },
  destroy: function() {
    OpenLayers.Handler.prototype.destroy.apply(this, arguments);
    if (this.dragHandler) {
      this.dragHandler.destroy();
      this.dragHandler = null;
    }
  },
  setMap: function(map) {
    OpenLayers.Handler.prototype.setMap.apply(this, arguments);
    if (this.dragHandler) {
      this.dragHandler.setMap(map);
    }
  },
  startBox: function(xy) {
    this.callback("start", []);
    this.zoomBox = OpenLayers.Util.createDiv("zoomBox", { x: -9999, y: -9999 });
    this.zoomBox.className = this.boxDivClassName;
    this.zoomBox.style.zIndex = this.map.Z_INDEX_BASE["Popup"] - 1;
    this.map.viewPortDiv.appendChild(this.zoomBox);
    OpenLayers.Element.addClass(this.map.viewPortDiv, "olDrawBox");
  },
  moveBox: function(xy) {
    var startX = this.dragHandler.start.x;
    var startY = this.dragHandler.start.y;
    var deltaX = Math.abs(startX - xy.x);
    var deltaY = Math.abs(startY - xy.y);
    var offset = this.getBoxOffsets();
    this.zoomBox.style.width = deltaX + offset.width + 1 + "px";
    this.zoomBox.style.height = deltaY + offset.height + 1 + "px";
    this.zoomBox.style.left =
      (xy.x < startX ? startX - deltaX - offset.left : startX - offset.left) +
      "px";
    this.zoomBox.style.top =
      (xy.y < startY ? startY - deltaY - offset.top : startY - offset.top) +
      "px";
  },
  endBox: function(end) {
    var result;
    if (
      Math.abs(this.dragHandler.start.x - end.x) > 5 ||
      Math.abs(this.dragHandler.start.y - end.y) > 5
    ) {
      var start = this.dragHandler.start;
      var top = Math.min(start.y, end.y);
      var bottom = Math.max(start.y, end.y);
      var left = Math.min(start.x, end.x);
      var right = Math.max(start.x, end.x);
      result = new OpenLayers.Bounds(left, bottom, right, top);
    } else {
      result = this.dragHandler.start.clone();
    }
    this.removeBox();
    this.callback("done", [result]);
  },
  removeBox: function() {
    this.map.viewPortDiv.removeChild(this.zoomBox);
    this.zoomBox = null;
    this.boxOffsets = null;
    OpenLayers.Element.removeClass(this.map.viewPortDiv, "olDrawBox");
  },
  activate: function() {
    if (OpenLayers.Handler.prototype.activate.apply(this, arguments)) {
      this.dragHandler.activate();
      return true;
    } else {
      return false;
    }
  },
  deactivate: function() {
    if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
      if (this.dragHandler.deactivate()) {
        if (this.zoomBox) {
          this.removeBox();
        }
      }
      return true;
    } else {
      return false;
    }
  },
  getBoxOffsets: function() {
    if (!this.boxOffsets) {
      var testDiv = document.createElement("div");
      testDiv.style.position = "absolute";
      testDiv.style.border = "1px solid black";
      testDiv.style.width = "3px";
      document.body.appendChild(testDiv);
      var w3cBoxModel = testDiv.clientWidth == 3;
      document.body.removeChild(testDiv);
      var left = parseInt(
        OpenLayers.Element.getStyle(this.zoomBox, "border-left-width")
      );
      var right = parseInt(
        OpenLayers.Element.getStyle(this.zoomBox, "border-right-width")
      );
      var top = parseInt(
        OpenLayers.Element.getStyle(this.zoomBox, "border-top-width")
      );
      var bottom = parseInt(
        OpenLayers.Element.getStyle(this.zoomBox, "border-bottom-width")
      );
      this.boxOffsets = {
        left: left,
        right: right,
        top: top,
        bottom: bottom,
        width: w3cBoxModel === false ? left + right : 0,
        height: w3cBoxModel === false ? top + bottom : 0
      };
    }
    return this.boxOffsets;
  },
  CLASS_NAME: "OpenLayers.Handler.Box"
});
OpenLayers.Control.ZoomBox = OpenLayers.Class(OpenLayers.Control, {
  type: OpenLayers.Control.TYPE_TOOL,
  out: false,
  keyMask: null,
  alwaysZoom: false,
  draw: function() {
    this.handler = new OpenLayers.Handler.Box(
      this,
      { done: this.zoomBox },
      { keyMask: this.keyMask }
    );
  },
  zoomBox: function(position) {
    if (position instanceof OpenLayers.Bounds) {
      var bounds;
      if (!this.out) {
        var minXY = this.map.getLonLatFromPixel({
          x: position.left,
          y: position.bottom
        });
        var maxXY = this.map.getLonLatFromPixel({
          x: position.right,
          y: position.top
        });
        bounds = new OpenLayers.Bounds(
          minXY.lon,
          minXY.lat,
          maxXY.lon,
          maxXY.lat
        );
      } else {
        var pixWidth = Math.abs(position.right - position.left);
        var pixHeight = Math.abs(position.top - position.bottom);
        var zoomFactor = Math.min(
          this.map.size.h / pixHeight,
          this.map.size.w / pixWidth
        );
        var extent = this.map.getExtent();
        var center = this.map.getLonLatFromPixel(position.getCenterPixel());
        var xmin = center.lon - (extent.getWidth() / 2) * zoomFactor;
        var xmax = center.lon + (extent.getWidth() / 2) * zoomFactor;
        var ymin = center.lat - (extent.getHeight() / 2) * zoomFactor;
        var ymax = center.lat + (extent.getHeight() / 2) * zoomFactor;
        bounds = new OpenLayers.Bounds(xmin, ymin, xmax, ymax);
      }
      var lastZoom = this.map.getZoom();
      this.map.zoomToExtent(bounds);
      if (lastZoom == this.map.getZoom() && this.alwaysZoom == true) {
        this.map.zoomTo(lastZoom + (this.out ? -1 : 1));
      }
    } else {
      if (!this.out) {
        this.map.setCenter(
          this.map.getLonLatFromPixel(position),
          this.map.getZoom() + 1
        );
      } else {
        this.map.setCenter(
          this.map.getLonLatFromPixel(position),
          this.map.getZoom() - 1
        );
      }
    }
  },
  CLASS_NAME: "OpenLayers.Control.ZoomBox"
});
OpenLayers.Control.DragPan = OpenLayers.Class(OpenLayers.Control, {
  type: OpenLayers.Control.TYPE_TOOL,
  panned: false,
  interval: 1,
  documentDrag: false,
  kinetic: null,
  enableKinetic: false,
  kineticInterval: 10,
  draw: function() {
    if (this.enableKinetic) {
      var config = { interval: this.kineticInterval };
      if (typeof this.enableKinetic === "object") {
        config = OpenLayers.Util.extend(config, this.enableKinetic);
      }
      this.kinetic = new OpenLayers.Kinetic(config);
    }
    this.handler = new OpenLayers.Handler.Drag(
      this,
      { move: this.panMap, done: this.panMapDone, down: this.panMapStart },
      { interval: this.interval, documentDrag: this.documentDrag }
    );
  },
  panMapStart: function() {
    if (this.kinetic) {
      this.kinetic.begin();
    }
  },
  panMap: function(xy) {
    if (this.kinetic) {
      this.kinetic.update(xy);
    }
    this.panned = true;
    this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, {
      dragging: true,
      animate: false
    });
  },
  panMapDone: function(xy) {
    if (this.panned) {
      var res = null;
      if (this.kinetic) {
        res = this.kinetic.end(xy);
      }
      this.map.pan(this.handler.last.x - xy.x, this.handler.last.y - xy.y, {
        dragging: !!res,
        animate: false
      });
      if (res) {
        var self = this;
        this.kinetic.move(res, function(x, y, end) {
          self.map.pan(x, y, { dragging: !end, animate: false });
        });
      }
      this.panned = false;
    }
  },
  CLASS_NAME: "OpenLayers.Control.DragPan"
});
OpenLayers.Handler.Click = OpenLayers.Class(OpenLayers.Handler, {
  delay: 300,
  single: true,
  double: false,
  pixelTolerance: 0,
  dblclickTolerance: 13,
  stopSingle: false,
  stopDouble: false,
  timerId: null,
  touch: false,
  down: null,
  last: null,
  first: null,
  rightclickTimerId: null,
  touchstart: function(evt) {
    if (!this.touch) {
      this.unregisterMouseListeners();
      this.touch = true;
    }
    this.down = this.getEventInfo(evt);
    this.last = this.getEventInfo(evt);
    return true;
  },
  touchmove: function(evt) {
    this.last = this.getEventInfo(evt);
    return true;
  },
  touchend: function(evt) {
    if (this.down) {
      evt.xy = this.last.xy;
      evt.lastTouches = this.last.touches;
      this.handleSingle(evt);
      this.down = null;
    }
    return true;
  },
  unregisterMouseListeners: function() {
    this.map.events.un({
      mousedown: this.mousedown,
      mouseup: this.mouseup,
      click: this.click,
      dblclick: this.dblclick,
      scope: this
    });
  },
  mousedown: function(evt) {
    this.down = this.getEventInfo(evt);
    this.last = this.getEventInfo(evt);
    return true;
  },
  mouseup: function(evt) {
    var propagate = true;
    if (
      this.checkModifiers(evt) &&
      this.control.handleRightClicks &&
      OpenLayers.Event.isRightClick(evt)
    ) {
      propagate = this.rightclick(evt);
    }
    return propagate;
  },
  rightclick: function(evt) {
    if (this.passesTolerance(evt)) {
      if (this.rightclickTimerId != null) {
        this.clearTimer();
        this.callback("dblrightclick", [evt]);
        return !this.stopDouble;
      } else {
        var clickEvent = this["double"]
          ? OpenLayers.Util.extend({}, evt)
          : this.callback("rightclick", [evt]);
        var delayedRightCall = OpenLayers.Function.bind(
          this.delayedRightCall,
          this,
          clickEvent
        );
        this.rightclickTimerId = window.setTimeout(
          delayedRightCall,
          this.delay
        );
      }
    }
    return !this.stopSingle;
  },
  delayedRightCall: function(evt) {
    this.rightclickTimerId = null;
    if (evt) {
      this.callback("rightclick", [evt]);
    }
  },
  click: function(evt) {
    if (!this.last) {
      this.last = this.getEventInfo(evt);
    }
    this.handleSingle(evt);
    return !this.stopSingle;
  },
  dblclick: function(evt) {
    this.handleDouble(evt);
    return !this.stopDouble;
  },
  handleDouble: function(evt) {
    if (this.passesDblclickTolerance(evt)) {
      if (this["double"]) {
        this.callback("dblclick", [evt]);
      }
      this.clearTimer();
    }
  },
  handleSingle: function(evt) {
    if (this.passesTolerance(evt)) {
      if (this.timerId != null) {
        if (this.last.touches && this.last.touches.length === 1) {
          if (this["double"]) {
            OpenLayers.Event.stop(evt);
          }
          this.handleDouble(evt);
        }
        if (!this.last.touches || this.last.touches.length !== 2) {
          this.clearTimer();
        }
      } else {
        this.first = this.getEventInfo(evt);
        var clickEvent = this.single ? OpenLayers.Util.extend({}, evt) : null;
        this.queuePotentialClick(clickEvent);
      }
    }
  },
  queuePotentialClick: function(evt) {
    this.timerId = window.setTimeout(
      OpenLayers.Function.bind(this.delayedCall, this, evt),
      this.delay
    );
  },
  passesTolerance: function(evt) {
    var passes = true;
    if (this.pixelTolerance != null && this.down && this.down.xy) {
      passes = this.pixelTolerance >= this.down.xy.distanceTo(evt.xy);
      if (
        passes &&
        this.touch &&
        this.down.touches.length === this.last.touches.length
      ) {
        for (var i = 0, ii = this.down.touches.length; i < ii; ++i) {
          if (
            this.getTouchDistance(this.down.touches[i], this.last.touches[i]) >
            this.pixelTolerance
          ) {
            passes = false;
            break;
          }
        }
      }
    }
    return passes;
  },
  getTouchDistance: function(from, to) {
    return Math.sqrt(
      Math.pow(from.clientX - to.clientX, 2) +
        Math.pow(from.clientY - to.clientY, 2)
    );
  },
  passesDblclickTolerance: function(evt) {
    var passes = true;
    if (this.down && this.first) {
      passes = this.down.xy.distanceTo(this.first.xy) <= this.dblclickTolerance;
    }
    return passes;
  },
  clearTimer: function() {
    if (this.timerId != null) {
      window.clearTimeout(this.timerId);
      this.timerId = null;
    }
    if (this.rightclickTimerId != null) {
      window.clearTimeout(this.rightclickTimerId);
      this.rightclickTimerId = null;
    }
  },
  delayedCall: function(evt) {
    this.timerId = null;
    if (evt) {
      this.callback("click", [evt]);
    }
  },
  getEventInfo: function(evt) {
    var touches;
    if (evt.touches) {
      var len = evt.touches.length;
      touches = new Array(len);
      var touch;
      for (var i = 0; i < len; i++) {
        touch = evt.touches[i];
        touches[i] = { clientX: touch.clientX, clientY: touch.clientY };
      }
    }
    return { xy: evt.xy, touches: touches };
  },
  deactivate: function() {
    var deactivated = false;
    if (OpenLayers.Handler.prototype.deactivate.apply(this, arguments)) {
      this.clearTimer();
      this.down = null;
      this.first = null;
      this.last = null;
      this.touch = false;
      deactivated = true;
    }
    return deactivated;
  },
  CLASS_NAME: "OpenLayers.Handler.Click"
});
OpenLayers.Control.Navigation = OpenLayers.Class(OpenLayers.Control, {
  dragPan: null,
  dragPanOptions: null,
  pinchZoom: null,
  pinchZoomOptions: null,
  documentDrag: false,
  zoomBox: null,
  zoomBoxEnabled: true,
  zoomWheelEnabled: true,
  mouseWheelOptions: null,
  handleRightClicks: false,
  zoomBoxKeyMask: OpenLayers.Handler.MOD_SHIFT,
  autoActivate: true,
  initialize: function(options) {
    this.handlers = {};
    OpenLayers.Control.prototype.initialize.apply(this, arguments);
  },
  destroy: function() {
    this.deactivate();
    if (this.dragPan) {
      this.dragPan.destroy();
    }
    this.dragPan = null;
    if (this.zoomBox) {
      this.zoomBox.destroy();
    }
    this.zoomBox = null;
    if (this.pinchZoom) {
      this.pinchZoom.destroy();
    }
    this.pinchZoom = null;
    OpenLayers.Control.prototype.destroy.apply(this, arguments);
  },
  activate: function() {
    this.dragPan.activate();
    if (this.zoomWheelEnabled) {
      this.handlers.wheel.activate();
    }
    this.handlers.click.activate();
    if (this.zoomBoxEnabled) {
      this.zoomBox.activate();
    }
    if (this.pinchZoom) {
      this.pinchZoom.activate();
    }
    return OpenLayers.Control.prototype.activate.apply(this, arguments);
  },
  deactivate: function() {
    if (this.pinchZoom) {
      this.pinchZoom.deactivate();
    }
    this.zoomBox.deactivate();
    this.dragPan.deactivate();
    this.handlers.click.deactivate();
    this.handlers.wheel.deactivate();
    return OpenLayers.Control.prototype.deactivate.apply(this, arguments);
  },
  draw: function() {
    if (this.handleRightClicks) {
      this.map.viewPortDiv.oncontextmenu = OpenLayers.Function.False;
    }
    var clickCallbacks = {
      click: this.defaultClick,
      dblclick: this.defaultDblClick,
      dblrightclick: this.defaultDblRightClick
    };
    var clickOptions = { double: true, stopDouble: true };
    this.handlers.click = new OpenLayers.Handler.Click(
      this,
      clickCallbacks,
      clickOptions
    );
    this.dragPan = new OpenLayers.Control.DragPan(
      OpenLayers.Util.extend(
        { map: this.map, documentDrag: this.documentDrag },
        this.dragPanOptions
      )
    );
    this.zoomBox = new OpenLayers.Control.ZoomBox({
      map: this.map,
      keyMask: this.zoomBoxKeyMask
    });
    this.dragPan.draw();
    this.zoomBox.draw();
    this.handlers.wheel = new OpenLayers.Handler.MouseWheel(
      this,
      { up: this.wheelUp, down: this.wheelDown },
      this.mouseWheelOptions
    );
    if (OpenLayers.Control.PinchZoom) {
      this.pinchZoom = new OpenLayers.Control.PinchZoom(
        OpenLayers.Util.extend({ map: this.map }, this.pinchZoomOptions)
      );
    }
  },
  defaultClick: function(evt) {
    if (evt.lastTouches && evt.lastTouches.length == 2) {
      this.map.zoomOut();
    }
  },
  defaultDblClick: function(evt) {
    var newCenter = this.map.getLonLatFromViewPortPx(evt.xy);
    this.map.setCenter(newCenter, this.map.zoom + 1);
  },
  defaultDblRightClick: function(evt) {
    var newCenter = this.map.getLonLatFromViewPortPx(evt.xy);
    this.map.setCenter(newCenter, this.map.zoom - 1);
  },
  wheelChange: function(evt, deltaZ) {
    var currentZoom = this.map.getZoom();
    var newZoom = this.map.getZoom() + Math.round(deltaZ);
    newZoom = Math.max(newZoom, 0);
    newZoom = Math.min(newZoom, this.map.getNumZoomLevels());
    if (newZoom === currentZoom) {
      return;
    }
    var size = this.map.getSize();
    var deltaX = size.w / 2 - evt.xy.x;
    var deltaY = evt.xy.y - size.h / 2;
    var newRes = this.map.baseLayer.getResolutionForZoom(newZoom);
    var zoomPoint = this.map.getLonLatFromPixel(evt.xy);
    var newCenter = new OpenLayers.LonLat(
      zoomPoint.lon + deltaX * newRes,
      zoomPoint.lat + deltaY * newRes
    );
    this.map.setCenter(newCenter, newZoom);
  },
  wheelUp: function(evt, delta) {
    this.wheelChange(evt, delta || 1);
  },
  wheelDown: function(evt, delta) {
    this.wheelChange(evt, delta || -1);
  },
  disableZoomBox: function() {
    this.zoomBoxEnabled = false;
    this.zoomBox.deactivate();
  },
  enableZoomBox: function() {
    this.zoomBoxEnabled = true;
    if (this.active) {
      this.zoomBox.activate();
    }
  },
  disableZoomWheel: function() {
    this.zoomWheelEnabled = false;
    this.handlers.wheel.deactivate();
  },
  enableZoomWheel: function() {
    this.zoomWheelEnabled = true;
    if (this.active) {
      this.handlers.wheel.activate();
    }
  },
  CLASS_NAME: "OpenLayers.Control.Navigation"
});
OpenLayers.Layer.WMS = OpenLayers.Class(OpenLayers.Layer.Grid, {
  DEFAULT_PARAMS: {
    service: "WMS",
    version: "1.1.1",
    request: "GetMap",
    styles: "",
    format: "image/jpeg"
  },
  isBaseLayer: true,
  encodeBBOX: false,
  noMagic: false,
  yx: {},
  initialize: function(name, url, params, options) {
    var newArguments = [];
    params = OpenLayers.Util.upperCaseObject(params);
    if (parseFloat(params.VERSION) >= 1.3 && !params.EXCEPTIONS) {
      params.EXCEPTIONS = "INIMAGE";
    }
    newArguments.push(name, url, params, options);
    OpenLayers.Layer.Grid.prototype.initialize.apply(this, newArguments);
    OpenLayers.Util.applyDefaults(
      this.params,
      OpenLayers.Util.upperCaseObject(this.DEFAULT_PARAMS)
    );
    if (
      !this.noMagic &&
      this.params.TRANSPARENT &&
      this.params.TRANSPARENT.toString().toLowerCase() == "true"
    ) {
      if (options == null || !options.isBaseLayer) {
        this.isBaseLayer = false;
      }
      if (this.params.FORMAT == "image/jpeg") {
        this.params.FORMAT = OpenLayers.Util.alphaHack()
          ? "image/gif"
          : "image/png";
      }
    }
  },
  clone: function(obj) {
    if (obj == null) {
      obj = new OpenLayers.Layer.WMS(
        this.name,
        this.url,
        this.params,
        this.getOptions()
      );
    }
    obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
    return obj;
  },
  reverseAxisOrder: function() {
    var projCode = this.projection.getCode();
    return (
      parseFloat(this.params.VERSION) >= 1.3 &&
      !!(this.yx[projCode] || OpenLayers.Projection.defaults[projCode].yx)
    );
  },
  getURL: function(bounds) {
    bounds = this.adjustBounds(bounds);
    var imageSize = this.getImageSize();
    var newParams = {};
    var reverseAxisOrder = this.reverseAxisOrder();
    newParams.BBOX = this.encodeBBOX
      ? bounds.toBBOX(null, reverseAxisOrder)
      : bounds.toArray(reverseAxisOrder);
    newParams.WIDTH = imageSize.w;
    newParams.HEIGHT = imageSize.h;
    var requestString = this.getFullRequestString(newParams);
    return requestString;
  },
  mergeNewParams: function(newParams) {
    var upperParams = OpenLayers.Util.upperCaseObject(newParams);
    var newArguments = [upperParams];
    return OpenLayers.Layer.Grid.prototype.mergeNewParams.apply(
      this,
      newArguments
    );
  },
  getFullRequestString: function(newParams, altUrl) {
    var mapProjection = this.map.getProjectionObject();
    var projectionCode =
      this.projection && this.projection.equals(mapProjection)
        ? this.projection.getCode()
        : mapProjection.getCode();
    var value = projectionCode == "none" ? null : projectionCode;
    if (parseFloat(this.params.VERSION) >= 1.3) {
      this.params.CRS = value;
    } else {
      this.params.SRS = value;
    }
    if (typeof this.params.TRANSPARENT == "boolean") {
      newParams.TRANSPARENT = this.params.TRANSPARENT ? "TRUE" : "FALSE";
    }
    return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(
      this,
      arguments
    );
  },
  CLASS_NAME: "OpenLayers.Layer.WMS"
});
OpenLayers.Renderer.SVG = OpenLayers.Class(OpenLayers.Renderer.Elements, {
  xmlns: "http://www.w3.org/2000/svg",
  xlinkns: "http://www.w3.org/1999/xlink",
  MAX_PIXEL: 15000,
  translationParameters: null,
  symbolMetrics: null,
  initialize: function(containerID) {
    if (!this.supported()) {
      return;
    }
    OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments);
    this.translationParameters = { x: 0, y: 0 };
    this.symbolMetrics = {};
  },
  supported: function() {
    var svgFeature = "http://www.w3.org/TR/SVG11/feature#";
    return (
      document.implementation &&
      (document.implementation.hasFeature("org.w3c.svg", "1.0") ||
        document.implementation.hasFeature(svgFeature + "SVG", "1.1") ||
        document.implementation.hasFeature(
          svgFeature + "BasicStructure",
          "1.1"
        ))
    );
  },
  inValidRange: function(x, y, xyOnly) {
    var left = x + (xyOnly ? 0 : this.translationParameters.x);
    var top = y + (xyOnly ? 0 : this.translationParameters.y);
    return (
      left >= -this.MAX_PIXEL &&
      left <= this.MAX_PIXEL &&
      top >= -this.MAX_PIXEL &&
      top <= this.MAX_PIXEL
    );
  },
  setExtent: function(extent, resolutionChanged) {
    var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(
      this,
      arguments
    );
    var resolution = this.getResolution(),
      left = -extent.left / resolution,
      top = extent.top / resolution;
    if (resolutionChanged) {
      this.left = left;
      this.top = top;
      var extentString = "0 0 " + this.size.w + " " + this.size.h;
      this.rendererRoot.setAttributeNS(null, "viewBox", extentString);
      this.translate(this.xOffset, 0);
      return true;
    } else {
      var inRange = this.translate(
        left - this.left + this.xOffset,
        top - this.top
      );
      if (!inRange) {
        this.setExtent(extent, true);
      }
      return coordSysUnchanged && inRange;
    }
  },
  translate: function(x, y) {
    if (!this.inValidRange(x, y, true)) {
      return false;
    } else {
      var transformString = "";
      if (x || y) {
        transformString = "translate(" + x + "," + y + ")";
      }
      this.root.setAttributeNS(null, "transform", transformString);
      this.translationParameters = { x: x, y: y };
      return true;
    }
  },
  setSize: function(size) {
    OpenLayers.Renderer.prototype.setSize.apply(this, arguments);
    this.rendererRoot.setAttributeNS(null, "width", this.size.w);
    this.rendererRoot.setAttributeNS(null, "height", this.size.h);
  },
  getNodeType: function(geometry, style) {
    var nodeType = null;
    switch (geometry.CLASS_NAME) {
      case "OpenLayers.Geometry.Point":
        if (style.externalGraphic) {
          nodeType = "image";
        } else if (this.isComplexSymbol(style.graphicName)) {
          nodeType = "svg";
        } else {
          nodeType = "circle";
        }
        break;
      case "OpenLayers.Geometry.Rectangle":
        nodeType = "rect";
        break;
      case "OpenLayers.Geometry.LineString":
        nodeType = "polyline";
        break;
      case "OpenLayers.Geometry.LinearRing":
        nodeType = "polygon";
        break;
      case "OpenLayers.Geometry.Polygon":
      case "OpenLayers.Geometry.Curve":
        nodeType = "path";
        break;
      default:
        break;
    }
    return nodeType;
  },
  setStyle: function(node, style, options) {
    style = style || node._style;
    options = options || node._options;
    var r = parseFloat(node.getAttributeNS(null, "r"));
    var widthFactor = 1;
    var pos;
    if (node._geometryClass == "OpenLayers.Geometry.Point" && r) {
      node.style.visibility = "";
      if (style.graphic === false) {
        node.style.visibility = "hidden";
      } else if (style.externalGraphic) {
        pos = this.getPosition(node);
        if (style.graphicTitle) {
          node.setAttributeNS(null, "title", style.graphicTitle);
          var titleNode = node.getElementsByTagName("title");
          if (titleNode.length > 0) {
            titleNode[0].firstChild.textContent = style.graphicTitle;
          } else {
            var label = this.nodeFactory(null, "title");
            label.textContent = style.graphicTitle;
            node.appendChild(label);
          }
        }
        if (style.graphicWidth && style.graphicHeight) {
          node.setAttributeNS(null, "preserveAspectRatio", "none");
        }
        var width = style.graphicWidth || style.graphicHeight;
        var height = style.graphicHeight || style.graphicWidth;
        width = width ? width : style.pointRadius * 2;
        height = height ? height : style.pointRadius * 2;
        var xOffset =
          style.graphicXOffset != undefined
            ? style.graphicXOffset
            : -(0.5 * width);
        var yOffset =
          style.graphicYOffset != undefined
            ? style.graphicYOffset
            : -(0.5 * height);
        var opacity = style.graphicOpacity || style.fillOpacity;
        node.setAttributeNS(null, "x", (pos.x + xOffset).toFixed());
        node.setAttributeNS(null, "y", (pos.y + yOffset).toFixed());
        node.setAttributeNS(null, "width", width);
        node.setAttributeNS(null, "height", height);
        node.setAttributeNS(this.xlinkns, "href", style.externalGraphic);
        node.setAttributeNS(null, "style", "opacity: " + opacity);
        node.onclick = OpenLayers.Renderer.SVG.preventDefault;
      } else if (this.isComplexSymbol(style.graphicName)) {
        var offset = style.pointRadius * 3;
        var size = offset * 2;
        var src = this.importSymbol(style.graphicName);
        pos = this.getPosition(node);
        widthFactor = (this.symbolMetrics[src.id][0] * 3) / size;
        var parent = node.parentNode;
        var nextSibling = node.nextSibling;
        if (parent) {
          parent.removeChild(node);
        }
        node.firstChild && node.removeChild(node.firstChild);
        node.appendChild(src.firstChild.cloneNode(true));
        node.setAttributeNS(
          null,
          "viewBox",
          src.getAttributeNS(null, "viewBox")
        );
        node.setAttributeNS(null, "width", size);
        node.setAttributeNS(null, "height", size);
        node.setAttributeNS(null, "x", pos.x - offset);
        node.setAttributeNS(null, "y", pos.y - offset);
        if (nextSibling) {
          parent.insertBefore(node, nextSibling);
        } else if (parent) {
          parent.appendChild(node);
        }
      } else {
        node.setAttributeNS(null, "r", style.pointRadius);
      }
      var rotation = style.rotation;
      if ((rotation !== undefined || node._rotation !== undefined) && pos) {
        node._rotation = rotation;
        rotation |= 0;
        if (node.nodeName !== "svg") {
          node.setAttributeNS(
            null,
            "transform",
            "rotate(" + rotation + " " + pos.x + " " + pos.y + ")"
          );
        } else {
          var metrics = this.symbolMetrics[src.id];
          node.firstChild.setAttributeNS(
            null,
            "transform",
            "rotate(" + rotation + " " + metrics[1] + " " + metrics[2] + ")"
          );
        }
      }
    }
    if (options.isFilled) {
      node.setAttributeNS(null, "fill", style.fillColor);
      node.setAttributeNS(null, "fill-opacity", style.fillOpacity);
    } else {
      node.setAttributeNS(null, "fill", "none");
    }
    if (options.isStroked) {
      node.setAttributeNS(null, "stroke", style.strokeColor);
      node.setAttributeNS(null, "stroke-opacity", style.strokeOpacity);
      node.setAttributeNS(
        null,
        "stroke-width",
        style.strokeWidth * widthFactor
      );
      node.setAttributeNS(
        null,
        "stroke-linecap",
        style.strokeLinecap || "round"
      );
      node.setAttributeNS(null, "stroke-linejoin", "round");
      style.strokeDashstyle &&
        node.setAttributeNS(
          null,
          "stroke-dasharray",
          this.dashStyle(style, widthFactor)
        );
    } else {
      node.setAttributeNS(null, "stroke", "none");
    }
    if (style.pointerEvents) {
      node.setAttributeNS(null, "pointer-events", style.pointerEvents);
    }
    if (style.cursor != null) {
      node.setAttributeNS(null, "cursor", style.cursor);
    }
    return node;
  },
  dashStyle: function(style, widthFactor) {
    var w = style.strokeWidth * widthFactor;
    var str = style.strokeDashstyle;
    switch (str) {
      case "solid":
        return "none";
      case "dot":
        return [1, 4 * w].join();
      case "dash":
        return [4 * w, 4 * w].join();
      case "dashdot":
        return [4 * w, 4 * w, 1, 4 * w].join();
      case "longdash":
        return [8 * w, 4 * w].join();
      case "longdashdot":
        return [8 * w, 4 * w, 1, 4 * w].join();
      default:
        return OpenLayers.String.trim(str).replace(/\s+/g, ",");
    }
  },
  createNode: function(type, id) {
    var node = document.createElementNS(this.xmlns, type);
    if (id) {
      node.setAttributeNS(null, "id", id);
    }
    return node;
  },
  nodeTypeCompare: function(node, type) {
    return type == node.nodeName;
  },
  createRenderRoot: function() {
    var svg = this.nodeFactory(this.container.id + "_svgRoot", "svg");
    svg.style.display = "block";
    return svg;
  },
  createRoot: function(suffix) {
    return this.nodeFactory(this.container.id + suffix, "g");
  },
  createDefs: function() {
    var defs = this.nodeFactory(this.container.id + "_defs", "defs");
    this.rendererRoot.appendChild(defs);
    return defs;
  },
  drawPoint: function(node, geometry) {
    return this.drawCircle(node, geometry, 1);
  },
  drawCircle: function(node, geometry, radius) {
    var resolution = this.getResolution();
    var x = (geometry.x - this.featureDx) / resolution + this.left;
    var y = this.top - geometry.y / resolution;
    if (this.inValidRange(x, y)) {
      node.setAttributeNS(null, "cx", x);
      node.setAttributeNS(null, "cy", y);
      node.setAttributeNS(null, "r", radius);
      return node;
    } else {
      return false;
    }
  },
  drawLineString: function(node, geometry) {
    var componentsResult = this.getComponentsString(geometry.components);
    if (componentsResult.path) {
      node.setAttributeNS(null, "points", componentsResult.path);
      return componentsResult.complete ? node : null;
    } else {
      return false;
    }
  },
  drawLinearRing: function(node, geometry) {
    var componentsResult = this.getComponentsString(geometry.components);
    if (componentsResult.path) {
      node.setAttributeNS(null, "points", componentsResult.path);
      return componentsResult.complete ? node : null;
    } else {
      return false;
    }
  },
  drawPolygon: function(node, geometry) {
    var d = "";
    var draw = true;
    var complete = true;
    var linearRingResult, path;
    for (var j = 0, len = geometry.components.length; j < len; j++) {
      d += " M";
      linearRingResult = this.getComponentsString(
        geometry.components[j].components,
        " "
      );
      path = linearRingResult.path;
      if (path) {
        d += " " + path;
        complete = linearRingResult.complete && complete;
      } else {
        draw = false;
      }
    }
    d += " z";
    if (draw) {
      node.setAttributeNS(null, "d", d);
      node.setAttributeNS(null, "fill-rule", "evenodd");
      return complete ? node : null;
    } else {
      return false;
    }
  },
  drawRectangle: function(node, geometry) {
    var resolution = this.getResolution();
    var x = (geometry.x - this.featureDx) / resolution + this.left;
    var y = this.top - geometry.y / resolution;
    if (this.inValidRange(x, y)) {
      node.setAttributeNS(null, "x", x);
      node.setAttributeNS(null, "y", y);
      node.setAttributeNS(null, "width", geometry.width / resolution);
      node.setAttributeNS(null, "height", geometry.height / resolution);
      return node;
    } else {
      return false;
    }
  },
  drawText: function(featureId, style, location) {
    var drawOutline = !!style.labelOutlineWidth;
    if (drawOutline) {
      var outlineStyle = OpenLayers.Util.extend({}, style);
      outlineStyle.fontColor = outlineStyle.labelOutlineColor;
      outlineStyle.fontStrokeColor = outlineStyle.labelOutlineColor;
      outlineStyle.fontStrokeWidth = style.labelOutlineWidth;
      delete outlineStyle.labelOutlineWidth;
      this.drawText(featureId, outlineStyle, location);
    }
    var resolution = this.getResolution();
    var x = (location.x - this.featureDx) / resolution + this.left;
    var y = location.y / resolution - this.top;
    var suffix = drawOutline ? this.LABEL_OUTLINE_SUFFIX : this.LABEL_ID_SUFFIX;
    var label = this.nodeFactory(featureId + suffix, "text");
    label.setAttributeNS(null, "x", x);
    label.setAttributeNS(null, "y", -y);
    if (style.fontColor) {
      label.setAttributeNS(null, "fill", style.fontColor);
    }
    if (style.fontStrokeColor) {
      label.setAttributeNS(null, "stroke", style.fontStrokeColor);
    }
    if (style.fontStrokeWidth) {
      label.setAttributeNS(null, "stroke-width", style.fontStrokeWidth);
    }
    if (style.fontOpacity) {
      label.setAttributeNS(null, "opacity", style.fontOpacity);
    }
    if (style.fontFamily) {
      label.setAttributeNS(null, "font-family", style.fontFamily);
    }
    if (style.fontSize) {
      label.setAttributeNS(null, "font-size", style.fontSize);
    }
    if (style.fontWeight) {
      label.setAttributeNS(null, "font-weight", style.fontWeight);
    }
    if (style.fontStyle) {
      label.setAttributeNS(null, "font-style", style.fontStyle);
    }
    if (style.labelSelect === true) {
      label.setAttributeNS(null, "pointer-events", "visible");
      label._featureId = featureId;
    } else {
      label.setAttributeNS(null, "pointer-events", "none");
    }
    var align =
      style.labelAlign || OpenLayers.Renderer.defaultSymbolizer.labelAlign;
    label.setAttributeNS(
      null,
      "text-anchor",
      OpenLayers.Renderer.SVG.LABEL_ALIGN[align[0]] || "middle"
    );
    if (OpenLayers.IS_GECKO === true) {
      label.setAttributeNS(
        null,
        "dominant-baseline",
        OpenLayers.Renderer.SVG.LABEL_ALIGN[align[1]] || "central"
      );
    }
    var labelRows = style.label.split("\n");
    var numRows = labelRows.length;
    while (label.childNodes.length > numRows) {
      label.removeChild(label.lastChild);
    }
    for (var i = 0; i < numRows; i++) {
      var tspan = this.nodeFactory(featureId + suffix + "_tspan_" + i, "tspan");
      if (style.labelSelect === true) {
        tspan._featureId = featureId;
        tspan._geometry = location;
        tspan._geometryClass = location.CLASS_NAME;
      }
      if (OpenLayers.IS_GECKO === false) {
        tspan.setAttributeNS(
          null,
          "baseline-shift",
          OpenLayers.Renderer.SVG.LABEL_VSHIFT[align[1]] || "-35%"
        );
      }
      tspan.setAttribute("x", x);
      if (i == 0) {
        var vfactor = OpenLayers.Renderer.SVG.LABEL_VFACTOR[align[1]];
        if (vfactor == null) {
          vfactor = -0.5;
        }
        tspan.setAttribute("dy", vfactor * (numRows - 1) + "em");
      } else {
        tspan.setAttribute("dy", "1em");
      }
      tspan.textContent = labelRows[i] === "" ? " " : labelRows[i];
      if (!tspan.parentNode) {
        label.appendChild(tspan);
      }
    }
    if (!label.parentNode) {
      this.textRoot.appendChild(label);
    }
  },
  getComponentsString: function(components, separator) {
    var renderCmp = [];
    var complete = true;
    var len = components.length;
    var strings = [];
    var str, component;
    for (var i = 0; i < len; i++) {
      component = components[i];
      renderCmp.push(component);
      str = this.getShortString(component);
      if (str) {
        strings.push(str);
      } else {
        if (i > 0) {
          if (this.getShortString(components[i - 1])) {
            strings.push(this.clipLine(components[i], components[i - 1]));
          }
        }
        if (i < len - 1) {
          if (this.getShortString(components[i + 1])) {
            strings.push(this.clipLine(components[i], components[i + 1]));
          }
        }
        complete = false;
      }
    }
    return { path: strings.join(separator || ","), complete: complete };
  },
  clipLine: function(badComponent, goodComponent) {
    if (goodComponent.equals(badComponent)) {
      return "";
    }
    var resolution = this.getResolution();
    var maxX = this.MAX_PIXEL - this.translationParameters.x;
    var maxY = this.MAX_PIXEL - this.translationParameters.y;
    var x1 = (goodComponent.x - this.featureDx) / resolution + this.left;
    var y1 = this.top - goodComponent.y / resolution;
    var x2 = (badComponent.x - this.featureDx) / resolution + this.left;
    var y2 = this.top - badComponent.y / resolution;
    var k;
    if (x2 < -maxX || x2 > maxX) {
      k = (y2 - y1) / (x2 - x1);
      x2 = x2 < 0 ? -maxX : maxX;
      y2 = y1 + (x2 - x1) * k;
    }
    if (y2 < -maxY || y2 > maxY) {
      k = (x2 - x1) / (y2 - y1);
      y2 = y2 < 0 ? -maxY : maxY;
      x2 = x1 + (y2 - y1) * k;
    }
    return x2 + "," + y2;
  },
  getShortString: function(point) {
    var resolution = this.getResolution();
    var x = (point.x - this.featureDx) / resolution + this.left;
    var y = this.top - point.y / resolution;
    if (this.inValidRange(x, y)) {
      return x + "," + y;
    } else {
      return false;
    }
  },
  getPosition: function(node) {
    return {
      x: parseFloat(node.getAttributeNS(null, "cx")),
      y: parseFloat(node.getAttributeNS(null, "cy"))
    };
  },
  importSymbol: function(graphicName) {
    if (!this.defs) {
      this.defs = this.createDefs();
    }
    var id = this.container.id + "-" + graphicName;
    var existing = document.getElementById(id);
    if (existing != null) {
      return existing;
    }
    var symbol = OpenLayers.Renderer.symbol[graphicName];
    if (!symbol) {
      throw new Error(graphicName + " is not a valid symbol name");
    }
    var symbolNode = this.nodeFactory(id, "symbol");
    var node = this.nodeFactory(null, "polygon");
    symbolNode.appendChild(node);
    var symbolExtent = new OpenLayers.Bounds(
      Number.MAX_VALUE,
      Number.MAX_VALUE,
      0,
      0
    );
    var points = [];
    var x, y;
    for (var i = 0; i < symbol.length; i = i + 2) {
      x = symbol[i];
      y = symbol[i + 1];
      symbolExtent.left = Math.min(symbolExtent.left, x);
      symbolExtent.bottom = Math.min(symbolExtent.bottom, y);
      symbolExtent.right = Math.max(symbolExtent.right, x);
      symbolExtent.top = Math.max(symbolExtent.top, y);
      points.push(x, ",", y);
    }
    node.setAttributeNS(null, "points", points.join(" "));
    var width = symbolExtent.getWidth();
    var height = symbolExtent.getHeight();
    var viewBox = [
      symbolExtent.left - width,
      symbolExtent.bottom - height,
      width * 3,
      height * 3
    ];
    symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" "));
    this.symbolMetrics[id] = [
      Math.max(width, height),
      symbolExtent.getCenterLonLat().lon,
      symbolExtent.getCenterLonLat().lat
    ];
    this.defs.appendChild(symbolNode);
    return symbolNode;
  },
  getFeatureIdFromEvent: function(evt) {
    var featureId = OpenLayers.Renderer.Elements.prototype.getFeatureIdFromEvent.apply(
      this,
      arguments
    );
    if (!featureId) {
      var target = evt.target;
      featureId =
        target.parentNode && target != this.rendererRoot
          ? target.parentNode._featureId
          : undefined;
    }
    return featureId;
  },
  CLASS_NAME: "OpenLayers.Renderer.SVG"
});
OpenLayers.Renderer.SVG.LABEL_ALIGN = {
  l: "start",
  r: "end",
  b: "bottom",
  t: "hanging"
};
OpenLayers.Renderer.SVG.LABEL_VSHIFT = { t: "-70%", b: "0" };
OpenLayers.Renderer.SVG.LABEL_VFACTOR = { t: 0, b: -1 };
OpenLayers.Renderer.SVG.preventDefault = function(e) {
  e.preventDefault && e.preventDefault();
};
OpenLayers.Format = OpenLayers.Class({
  options: null,
  externalProjection: null,
  internalProjection: null,
  data: null,
  keepData: false,
  initialize: function(options) {
    OpenLayers.Util.extend(this, options);
    this.options = options;
  },
  destroy: function() {},
  read: function(data) {
    throw new Error("Read not implemented.");
  },
  write: function(object) {
    throw new Error("Write not implemented.");
  },
  CLASS_NAME: "OpenLayers.Format"
});
OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, {
  indent: "    ",
  space: " ",
  newline: "\n",
  level: 0,
  pretty: false,
  nativeJSON: (function() {
    return !!(
      window.JSON &&
      typeof JSON.parse == "function" &&
      typeof JSON.stringify == "function"
    );
  })(),
  read: function(json, filter) {
    var object;
    if (this.nativeJSON) {
      object = JSON.parse(json, filter);
    } else
      try {
        if (
          /^[\],:{}\s]*$/.test(
            json
              .replace(/\\["\\\/bfnrtu]/g, "@")
              .replace(
                /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
                "]"
              )
              .replace(/(?:^|:|,)(?:\s*\[)+/g, "")
          )
        ) {
          object = eval("(" + json + ")");
          if (typeof filter === "function") {
            function walk(k, v) {
              if (v && typeof v === "object") {
                for (var i in v) {
                  if (v.hasOwnProperty(i)) {
                    v[i] = walk(i, v[i]);
                  }
                }
              }
              return filter(k, v);
            }
            object = walk("", object);
          }
        }
      } catch (e) {}
    if (this.keepData) {
      this.data = object;
    }
    return object;
  },
  write: function(value, pretty) {
    this.pretty = !!pretty;
    var json = null;
    var type = typeof value;
    if (this.serialize[type]) {
      try {
        json =
          !this.pretty && this.nativeJSON
            ? JSON.stringify(value)
            : this.serialize[type].apply(this, [value]);
      } catch (err) {
        OpenLayers.Console.error("Trouble serializing: " + err);
      }
    }
    return json;
  },
  writeIndent: function() {
    var pieces = [];
    if (this.pretty) {
      for (var i = 0; i < this.level; ++i) {
        pieces.push(this.indent);
      }
    }
    return pieces.join("");
  },
  writeNewline: function() {
    return this.pretty ? this.newline : "";
  },
  writeSpace: function() {
    return this.pretty ? this.space : "";
  },
  serialize: {
    object: function(object) {
      if (object == null) {
        return "null";
      }
      if (object.constructor == Date) {
        return this.serialize.date.apply(this, [object]);
      }
      if (object.constructor == Array) {
        return this.serialize.array.apply(this, [object]);
      }
      var pieces = ["{"];
      this.level += 1;
      var key, keyJSON, valueJSON;
      var addComma = false;
      for (key in object) {
        if (object.hasOwnProperty(key)) {
          keyJSON = OpenLayers.Format.JSON.prototype.write.apply(this, [
            key,
            this.pretty
          ]);
          valueJSON = OpenLayers.Format.JSON.prototype.write.apply(this, [
            object[key],
            this.pretty
          ]);
          if (keyJSON != null && valueJSON != null) {
            if (addComma) {
              pieces.push(",");
            }
            pieces.push(
              this.writeNewline(),
              this.writeIndent(),
              keyJSON,
              ":",
              this.writeSpace(),
              valueJSON
            );
            addComma = true;
          }
        }
      }
      this.level -= 1;
      pieces.push(this.writeNewline(), this.writeIndent(), "}");
      return pieces.join("");
    },
    array: function(array) {
      var json;
      var pieces = ["["];
      this.level += 1;
      for (var i = 0, len = array.length; i < len; ++i) {
        json = OpenLayers.Format.JSON.prototype.write.apply(this, [
          array[i],
          this.pretty
        ]);
        if (json != null) {
          if (i > 0) {
            pieces.push(",");
          }
          pieces.push(this.writeNewline(), this.writeIndent(), json);
        }
      }
      this.level -= 1;
      pieces.push(this.writeNewline(), this.writeIndent(), "]");
      return pieces.join("");
    },
    string: function(string) {
      var m = {
        "\b": "\\b",
        "\t": "\\t",
        "\n": "\\n",
        "\f": "\\f",
        "\r": "\\r",
        '"': '\\"',
        "\\": "\\\\"
      };
      if (/["\\\x00-\x1f]/.test(string)) {
        return (
          '"' +
          string.replace(/([\x00-\x1f\\"])/g, function(a, b) {
            var c = m[b];
            if (c) {
              return c;
            }
            c = b.charCodeAt();
            return (
              "\\u00" + Math.floor(c / 16).toString(16) + (c % 16).toString(16)
            );
          }) +
          '"'
        );
      }
      return '"' + string + '"';
    },
    number: function(number) {
      return isFinite(number) ? String(number) : "null";
    },
    boolean: function(bool) {
      return String(bool);
    },
    date: function(date) {
      function format(number) {
        return number < 10 ? "0" + number : number;
      }
      return (
        '"' +
        date.getFullYear() +
        "-" +
        format(date.getMonth() + 1) +
        "-" +
        format(date.getDate()) +
        "T" +
        format(date.getHours()) +
        ":" +
        format(date.getMinutes()) +
        ":" +
        format(date.getSeconds()) +
        '"'
      );
    }
  },
  CLASS_NAME: "OpenLayers.Format.JSON"
});
OpenLayers.Format.GeoJSON = OpenLayers.Class(OpenLayers.Format.JSON, {
  ignoreExtraDims: false,
  read: function(json, type, filter) {
    type = type ? type : "FeatureCollection";
    var results = null;
    var obj = null;
    if (typeof json == "string") {
      obj = OpenLayers.Format.JSON.prototype.read.apply(this, [json, filter]);
    } else {
      obj = json;
    }
    if (!obj) {
      OpenLayers.Console.error("Bad JSON: " + json);
    } else if (typeof obj.type != "string") {
      OpenLayers.Console.error("Bad GeoJSON - no type: " + json);
    } else if (this.isValidType(obj, type)) {
      switch (type) {
        case "Geometry":
          try {
            results = this.parseGeometry(obj);
          } catch (err) {
            OpenLayers.Console.error(err);
          }
          break;
        case "Feature":
          try {
            results = this.parseFeature(obj);
            results.type = "Feature";
          } catch (err) {
            OpenLayers.Console.error(err);
          }
          break;
        case "FeatureCollection":
          results = [];
          switch (obj.type) {
            case "Feature":
              try {
                results.push(this.parseFeature(obj));
              } catch (err) {
                results = null;
                OpenLayers.Console.error(err);
              }
              break;
            case "FeatureCollection":
              for (var i = 0, len = obj.features.length; i < len; ++i) {
                try {
                  results.push(this.parseFeature(obj.features[i]));
                } catch (err) {
                  results = null;
                  OpenLayers.Console.error(err);
                }
              }
              break;
            default:
              try {
                var geom = this.parseGeometry(obj);
                results.push(new OpenLayers.Feature.Vector(geom));
              } catch (err) {
                results = null;
                OpenLayers.Console.error(err);
              }
          }
          break;
      }
    }
    return results;
  },
  isValidType: function(obj, type) {
    var valid = false;
    switch (type) {
      case "Geometry":
        if (
          OpenLayers.Util.indexOf(
            [
              "Point",
              "MultiPoint",
              "LineString",
              "MultiLineString",
              "Polygon",
              "MultiPolygon",
              "Box",
              "GeometryCollection"
            ],
            obj.type
          ) == -1
        ) {
          OpenLayers.Console.error("Unsupported geometry type: " + obj.type);
        } else {
          valid = true;
        }
        break;
      case "FeatureCollection":
        valid = true;
        break;
      default:
        if (obj.type == type) {
          valid = true;
        } else {
          OpenLayers.Console.error(
            "Cannot convert types from " + obj.type + " to " + type
          );
        }
    }
    return valid;
  },
  parseFeature: function(obj) {
    var feature, geometry, attributes, bbox;
    attributes = obj.properties ? obj.properties : {};
    bbox = (obj.geometry && obj.geometry.bbox) || obj.bbox;
    try {
      geometry = this.parseGeometry(obj.geometry);
    } catch (err) {
      throw err;
    }
    feature = new OpenLayers.Feature.Vector(geometry, attributes);
    if (bbox) {
      feature.bounds = OpenLayers.Bounds.fromArray(bbox);
    }
    if (obj.id) {
      feature.fid = obj.id;
    }
    return feature;
  },
  parseGeometry: function(obj) {
    if (obj == null) {
      return null;
    }
    var geometry,
      collection = false;
    if (obj.type == "GeometryCollection") {
      if (!OpenLayers.Util.isArray(obj.geometries)) {
        throw "GeometryCollection must have geometries array: " + obj;
      }
      var numGeom = obj.geometries.length;
      var components = new Array(numGeom);
      for (var i = 0; i < numGeom; ++i) {
        components[i] = this.parseGeometry.apply(this, [obj.geometries[i]]);
      }
      geometry = new OpenLayers.Geometry.Collection(components);
      collection = true;
    } else {
      if (!OpenLayers.Util.isArray(obj.coordinates)) {
        throw "Geometry must have coordinates array: " + obj;
      }
      if (!this.parseCoords[obj.type.toLowerCase()]) {
        throw "Unsupported geometry type: " + obj.type;
      }
      try {
        geometry = this.parseCoords[obj.type.toLowerCase()].apply(this, [
          obj.coordinates
        ]);
      } catch (err) {
        throw err;
      }
    }
    if (this.internalProjection && this.externalProjection && !collection) {
      geometry.transform(this.externalProjection, this.internalProjection);
    }
    return geometry;
  },
  parseCoords: {
    point: function(array) {
      if (this.ignoreExtraDims == false && array.length != 2) {
        throw "Only 2D points are supported: " + array;
      }
      return new OpenLayers.Geometry.Point(array[0], array[1]);
    },
    multipoint: function(array) {
      var points = [];
      var p = null;
      for (var i = 0, len = array.length; i < len; ++i) {
        try {
          p = this.parseCoords["point"].apply(this, [array[i]]);
        } catch (err) {
          throw err;
        }
        points.push(p);
      }
      return new OpenLayers.Geometry.MultiPoint(points);
    },
    linestring: function(array) {
      var points = [];
      var p = null;
      for (var i = 0, len = array.length; i < len; ++i) {
        try {
          p = this.parseCoords["point"].apply(this, [array[i]]);
        } catch (err) {
          throw err;
        }
        points.push(p);
      }
      return new OpenLayers.Geometry.LineString(points);
    },
    multilinestring: function(array) {
      var lines = [];
      var l = null;
      for (var i = 0, len = array.length; i < len; ++i) {
        try {
          l = this.parseCoords["linestring"].apply(this, [array[i]]);
        } catch (err) {
          throw err;
        }
        lines.push(l);
      }
      return new OpenLayers.Geometry.MultiLineString(lines);
    },
    polygon: function(array) {
      var rings = [];
      var r, l;
      for (var i = 0, len = array.length; i < len; ++i) {
        try {
          l = this.parseCoords["linestring"].apply(this, [array[i]]);
        } catch (err) {
          throw err;
        }
        r = new OpenLayers.Geometry.LinearRing(l.components);
        rings.push(r);
      }
      return new OpenLayers.Geometry.Polygon(rings);
    },
    multipolygon: function(array) {
      var polys = [];
      var p = null;
      for (var i = 0, len = array.length; i < len; ++i) {
        try {
          p = this.parseCoords["polygon"].apply(this, [array[i]]);
        } catch (err) {
          throw err;
        }
        polys.push(p);
      }
      return new OpenLayers.Geometry.MultiPolygon(polys);
    },
    box: function(array) {
      if (array.length != 2) {
        throw "GeoJSON box coordinates must have 2 elements";
      }
      return new OpenLayers.Geometry.Polygon([
        new OpenLayers.Geometry.LinearRing([
          new OpenLayers.Geometry.Point(array[0][0], array[0][1]),
          new OpenLayers.Geometry.Point(array[1][0], array[0][1]),
          new OpenLayers.Geometry.Point(array[1][0], array[1][1]),
          new OpenLayers.Geometry.Point(array[0][0], array[1][1]),
          new OpenLayers.Geometry.Point(array[0][0], array[0][1])
        ])
      ]);
    }
  },
  write: function(obj, pretty) {
    var geojson = { type: null };
    if (OpenLayers.Util.isArray(obj)) {
      geojson.type = "FeatureCollection";
      var numFeatures = obj.length;
      geojson.features = new Array(numFeatures);
      for (var i = 0; i < numFeatures; ++i) {
        var element = obj[i];
        if (!element instanceof OpenLayers.Feature.Vector) {
          var msg =
            "FeatureCollection only supports collections " +
            "of features: " +
            element;
          throw msg;
        }
        geojson.features[i] = this.extract.feature.apply(this, [element]);
      }
    } else if (obj.CLASS_NAME.indexOf("OpenLayers.Geometry") == 0) {
      geojson = this.extract.geometry.apply(this, [obj]);
    } else if (obj instanceof OpenLayers.Feature.Vector) {
      geojson = this.extract.feature.apply(this, [obj]);
      if (obj.layer && obj.layer.projection) {
        geojson.crs = this.createCRSObject(obj);
      }
    }
    return OpenLayers.Format.JSON.prototype.write.apply(this, [
      geojson,
      pretty
    ]);
  },
  createCRSObject: function(object) {
    var proj = object.layer.projection.toString();
    var crs = {};
    if (proj.match(/epsg:/i)) {
      var code = parseInt(proj.substring(proj.indexOf(":") + 1));
      if (code == 4326) {
        crs = {
          type: "name",
          properties: { name: "urn:ogc:def:crs:OGC:1.3:CRS84" }
        };
      } else {
        crs = { type: "name", properties: { name: "EPSG:" + code } };
      }
    }
    return crs;
  },
  extract: {
    feature: function(feature) {
      var geom = this.extract.geometry.apply(this, [feature.geometry]);
      var json = {
        type: "Feature",
        properties: feature.attributes,
        geometry: geom
      };
      if (feature.fid != null) {
        json.id = feature.fid;
      }
      return json;
    },
    geometry: function(geometry) {
      if (geometry == null) {
        return null;
      }
      if (this.internalProjection && this.externalProjection) {
        geometry = geometry.clone();
        geometry.transform(this.internalProjection, this.externalProjection);
      }
      var geometryType = geometry.CLASS_NAME.split(".")[2];
      var data = this.extract[geometryType.toLowerCase()].apply(this, [
        geometry
      ]);
      var json;
      if (geometryType == "Collection") {
        json = { type: "GeometryCollection", geometries: data };
      } else {
        json = { type: geometryType, coordinates: data };
      }
      return json;
    },
    point: function(point) {
      return [point.x, point.y];
    },
    multipoint: function(multipoint) {
      var array = [];
      for (var i = 0, len = multipoint.components.length; i < len; ++i) {
        array.push(this.extract.point.apply(this, [multipoint.components[i]]));
      }
      return array;
    },
    linestring: function(linestring) {
      var array = [];
      for (var i = 0, len = linestring.components.length; i < len; ++i) {
        array.push(this.extract.point.apply(this, [linestring.components[i]]));
      }
      return array;
    },
    multilinestring: function(multilinestring) {
      var array = [];
      for (var i = 0, len = multilinestring.components.length; i < len; ++i) {
        array.push(
          this.extract.linestring.apply(this, [multilinestring.components[i]])
        );
      }
      return array;
    },
    polygon: function(polygon) {
      var array = [];
      for (var i = 0, len = polygon.components.length; i < len; ++i) {
        array.push(
          this.extract.linestring.apply(this, [polygon.components[i]])
        );
      }
      return array;
    },
    multipolygon: function(multipolygon) {
      var array = [];
      for (var i = 0, len = multipolygon.components.length; i < len; ++i) {
        array.push(
          this.extract.polygon.apply(this, [multipolygon.components[i]])
        );
      }
      return array;
    },
    collection: function(collection) {
      var len = collection.components.length;
      var array = new Array(len);
      for (var i = 0; i < len; ++i) {
        array[i] = this.extract.geometry.apply(this, [
          collection.components[i]
        ]);
      }
      return array;
    }
  },
  CLASS_NAME: "OpenLayers.Format.GeoJSON"
});
OpenLayers.Popup = OpenLayers.Class({
  events: null,
  id: "",
  lonlat: null,
  div: null,
  contentSize: null,
  size: null,
  contentHTML: null,
  backgroundColor: "",
  opacity: "",
  border: "",
  contentDiv: null,
  groupDiv: null,
  closeDiv: null,
  autoSize: false,
  minSize: null,
  maxSize: null,
  displayClass: "olPopup",
  contentDisplayClass: "olPopupContent",
  padding: 0,
  disableFirefoxOverflowHack: false,
  fixPadding: function() {
    if (typeof this.padding == "number") {
      this.padding = new OpenLayers.Bounds(
        this.padding,
        this.padding,
        this.padding,
        this.padding
      );
    }
  },
  panMapIfOutOfView: false,
  keepInMap: false,
  closeOnMove: false,
  map: null,
  initialize: function(
    id,
    lonlat,
    contentSize,
    contentHTML,
    closeBox,
    closeBoxCallback
  ) {
    if (id == null) {
      id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
    }
    this.id = id;
    this.lonlat = lonlat;
    this.contentSize =
      contentSize != null
        ? contentSize
        : 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,
      null,
      null,
      null,
      null,
      null,
      "hidden"
    );
    this.div.className = this.displayClass;
    var groupDivId = this.id + "_GroupDiv";
    this.groupDiv = OpenLayers.Util.createDiv(
      groupDivId,
      null,
      null,
      null,
      "relative",
      null,
      "hidden"
    );
    var id = this.div.id + "_contentDiv";
    this.contentDiv = OpenLayers.Util.createDiv(
      id,
      null,
      this.contentSize.clone(),
      null,
      "relative"
    );
    this.contentDiv.className = this.contentDisplayClass;
    this.groupDiv.appendChild(this.contentDiv);
    this.div.appendChild(this.groupDiv);
    if (closeBox) {
      this.addCloseBox(closeBoxCallback);
    }
    this.registerEvents();
  },
  destroy: function() {
    this.id = null;
    this.lonlat = null;
    this.size = null;
    this.contentHTML = null;
    this.backgroundColor = null;
    this.opacity = null;
    this.border = null;
    if (this.closeOnMove && this.map) {
      this.map.events.unregister("movestart", this, this.hide);
    }
    this.events.destroy();
    this.events = null;
    if (this.closeDiv) {
      OpenLayers.Event.stopObservingElement(this.closeDiv);
      this.groupDiv.removeChild(this.closeDiv);
    }
    this.closeDiv = null;
    this.div.removeChild(this.groupDiv);
    this.groupDiv = null;
    if (this.map != null) {
      this.map.removePopup(this);
    }
    this.map = null;
    this.div = null;
    this.autoSize = null;
    this.minSize = null;
    this.maxSize = null;
    this.padding = null;
    this.panMapIfOutOfView = null;
  },
  draw: function(px) {
    if (px == null) {
      if (this.lonlat != null && this.map != null) {
        px = this.map.getLayerPxFromLonLat(this.lonlat);
      }
    }
    if (this.closeOnMove) {
      this.map.events.register("movestart", this, this.hide);
    }
    if (
      !this.disableFirefoxOverflowHack &&
      OpenLayers.BROWSER_NAME == "firefox"
    ) {
      this.map.events.register("movestart", this, function() {
        var style = document.defaultView.getComputedStyle(
          this.contentDiv,
          null
        );
        var currentOverflow = style.getPropertyValue("overflow");
        if (currentOverflow != "hidden") {
          this.contentDiv._oldOverflow = currentOverflow;
          this.contentDiv.style.overflow = "hidden";
        }
      });
      this.map.events.register("moveend", this, function() {
        var oldOverflow = this.contentDiv._oldOverflow;
        if (oldOverflow) {
          this.contentDiv.style.overflow = oldOverflow;
          this.contentDiv._oldOverflow = null;
        }
      });
    }
    this.moveTo(px);
    if (!this.autoSize && !this.size) {
      this.setSize(this.contentSize);
    }
    this.setBackgroundColor();
    this.setOpacity();
    this.setBorder();
    this.setContentHTML();
    if (this.panMapIfOutOfView) {
      this.panIntoView();
    }
    return this.div;
  },
  updatePosition: function() {
    if (this.lonlat && this.map) {
      var px = this.map.getLayerPxFromLonLat(this.lonlat);
      if (px) {
        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 OpenLayers.Element.visible(this.div);
  },
  toggle: function() {
    if (this.visible()) {
      this.hide();
    } else {
      this.show();
    }
  },
  show: function() {
    this.div.style.display = "";
    if (this.panMapIfOutOfView) {
      this.panIntoView();
    }
  },
  hide: function() {
    this.div.style.display = "none";
  },
  setSize: function(contentSize) {
    this.size = contentSize.clone();
    var contentDivPadding = this.getContentDivPadding();
    var wPadding = contentDivPadding.left + contentDivPadding.right;
    var hPadding = contentDivPadding.top + contentDivPadding.bottom;
    this.fixPadding();
    wPadding += this.padding.left + this.padding.right;
    hPadding += this.padding.top + this.padding.bottom;
    if (this.closeDiv) {
      var closeDivWidth = parseInt(this.closeDiv.style.width);
      wPadding += closeDivWidth + contentDivPadding.right;
    }
    this.size.w += wPadding;
    this.size.h += hPadding;
    if (OpenLayers.BROWSER_NAME == "msie") {
      this.contentSize.w += contentDivPadding.left + contentDivPadding.right;
      this.contentSize.h += contentDivPadding.bottom + contentDivPadding.top;
    }
    if (this.div != null) {
      this.div.style.width = this.size.w + "px";
      this.div.style.height = this.size.h + "px";
    }
    if (this.contentDiv != null) {
      this.contentDiv.style.width = contentSize.w + "px";
      this.contentDiv.style.height = contentSize.h + "px";
    }
  },
  updateSize: function() {
    var preparedHTML =
      "<div class='" +
      this.contentDisplayClass +
      "'>" +
      this.contentDiv.innerHTML +
      "</div>";
    var containerElement = this.map ? this.map.div : document.body;
    var realSize = OpenLayers.Util.getRenderedDimensions(preparedHTML, null, {
      displayClass: this.displayClass,
      containerElement: containerElement
    });
    var safeSize = this.getSafeContentSize(realSize);
    var newSize = null;
    if (safeSize.equals(realSize)) {
      newSize = realSize;
    } else {
      var fixedSize = {
        w: safeSize.w < realSize.w ? safeSize.w : null,
        h: safeSize.h < realSize.h ? safeSize.h : null
      };
      if (fixedSize.w && fixedSize.h) {
        newSize = safeSize;
      } else {
        var clippedSize = OpenLayers.Util.getRenderedDimensions(
          preparedHTML,
          fixedSize,
          {
            displayClass: this.contentDisplayClass,
            containerElement: containerElement
          }
        );
        var currentOverflow = OpenLayers.Element.getStyle(
          this.contentDiv,
          "overflow"
        );
        if (currentOverflow != "hidden" && clippedSize.equals(safeSize)) {
          var scrollBar = OpenLayers.Util.getScrollbarWidth();
          if (fixedSize.w) {
            clippedSize.h += scrollBar;
          } else {
            clippedSize.w += scrollBar;
          }
        }
        newSize = this.getSafeContentSize(clippedSize);
      }
    }
    this.setSize(newSize);
  },
  setBackgroundColor: function(color) {
    if (color != undefined) {
      this.backgroundColor = color;
    }
    if (this.div != null) {
      this.div.style.backgroundColor = this.backgroundColor;
    }
  },
  setOpacity: function(opacity) {
    if (opacity != undefined) {
      this.opacity = opacity;
    }
    if (this.div != null) {
      this.div.style.opacity = this.opacity;
      this.div.style.filter = "alpha(opacity=" + this.opacity * 100 + ")";
    }
  },
  setBorder: function(border) {
    if (border != undefined) {
      this.border = border;
    }
    if (this.div != null) {
      this.div.style.border = this.border;
    }
  },
  setContentHTML: function(contentHTML) {
    if (contentHTML != null) {
      this.contentHTML = contentHTML;
    }
    if (
      this.contentDiv != null &&
      this.contentHTML != null &&
      this.contentHTML != this.contentDiv.innerHTML
    ) {
      this.contentDiv.innerHTML = this.contentHTML;
      if (this.autoSize) {
        this.registerImageListeners();
        this.updateSize();
      }
    }
  },
  registerImageListeners: function() {
    var onImgLoad = function() {
      if (this.popup.id === null) {
        return;
      }
      this.popup.updateSize();
      if (this.popup.visible() && this.popup.panMapIfOutOfView) {
        this.popup.panIntoView();
      }
      OpenLayers.Event.stopObserving(this.img, "load", this.img._onImageLoad);
    };
    var images = this.contentDiv.getElementsByTagName("img");
    for (var i = 0, len = images.length; i < len; i++) {
      var img = images[i];
      if (img.width == 0 || img.height == 0) {
        var context = { popup: this, img: img };
        img._onImgLoad = OpenLayers.Function.bind(onImgLoad, context);
        OpenLayers.Event.observe(img, "load", img._onImgLoad);
      }
    }
  },
  getSafeContentSize: function(size) {
    var safeContentSize = size.clone();
    var contentDivPadding = this.getContentDivPadding();
    var wPadding = contentDivPadding.left + contentDivPadding.right;
    var hPadding = contentDivPadding.top + contentDivPadding.bottom;
    this.fixPadding();
    wPadding += this.padding.left + this.padding.right;
    hPadding += this.padding.top + this.padding.bottom;
    if (this.closeDiv) {
      var closeDivWidth = parseInt(this.closeDiv.style.width);
      wPadding += closeDivWidth + contentDivPadding.right;
    }
    if (this.minSize) {
      safeContentSize.w = Math.max(
        safeContentSize.w,
        this.minSize.w - wPadding
      );
      safeContentSize.h = Math.max(
        safeContentSize.h,
        this.minSize.h - hPadding
      );
    }
    if (this.maxSize) {
      safeContentSize.w = Math.min(
        safeContentSize.w,
        this.maxSize.w - wPadding
      );
      safeContentSize.h = Math.min(
        safeContentSize.h,
        this.maxSize.h - hPadding
      );
    }
    if (this.map && this.map.size) {
      var extraX = 0,
        extraY = 0;
      if (this.keepInMap && !this.panMapIfOutOfView) {
        var px = this.map.getPixelFromLonLat(this.lonlat);
        switch (this.relativePosition) {
          case "tr":
            extraX = px.x;
            extraY = this.map.size.h - px.y;
            break;
          case "tl":
            extraX = this.map.size.w - px.x;
            extraY = this.map.size.h - px.y;
            break;
          case "bl":
            extraX = this.map.size.w - px.x;
            extraY = px.y;
            break;
          case "br":
            extraX = px.x;
            extraY = px.y;
            break;
          default:
            extraX = px.x;
            extraY = this.map.size.h - px.y;
            break;
        }
      }
      var maxY =
        this.map.size.h -
        this.map.paddingForPopups.top -
        this.map.paddingForPopups.bottom -
        hPadding -
        extraY;
      var maxX =
        this.map.size.w -
        this.map.paddingForPopups.left -
        this.map.paddingForPopups.right -
        wPadding -
        extraX;
      safeContentSize.w = Math.min(safeContentSize.w, maxX);
      safeContentSize.h = Math.min(safeContentSize.h, maxY);
    }
    return safeContentSize;
  },
  getContentDivPadding: function() {
    var contentDivPadding = this._contentDivPadding;
    if (!contentDivPadding) {
      if (this.div.parentNode == null) {
        this.div.style.display = "none";
        document.body.appendChild(this.div);
      }
      contentDivPadding = new OpenLayers.Bounds(
        OpenLayers.Element.getStyle(this.contentDiv, "padding-left"),
        OpenLayers.Element.getStyle(this.contentDiv, "padding-bottom"),
        OpenLayers.Element.getStyle(this.contentDiv, "padding-right"),
        OpenLayers.Element.getStyle(this.contentDiv, "padding-top")
      );
      this._contentDivPadding = contentDivPadding;
      if (this.div.parentNode == document.body) {
        document.body.removeChild(this.div);
        this.div.style.display = "";
      }
    }
    return contentDivPadding;
  },
  addCloseBox: function(callback) {
    this.closeDiv = OpenLayers.Util.createDiv(this.id + "_close", null, {
      w: 17,
      h: 17
    });
    this.closeDiv.className = "olPopupCloseBox";
    var contentDivPadding = this.getContentDivPadding();
    this.closeDiv.style.right = contentDivPadding.right + "px";
    this.closeDiv.style.top = contentDivPadding.top + "px";
    this.groupDiv.appendChild(this.closeDiv);
    var closePopup =
      callback ||
      function(e) {
        this.hide();
        OpenLayers.Event.stop(e);
      };
    OpenLayers.Event.observe(
      this.closeDiv,
      "touchend",
      OpenLayers.Function.bindAsEventListener(closePopup, this)
    );
    OpenLayers.Event.observe(
      this.closeDiv,
      "click",
      OpenLayers.Function.bindAsEventListener(closePopup, this)
    );
  },
  panIntoView: function() {
    var mapSize = this.map.getSize();
    var origTL = this.map.getViewPortPxFromLayerPx(
      new OpenLayers.Pixel(
        parseInt(this.div.style.left),
        parseInt(this.div.style.top)
      )
    );
    var newTL = origTL.clone();
    if (origTL.x < this.map.paddingForPopups.left) {
      newTL.x = this.map.paddingForPopups.left;
    } else if (
      origTL.x + this.size.w >
      mapSize.w - this.map.paddingForPopups.right
    ) {
      newTL.x = mapSize.w - this.map.paddingForPopups.right - this.size.w;
    }
    if (origTL.y < this.map.paddingForPopups.top) {
      newTL.y = this.map.paddingForPopups.top;
    } else if (
      origTL.y + this.size.h >
      mapSize.h - this.map.paddingForPopups.bottom
    ) {
      newTL.y = mapSize.h - this.map.paddingForPopups.bottom - this.size.h;
    }
    var dx = origTL.x - newTL.x;
    var dy = origTL.y - newTL.y;
    this.map.pan(dx, dy);
  },
  registerEvents: function() {
    this.events = new OpenLayers.Events(this, this.div, null, true);
    function onTouchstart(evt) {
      OpenLayers.Event.stop(evt, true);
    }
    this.events.on({
      mousedown: this.onmousedown,
      mousemove: this.onmousemove,
      mouseup: this.onmouseup,
      click: this.onclick,
      mouseout: this.onmouseout,
      dblclick: this.ondblclick,
      touchstart: onTouchstart,
      scope: this
    });
  },
  onmousedown: function(evt) {
    this.mousedown = true;
    OpenLayers.Event.stop(evt, true);
  },
  onmousemove: function(evt) {
    if (this.mousedown) {
      OpenLayers.Event.stop(evt, true);
    }
  },
  onmouseup: function(evt) {
    if (this.mousedown) {
      this.mousedown = false;
      OpenLayers.Event.stop(evt, true);
    }
  },
  onclick: function(evt) {
    OpenLayers.Event.stop(evt, true);
  },
  onmouseout: function(evt) {
    this.mousedown = false;
  },
  ondblclick: function(evt) {
    OpenLayers.Event.stop(evt, true);
  },
  CLASS_NAME: "OpenLayers.Popup"
});
OpenLayers.Popup.WIDTH = 200;
OpenLayers.Popup.HEIGHT = 200;
OpenLayers.Popup.COLOR = "white";
OpenLayers.Popup.OPACITY = 1;
OpenLayers.Popup.BORDER = "0px";
OpenLayers.Popup.Anchored = OpenLayers.Class(OpenLayers.Popup, {
  relativePosition: null,
  keepInMap: true,
  anchor: null,
  initialize: function(
    id,
    lonlat,
    contentSize,
    contentHTML,
    anchor,
    closeBox,
    closeBoxCallback
  ) {
    var newArguments = [
      id,
      lonlat,
      contentSize,
      contentHTML,
      closeBox,
      closeBoxCallback
    ];
    OpenLayers.Popup.prototype.initialize.apply(this, newArguments);
    this.anchor =
      anchor != null
        ? anchor
        : {
            size: new OpenLayers.Size(0, 0),
            offset: new OpenLayers.Pixel(0, 0)
          };
  },
  destroy: function() {
    this.anchor = null;
    this.relativePosition = null;
    OpenLayers.Popup.prototype.destroy.apply(this, arguments);
  },
  show: function() {
    this.updatePosition();
    OpenLayers.Popup.prototype.show.apply(this, arguments);
  },
  moveTo: function(px) {
    var oldRelativePosition = this.relativePosition;
    this.relativePosition = this.calculateRelativePosition(px);
    var newPx = this.calculateNewPx(px);
    var newArguments = new Array(newPx);
    OpenLayers.Popup.prototype.moveTo.apply(this, newArguments);
    if (this.relativePosition != oldRelativePosition) {
      this.updateRelativePosition();
    }
  },
  setSize: function(contentSize) {
    OpenLayers.Popup.prototype.setSize.apply(this, arguments);
    if (this.lonlat && this.map) {
      var px = this.map.getLayerPxFromLonLat(this.lonlat);
      this.moveTo(px);
    }
  },
  calculateRelativePosition: function(px) {
    var lonlat = this.map.getLonLatFromLayerPx(px);
    var extent = this.map.getExtent();
    var quadrant = extent.determineQuadrant(lonlat);
    return OpenLayers.Bounds.oppositeQuadrant(quadrant);
  },
  updateRelativePosition: function() {},
  calculateNewPx: function(px) {
    var newPx = px.offset(this.anchor.offset);
    var size = this.size || this.contentSize;
    var top = this.relativePosition.charAt(0) == "t";
    newPx.y += top ? -size.h : this.anchor.size.h;
    var left = this.relativePosition.charAt(1) == "l";
    newPx.x += left ? -size.w : this.anchor.size.w;
    return newPx;
  },
  CLASS_NAME: "OpenLayers.Popup.Anchored"
});
OpenLayers.Popup.Framed = OpenLayers.Class(OpenLayers.Popup.Anchored, {
  imageSrc: null,
  imageSize: null,
  isAlphaImage: false,
  positionBlocks: null,
  blocks: null,
  fixedRelativePosition: false,
  initialize: function(
    id,
    lonlat,
    contentSize,
    contentHTML,
    anchor,
    closeBox,
    closeBoxCallback
  ) {
    OpenLayers.Popup.Anchored.prototype.initialize.apply(this, arguments);
    if (this.fixedRelativePosition) {
      this.updateRelativePosition();
      this.calculateRelativePosition = function(px) {
        return this.relativePosition;
      };
    }
    this.contentDiv.style.position = "absolute";
    this.contentDiv.style.zIndex = 1;
    if (closeBox) {
      this.closeDiv.style.zIndex = 1;
    }
    this.groupDiv.style.position = "absolute";
    this.groupDiv.style.top = "0px";
    this.groupDiv.style.left = "0px";
    this.groupDiv.style.height = "100%";
    this.groupDiv.style.width = "100%";
  },
  destroy: function() {
    this.imageSrc = null;
    this.imageSize = null;
    this.isAlphaImage = null;
    this.fixedRelativePosition = false;
    this.positionBlocks = null;
    for (var i = 0; i < this.blocks.length; i++) {
      var block = this.blocks[i];
      if (block.image) {
        block.div.removeChild(block.image);
      }
      block.image = null;
      if (block.div) {
        this.groupDiv.removeChild(block.div);
      }
      block.div = null;
    }
    this.blocks = null;
    OpenLayers.Popup.Anchored.prototype.destroy.apply(this, arguments);
  },
  setBackgroundColor: function(color) {},
  setBorder: function() {},
  setOpacity: function(opacity) {},
  setSize: function(contentSize) {
    OpenLayers.Popup.Anchored.prototype.setSize.apply(this, arguments);
    this.updateBlocks();
  },
  updateRelativePosition: function() {
    this.padding = this.positionBlocks[this.relativePosition].padding;
    if (this.closeDiv) {
      var contentDivPadding = this.getContentDivPadding();
      this.closeDiv.style.right =
        contentDivPadding.right + this.padding.right + "px";
      this.closeDiv.style.top = contentDivPadding.top + this.padding.top + "px";
    }
    this.updateBlocks();
  },
  calculateNewPx: function(px) {
    var newPx = OpenLayers.Popup.Anchored.prototype.calculateNewPx.apply(
      this,
      arguments
    );
    newPx = newPx.offset(this.positionBlocks[this.relativePosition].offset);
    return newPx;
  },
  createBlocks: function() {
    this.blocks = [];
    var firstPosition = null;
    for (var key in this.positionBlocks) {
      firstPosition = key;
      break;
    }
    var position = this.positionBlocks[firstPosition];
    for (var i = 0; i < position.blocks.length; i++) {
      var block = {};
      this.blocks.push(block);
      var divId = this.id + "_FrameDecorationDiv_" + i;
      block.div = OpenLayers.Util.createDiv(
        divId,
        null,
        null,
        null,
        "absolute",
        null,
        "hidden",
        null
      );
      var imgId = this.id + "_FrameDecorationImg_" + i;
      var imageCreator = this.isAlphaImage
        ? OpenLayers.Util.createAlphaImageDiv
        : OpenLayers.Util.createImage;
      block.image = imageCreator(
        imgId,
        null,
        this.imageSize,
        this.imageSrc,
        "absolute",
        null,
        null,
        null
      );
      block.div.appendChild(block.image);
      this.groupDiv.appendChild(block.div);
    }
  },
  updateBlocks: function() {
    if (!this.blocks) {
      this.createBlocks();
    }
    if (this.size && this.relativePosition) {
      var position = this.positionBlocks[this.relativePosition];
      for (var i = 0; i < position.blocks.length; i++) {
        var positionBlock = position.blocks[i];
        var block = this.blocks[i];
        var l = positionBlock.anchor.left;
        var b = positionBlock.anchor.bottom;
        var r = positionBlock.anchor.right;
        var t = positionBlock.anchor.top;
        var w = isNaN(positionBlock.size.w)
          ? this.size.w - (r + l)
          : positionBlock.size.w;
        var h = isNaN(positionBlock.size.h)
          ? this.size.h - (b + t)
          : positionBlock.size.h;
        block.div.style.width = (w < 0 ? 0 : w) + "px";
        block.div.style.height = (h < 0 ? 0 : h) + "px";
        block.div.style.left = l != null ? l + "px" : "";
        block.div.style.bottom = b != null ? b + "px" : "";
        block.div.style.right = r != null ? r + "px" : "";
        block.div.style.top = t != null ? t + "px" : "";
        block.image.style.left = positionBlock.position.x + "px";
        block.image.style.top = positionBlock.position.y + "px";
      }
      this.contentDiv.style.left = this.padding.left + "px";
      this.contentDiv.style.top = this.padding.top + "px";
    }
  },
  CLASS_NAME: "OpenLayers.Popup.Framed"
});
OpenLayers.Layer.Google.v3 = {
  DEFAULTS: { sphericalMercator: true, projection: "EPSG:900913" },
  animationEnabled: true,
  loadMapObject: function() {
    if (!this.type) {
      this.type = google.maps.MapTypeId.ROADMAP;
    }
    var mapObject;
    var cache = OpenLayers.Layer.Google.cache[this.map.id];
    if (cache) {
      mapObject = cache.mapObject;
      ++cache.count;
    } else {
      var container = this.map.viewPortDiv;
      var div = document.createElement("div");
      div.id = this.map.id + "_GMapContainer";
      div.style.position = "absolute";
      div.style.width = "100%";
      div.style.height = "100%";
      container.appendChild(div);
      var center = this.map.getCenter();
      mapObject = new google.maps.Map(div, {
        center: center
          ? new google.maps.LatLng(center.lat, center.lon)
          : new google.maps.LatLng(0, 0),
        zoom: this.map.getZoom() || 0,
        mapTypeId: this.type,
        disableDefaultUI: true,
        keyboardShortcuts: false,
        draggable: false,
        disableDoubleClickZoom: true,
        scrollwheel: false,
        streetViewControl: false
      });
      cache = { mapObject: mapObject, count: 1 };
      OpenLayers.Layer.Google.cache[this.map.id] = cache;
      this.repositionListener = google.maps.event.addListenerOnce(
        mapObject,
        "center_changed",
        OpenLayers.Function.bind(this.repositionMapElements, this)
      );
    }
    this.mapObject = mapObject;
    this.setGMapVisibility(this.visibility);
  },
  repositionMapElements: function() {
    google.maps.event.trigger(this.mapObject, "resize");
    var div = this.mapObject.getDiv().firstChild;
    if (!div || div.childNodes.length < 3) {
      this.repositionTimer = window.setTimeout(
        OpenLayers.Function.bind(this.repositionMapElements, this),
        250
      );
      return false;
    }
    var cache = OpenLayers.Layer.Google.cache[this.map.id];
    var container = this.map.viewPortDiv;
    for (var i = div.children.length - 1; i >= 0; --i) {
      if (div.children[i].style.zIndex == 1000001) {
        var termsOfUse = div.children[i];
        container.appendChild(termsOfUse);
        termsOfUse.style.zIndex = "1100";
        termsOfUse.style.bottom = "";
        termsOfUse.className = "olLayerGoogleCopyright olLayerGoogleV3";
        termsOfUse.style.display = "";
        cache.termsOfUse = termsOfUse;
      }
      if (div.children[i].style.zIndex == 1000000) {
        var poweredBy = div.children[i];
        container.appendChild(poweredBy);
        poweredBy.style.zIndex = "1100";
        poweredBy.style.bottom = "";
        poweredBy.className =
          "olLayerGooglePoweredBy olLayerGoogleV3 gmnoprint";
        poweredBy.style.display = "";
        cache.poweredBy = poweredBy;
      }
      if (div.children[i].style.zIndex == 10000002) {
        container.appendChild(div.children[i]);
      }
    }
    this.setGMapVisibility(this.visibility);
  },
  onMapResize: function() {
    if (this.visibility) {
      google.maps.event.trigger(this.mapObject, "resize");
    } else {
      var cache = OpenLayers.Layer.Google.cache[this.map.id];
      if (!cache.resized) {
        var layer = this;
        google.maps.event.addListenerOnce(
          this.mapObject,
          "tilesloaded",
          function() {
            google.maps.event.trigger(layer.mapObject, "resize");
            layer.moveTo(layer.map.getCenter(), layer.map.getZoom());
            delete cache.resized;
          }
        );
      }
      cache.resized = true;
    }
  },
  setGMapVisibility: function(visible) {
    var cache = OpenLayers.Layer.Google.cache[this.map.id];
    if (cache) {
      var type = this.type;
      var layers = this.map.layers;
      var layer;
      for (var i = layers.length - 1; i >= 0; --i) {
        layer = layers[i];
        if (
          layer instanceof OpenLayers.Layer.Google &&
          layer.visibility === true &&
          layer.inRange === true
        ) {
          type = layer.type;
          visible = true;
          break;
        }
      }
      var container = this.mapObject.getDiv();
      if (visible === true) {
        this.mapObject.setMapTypeId(type);
        container.style.left = "";
        if (cache.termsOfUse && cache.termsOfUse.style) {
          cache.termsOfUse.style.left = "";
          cache.termsOfUse.style.display = "";
          cache.poweredBy.style.display = "";
        }
        cache.displayed = this.id;
      } else {
        delete cache.displayed;
        container.style.left = "-9999px";
        if (cache.termsOfUse && cache.termsOfUse.style) {
          cache.termsOfUse.style.display = "none";
          cache.termsOfUse.style.left = "-9999px";
          cache.poweredBy.style.display = "none";
        }
      }
    }
  },
  getMapContainer: function() {
    return this.mapObject.getDiv();
  },
  getMapObjectBoundsFromOLBounds: function(olBounds) {
    var moBounds = null;
    if (olBounds != null) {
      var sw = this.sphericalMercator
        ? this.inverseMercator(olBounds.bottom, olBounds.left)
        : new OpenLayers.LonLat(olBounds.bottom, olBounds.left);
      var ne = this.sphericalMercator
        ? this.inverseMercator(olBounds.top, olBounds.right)
        : new OpenLayers.LonLat(olBounds.top, olBounds.right);
      moBounds = new google.maps.LatLngBounds(
        new google.maps.LatLng(sw.lat, sw.lon),
        new google.maps.LatLng(ne.lat, ne.lon)
      );
    }
    return moBounds;
  },
  getMapObjectLonLatFromMapObjectPixel: function(moPixel) {
    var size = this.map.getSize();
    var lon = this.getLongitudeFromMapObjectLonLat(this.mapObject.center);
    var lat = this.getLatitudeFromMapObjectLonLat(this.mapObject.center);
    var res = this.map.getResolution();
    var delta_x = moPixel.x - size.w / 2;
    var delta_y = moPixel.y - size.h / 2;
    var lonlat = new OpenLayers.LonLat(
      lon + delta_x * res,
      lat - delta_y * res
    );
    if (this.wrapDateLine) {
      lonlat = lonlat.wrapDateLine(this.maxExtent);
    }
    return this.getMapObjectLonLatFromLonLat(lonlat.lon, lonlat.lat);
  },
  getMapObjectPixelFromMapObjectLonLat: function(moLonLat) {
    var lon = this.getLongitudeFromMapObjectLonLat(moLonLat);
    var lat = this.getLatitudeFromMapObjectLonLat(moLonLat);
    var res = this.map.getResolution();
    var extent = this.map.getExtent();
    return this.getMapObjectPixelFromXY(
      (1 / res) * (lon - extent.left),
      (1 / res) * (extent.top - lat)
    );
  },
  setMapObjectCenter: function(center, zoom) {
    if (this.animationEnabled === false && zoom != this.mapObject.zoom) {
      var mapContainer = this.getMapContainer();
      google.maps.event.addListenerOnce(this.mapObject, "idle", function() {
        mapContainer.style.visibility = "";
      });
      mapContainer.style.visibility = "hidden";
    }
    this.mapObject.setOptions({ center: center, zoom: zoom });
  },
  getMapObjectZoomFromMapObjectBounds: function(moBounds) {
    return this.mapObject.getBoundsZoomLevel(moBounds);
  },
  getMapObjectLonLatFromLonLat: function(lon, lat) {
    var gLatLng;
    if (this.sphericalMercator) {
      var lonlat = this.inverseMercator(lon, lat);
      gLatLng = new google.maps.LatLng(lonlat.lat, lonlat.lon);
    } else {
      gLatLng = new google.maps.LatLng(lat, lon);
    }
    return gLatLng;
  },
  getMapObjectPixelFromXY: function(x, y) {
    return new google.maps.Point(x, y);
  },
  destroy: function() {
    if (this.repositionListener) {
      google.maps.event.removeListener(this.repositionListener);
    }
    if (this.repositionTimer) {
      window.clearTimeout(this.repositionTimer);
    }
    OpenLayers.Layer.Google.prototype.destroy.apply(this, arguments);
  }
};
OpenLayers.ProxyHost = "";
OpenLayers.Request = {
  DEFAULT_CONFIG: {
    method: "GET",
    url: window.location.href,
    async: true,
    user: undefined,
    password: undefined,
    params: null,
    proxy: OpenLayers.ProxyHost,
    headers: {},
    data: null,
    callback: function() {},
    success: null,
    failure: null,
    scope: null
  },
  URL_SPLIT_REGEX: /([^:]*:)\/\/([^:]*:?[^@]*@)?([^:\/\?]*):?([^\/\?]*)/,
  events: new OpenLayers.Events(this),
  makeSameOrigin: function(url, proxy) {
    var sameOrigin = url.indexOf("http") !== 0;
    var urlParts = !sameOrigin && url.match(this.URL_SPLIT_REGEX);
    if (urlParts) {
      var location = window.location;
      sameOrigin =
        urlParts[1] == location.protocol && urlParts[3] == location.hostname;
      var uPort = urlParts[4],
        lPort = location.port;
      if ((uPort != 80 && uPort != "") || (lPort != "80" && lPort != "")) {
        sameOrigin = sameOrigin && uPort == lPort;
      }
    }
    if (!sameOrigin) {
      if (proxy) {
        if (typeof proxy == "function") {
          url = proxy(url);
        } else {
          url = proxy + encodeURIComponent(url);
        }
      } else {
        OpenLayers.Console.warn(OpenLayers.i18n("proxyNeeded"), { url: url });
      }
    }
    return url;
  },
  issue: function(config) {
    var defaultConfig = OpenLayers.Util.extend(this.DEFAULT_CONFIG, {
      proxy: OpenLayers.ProxyHost
    });
    config = OpenLayers.Util.applyDefaults(config, defaultConfig);
    var customRequestedWithHeader = false,
      headerKey;
    for (headerKey in config.headers) {
      if (config.headers.hasOwnProperty(headerKey)) {
        if (headerKey.toLowerCase() === "x-requested-with") {
          customRequestedWithHeader = true;
        }
      }
    }
    if (customRequestedWithHeader === false) {
      config.headers["X-Requested-With"] = "XMLHttpRequest";
    }
    var request = new OpenLayers.Request.XMLHttpRequest();
    var url = OpenLayers.Util.urlAppend(
      config.url,
      OpenLayers.Util.getParameterString(config.params || {})
    );
    url = OpenLayers.Request.makeSameOrigin(url, config.proxy);
    request.open(
      config.method,
      url,
      config.async,
      config.user,
      config.password
    );
    for (var header in config.headers) {
      request.setRequestHeader(header, config.headers[header]);
    }
    var events = this.events;
    var self = this;
    request.onreadystatechange = function() {
      if (request.readyState == OpenLayers.Request.XMLHttpRequest.DONE) {
        var proceed = events.triggerEvent("complete", {
          request: request,
          config: config,
          requestUrl: url
        });
        if (proceed !== false) {
          self.runCallbacks({
            request: request,
            config: config,
            requestUrl: url
          });
        }
      }
    };
    if (config.async === false) {
      request.send(config.data);
    } else {
      window.setTimeout(function() {
        if (request.readyState !== 0) {
          request.send(config.data);
        }
      }, 0);
    }
    return request;
  },
  runCallbacks: function(options) {
    var request = options.request;
    var config = options.config;
    var complete = config.scope
      ? OpenLayers.Function.bind(config.callback, config.scope)
      : config.callback;
    var success;
    if (config.success) {
      success = config.scope
        ? OpenLayers.Function.bind(config.success, config.scope)
        : config.success;
    }
    var failure;
    if (config.failure) {
      failure = config.scope
        ? OpenLayers.Function.bind(config.failure, config.scope)
        : config.failure;
    }
    if (
      OpenLayers.Util.createUrlObject(config.url).protocol == "file:" &&
      request.responseText
    ) {
      request.status = 200;
    }
    complete(request);
    if (!request.status || (request.status >= 200 && request.status < 300)) {
      this.events.triggerEvent("success", options);
      if (success) {
        success(request);
      }
    }
    if (request.status && (request.status < 200 || request.status >= 300)) {
      this.events.triggerEvent("failure", options);
      if (failure) {
        failure(request);
      }
    }
  },
  GET: function(config) {
    config = OpenLayers.Util.extend(config, { method: "GET" });
    return OpenLayers.Request.issue(config);
  },
  POST: function(config) {
    config = OpenLayers.Util.extend(config, { method: "POST" });
    config.headers = config.headers ? config.headers : {};
    if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) {
      config.headers["Content-Type"] = "application/xml";
    }
    return OpenLayers.Request.issue(config);
  },
  PUT: function(config) {
    config = OpenLayers.Util.extend(config, { method: "PUT" });
    config.headers = config.headers ? config.headers : {};
    if (!("CONTENT-TYPE" in OpenLayers.Util.upperCaseObject(config.headers))) {
      config.headers["Content-Type"] = "application/xml";
    }
    return OpenLayers.Request.issue(config);
  },
  DELETE: function(config) {
    config = OpenLayers.Util.extend(config, { method: "DELETE" });
    return OpenLayers.Request.issue(config);
  },
  HEAD: function(config) {
    config = OpenLayers.Util.extend(config, { method: "HEAD" });
    return OpenLayers.Request.issue(config);
  },
  OPTIONS: function(config) {
    config = OpenLayers.Util.extend(config, { method: "OPTIONS" });
    return OpenLayers.Request.issue(config);
  }
};
(function() {
  var oXMLHttpRequest = window.XMLHttpRequest;
  var bGecko = !!window.controllers,
    bIE = window.document.all && !window.opera,
    bIE7 = bIE && window.navigator.userAgent.match(/MSIE 7.0/);
  function fXMLHttpRequest() {
    this._object =
      oXMLHttpRequest && !bIE7
        ? new oXMLHttpRequest()
        : new window.ActiveXObject("Microsoft.XMLHTTP");
    this._listeners = [];
  }
  function cXMLHttpRequest() {
    return new fXMLHttpRequest();
  }
  cXMLHttpRequest.prototype = fXMLHttpRequest.prototype;
  if (bGecko && oXMLHttpRequest.wrapped)
    cXMLHttpRequest.wrapped = oXMLHttpRequest.wrapped;
  cXMLHttpRequest.UNSENT = 0;
  cXMLHttpRequest.OPENED = 1;
  cXMLHttpRequest.HEADERS_RECEIVED = 2;
  cXMLHttpRequest.LOADING = 3;
  cXMLHttpRequest.DONE = 4;
  cXMLHttpRequest.prototype.readyState = cXMLHttpRequest.UNSENT;
  cXMLHttpRequest.prototype.responseText = "";
  cXMLHttpRequest.prototype.responseXML = null;
  cXMLHttpRequest.prototype.status = 0;
  cXMLHttpRequest.prototype.statusText = "";
  cXMLHttpRequest.prototype.priority = "NORMAL";
  cXMLHttpRequest.prototype.onreadystatechange = null;
  cXMLHttpRequest.onreadystatechange = null;
  cXMLHttpRequest.onopen = null;
  cXMLHttpRequest.onsend = null;
  cXMLHttpRequest.onabort = null;
  cXMLHttpRequest.prototype.open = function(
    sMethod,
    sUrl,
    bAsync,
    sUser,
    sPassword
  ) {
    delete this._headers;
    if (arguments.length < 3) bAsync = true;
    this._async = bAsync;
    var oRequest = this,
      nState = this.readyState,
      fOnUnload;
    if (bIE && bAsync) {
      fOnUnload = function() {
        if (nState != cXMLHttpRequest.DONE) {
          fCleanTransport(oRequest);
          oRequest.abort();
        }
      };
      window.attachEvent("onunload", fOnUnload);
    }
    if (cXMLHttpRequest.onopen) cXMLHttpRequest.onopen.apply(this, arguments);
    if (arguments.length > 4)
      this._object.open(sMethod, sUrl, bAsync, sUser, sPassword);
    else if (arguments.length > 3)
      this._object.open(sMethod, sUrl, bAsync, sUser);
    else this._object.open(sMethod, sUrl, bAsync);
    this.readyState = cXMLHttpRequest.OPENED;
    fReadyStateChange(this);
    this._object.onreadystatechange = function() {
      if (bGecko && !bAsync) return;
      oRequest.readyState = oRequest._object.readyState;
      fSynchronizeValues(oRequest);
      if (oRequest._aborted) {
        oRequest.readyState = cXMLHttpRequest.UNSENT;
        return;
      }
      if (oRequest.readyState == cXMLHttpRequest.DONE) {
        delete oRequest._data;
        fCleanTransport(oRequest);
        if (bIE && bAsync) window.detachEvent("onunload", fOnUnload);
      }
      if (nState != oRequest.readyState) fReadyStateChange(oRequest);
      nState = oRequest.readyState;
    };
  };
  function fXMLHttpRequest_send(oRequest) {
    oRequest._object.send(oRequest._data);
    if (bGecko && !oRequest._async) {
      oRequest.readyState = cXMLHttpRequest.OPENED;
      fSynchronizeValues(oRequest);
      while (oRequest.readyState < cXMLHttpRequest.DONE) {
        oRequest.readyState++;
        fReadyStateChange(oRequest);
        if (oRequest._aborted) return;
      }
    }
  }
  cXMLHttpRequest.prototype.send = function(vData) {
    if (cXMLHttpRequest.onsend) cXMLHttpRequest.onsend.apply(this, arguments);
    if (!arguments.length) vData = null;
    if (vData && vData.nodeType) {
      vData = window.XMLSerializer
        ? new window.XMLSerializer().serializeToString(vData)
        : vData.xml;
      if (!this._headers["Content-Type"])
        this._object.setRequestHeader("Content-Type", "application/xml");
    }
    this._data = vData;
    fXMLHttpRequest_send(this);
  };
  cXMLHttpRequest.prototype.abort = function() {
    if (cXMLHttpRequest.onabort) cXMLHttpRequest.onabort.apply(this, arguments);
    if (this.readyState > cXMLHttpRequest.UNSENT) this._aborted = true;
    this._object.abort();
    fCleanTransport(this);
    this.readyState = cXMLHttpRequest.UNSENT;
    delete this._data;
  };
  cXMLHttpRequest.prototype.getAllResponseHeaders = function() {
    return this._object.getAllResponseHeaders();
  };
  cXMLHttpRequest.prototype.getResponseHeader = function(sName) {
    return this._object.getResponseHeader(sName);
  };
  cXMLHttpRequest.prototype.setRequestHeader = function(sName, sValue) {
    if (!this._headers) this._headers = {};
    this._headers[sName] = sValue;
    return this._object.setRequestHeader(sName, sValue);
  };
  cXMLHttpRequest.prototype.addEventListener = function(
    sName,
    fHandler,
    bUseCapture
  ) {
    for (
      var nIndex = 0, oListener;
      (oListener = this._listeners[nIndex]);
      nIndex++
    )
      if (
        oListener[0] == sName &&
        oListener[1] == fHandler &&
        oListener[2] == bUseCapture
      )
        return;
    this._listeners.push([sName, fHandler, bUseCapture]);
  };
  cXMLHttpRequest.prototype.removeEventListener = function(
    sName,
    fHandler,
    bUseCapture
  ) {
    for (
      var nIndex = 0, oListener;
      (oListener = this._listeners[nIndex]);
      nIndex++
    )
      if (
        oListener[0] == sName &&
        oListener[1] == fHandler &&
        oListener[2] == bUseCapture
      )
        break;
    if (oListener) this._listeners.splice(nIndex, 1);
  };
  cXMLHttpRequest.prototype.dispatchEvent = function(oEvent) {
    var oEventPseudo = {
      type: oEvent.type,
      target: this,
      currentTarget: this,
      eventPhase: 2,
      bubbles: oEvent.bubbles,
      cancelable: oEvent.cancelable,
      timeStamp: oEvent.timeStamp,
      stopPropagation: function() {},
      preventDefault: function() {},
      initEvent: function() {}
    };
    if (oEventPseudo.type == "readystatechange" && this.onreadystatechange)
      (this.onreadystatechange.handleEvent || this.onreadystatechange).apply(
        this,
        [oEventPseudo]
      );
    for (
      var nIndex = 0, oListener;
      (oListener = this._listeners[nIndex]);
      nIndex++
    )
      if (oListener[0] == oEventPseudo.type && !oListener[2])
        (oListener[1].handleEvent || oListener[1]).apply(this, [oEventPseudo]);
  };
  cXMLHttpRequest.prototype.toString = function() {
    return "[" + "object" + " " + "XMLHttpRequest" + "]";
  };
  cXMLHttpRequest.toString = function() {
    return "[" + "XMLHttpRequest" + "]";
  };
  function fReadyStateChange(oRequest) {
    if (cXMLHttpRequest.onreadystatechange)
      cXMLHttpRequest.onreadystatechange.apply(oRequest);
    oRequest.dispatchEvent({
      type: "readystatechange",
      bubbles: false,
      cancelable: false,
      timeStamp: new Date() + 0
    });
  }
  function fGetDocument(oRequest) {
    var oDocument = oRequest.responseXML,
      sResponse = oRequest.responseText;
    if (
      bIE &&
      sResponse &&
      oDocument &&
      !oDocument.documentElement &&
      oRequest.getResponseHeader("Content-Type").match(/[^\/]+\/[^\+]+\+xml/)
    ) {
      oDocument = new window.ActiveXObject("Microsoft.XMLDOM");
      oDocument.async = false;
      oDocument.validateOnParse = false;
      oDocument.loadXML(sResponse);
    }
    if (oDocument)
      if (
        (bIE && oDocument.parseError != 0) ||
        !oDocument.documentElement ||
        (oDocument.documentElement &&
          oDocument.documentElement.tagName == "parsererror")
      )
        return null;
    return oDocument;
  }
  function fSynchronizeValues(oRequest) {
    try {
      oRequest.responseText = oRequest._object.responseText;
    } catch (e) {}
    try {
      oRequest.responseXML = fGetDocument(oRequest._object);
    } catch (e) {}
    try {
      oRequest.status = oRequest._object.status;
    } catch (e) {}
    try {
      oRequest.statusText = oRequest._object.statusText;
    } catch (e) {}
  }
  function fCleanTransport(oRequest) {
    oRequest._object.onreadystatechange = new window.Function();
  }
  if (!window.Function.prototype.apply) {
    window.Function.prototype.apply = function(oRequest, oArguments) {
      if (!oArguments) oArguments = [];
      oRequest.__func = this;
      oRequest.__func(
        oArguments[0],
        oArguments[1],
        oArguments[2],
        oArguments[3],
        oArguments[4]
      );
      delete oRequest.__func;
    };
  }
  OpenLayers.Request.XMLHttpRequest = cXMLHttpRequest;
})();
OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, {
  type: null,
  property: null,
  value: null,
  matchCase: true,
  lowerBoundary: null,
  upperBoundary: null,
  initialize: function(options) {
    OpenLayers.Filter.prototype.initialize.apply(this, [options]);
    if (
      this.type === OpenLayers.Filter.Comparison.LIKE &&
      options.matchCase === undefined
    ) {
      this.matchCase = null;
    }
  },
  evaluate: function(context) {
    if (context instanceof OpenLayers.Feature.Vector) {
      context = context.attributes;
    }
    var result = false;
    var got = context[this.property];
    var exp;
    switch (this.type) {
      case OpenLayers.Filter.Comparison.EQUAL_TO:
        exp = this.value;
        if (
          !this.matchCase &&
          typeof got == "string" &&
          typeof exp == "string"
        ) {
          result = got.toUpperCase() == exp.toUpperCase();
        } else {
          result = got == exp;
        }
        break;
      case OpenLayers.Filter.Comparison.NOT_EQUAL_TO:
        exp = this.value;
        if (
          !this.matchCase &&
          typeof got == "string" &&
          typeof exp == "string"
        ) {
          result = got.toUpperCase() != exp.toUpperCase();
        } else {
          result = got != exp;
        }
        break;
      case OpenLayers.Filter.Comparison.LESS_THAN:
        result = got < this.value;
        break;
      case OpenLayers.Filter.Comparison.GREATER_THAN:
        result = got > this.value;
        break;
      case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO:
        result = got <= this.value;
        break;
      case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
        result = got >= this.value;
        break;
      case OpenLayers.Filter.Comparison.BETWEEN:
        result = got >= this.lowerBoundary && got <= this.upperBoundary;
        break;
      case OpenLayers.Filter.Comparison.LIKE:
        var regexp = new RegExp(this.value, "gi");
        result = regexp.test(got);
        break;
    }
    return result;
  },
  value2regex: function(wildCard, singleChar, escapeChar) {
    if (wildCard == ".") {
      throw new Error(
        "'.' is an unsupported wildCard character for " +
          "OpenLayers.Filter.Comparison"
      );
    }
    wildCard = wildCard ? wildCard : "*";
    singleChar = singleChar ? singleChar : ".";
    escapeChar = escapeChar ? escapeChar : "!";
    this.value = this.value.replace(
      new RegExp("\\" + escapeChar + "(.|$)", "g"),
      "\\$1"
    );
    this.value = this.value.replace(new RegExp("\\" + singleChar, "g"), ".");
    this.value = this.value.replace(new RegExp("\\" + wildCard, "g"), ".*");
    this.value = this.value.replace(
      new RegExp("\\\\.\\*", "g"),
      "\\" + wildCard
    );
    this.value = this.value.replace(
      new RegExp("\\\\\\.", "g"),
      "\\" + singleChar
    );
    return this.value;
  },
  regex2value: function() {
    var value = this.value;
    value = value.replace(/!/g, "!!");
    value = value.replace(/(\\)?\\\./g, function($0, $1) {
      return $1 ? $0 : "!.";
    });
    value = value.replace(/(\\)?\\\*/g, function($0, $1) {
      return $1 ? $0 : "!*";
    });
    value = value.replace(/\\\\/g, "\\");
    value = value.replace(/\.\*/g, "*");
    return value;
  },
  clone: function() {
    return OpenLayers.Util.extend(new OpenLayers.Filter.Comparison(), this);
  },
  CLASS_NAME: "OpenLayers.Filter.Comparison"
});
OpenLayers.Filter.Comparison.EQUAL_TO = "==";
OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
OpenLayers.Filter.Comparison.LESS_THAN = "<";
OpenLayers.Filter.Comparison.GREATER_THAN = ">";
OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
OpenLayers.Filter.Comparison.BETWEEN = "..";
OpenLayers.Filter.Comparison.LIKE = "~";
OpenLayers.Popup.FramedCloud = OpenLayers.Class(OpenLayers.Popup.Framed, {
  contentDisplayClass: "olFramedCloudPopupContent",
  autoSize: true,
  panMapIfOutOfView: true,
  imageSize: new OpenLayers.Size(1276, 736),
  isAlphaImage: false,
  fixedRelativePosition: false,
  positionBlocks: {
    tl: {
      offset: new OpenLayers.Pixel(44, 0),
      padding: new OpenLayers.Bounds(8, 40, 8, 9),
      blocks: [
        {
          size: new OpenLayers.Size("auto", "auto"),
          anchor: new OpenLayers.Bounds(0, 51, 22, 0),
          position: new OpenLayers.Pixel(0, 0)
        },
        {
          size: new OpenLayers.Size(22, "auto"),
          anchor: new OpenLayers.Bounds(null, 50, 0, 0),
          position: new OpenLayers.Pixel(-1238, 0)
        },
        {
          size: new OpenLayers.Size("auto", 19),
          anchor: new OpenLayers.Bounds(0, 32, 22, null),
          position: new OpenLayers.Pixel(0, -631)
        },
        {
          size: new OpenLayers.Size(22, 18),
          anchor: new OpenLayers.Bounds(null, 32, 0, null),
          position: new OpenLayers.Pixel(-1238, -632)
        },
        {
          size: new OpenLayers.Size(81, 35),
          anchor: new OpenLayers.Bounds(null, 0, 0, null),
          position: new OpenLayers.Pixel(0, -688)
        }
      ]
    },
    tr: {
      offset: new OpenLayers.Pixel(-45, 0),
      padding: new OpenLayers.Bounds(8, 40, 8, 9),
      blocks: [
        {
          size: new OpenLayers.Size("auto", "auto"),
          anchor: new OpenLayers.Bounds(0, 51, 22, 0),
          position: new OpenLayers.Pixel(0, 0)
        },
        {
          size: new OpenLayers.Size(22, "auto"),
          anchor: new OpenLayers.Bounds(null, 50, 0, 0),
          position: new OpenLayers.Pixel(-1238, 0)
        },
        {
          size: new OpenLayers.Size("auto", 19),
          anchor: new OpenLayers.Bounds(0, 32, 22, null),
          position: new OpenLayers.Pixel(0, -631)
        },
        {
          size: new OpenLayers.Size(22, 19),
          anchor: new OpenLayers.Bounds(null, 32, 0, null),
          position: new OpenLayers.Pixel(-1238, -631)
        },
        {
          size: new OpenLayers.Size(81, 35),
          anchor: new OpenLayers.Bounds(0, 0, null, null),
          position: new OpenLayers.Pixel(-215, -687)
        }
      ]
    },
    bl: {
      offset: new OpenLayers.Pixel(45, 0),
      padding: new OpenLayers.Bounds(8, 9, 8, 40),
      blocks: [
        {
          size: new OpenLayers.Size("auto", "auto"),
          anchor: new OpenLayers.Bounds(0, 21, 22, 32),
          position: new OpenLayers.Pixel(0, 0)
        },
        {
          size: new OpenLayers.Size(22, "auto"),
          anchor: new OpenLayers.Bounds(null, 21, 0, 32),
          position: new OpenLayers.Pixel(-1238, 0)
        },
        {
          size: new OpenLayers.Size("auto", 21),
          anchor: new OpenLayers.Bounds(0, 0, 22, null),
          position: new OpenLayers.Pixel(0, -629)
        },
        {
          size: new OpenLayers.Size(22, 21),
          anchor: new OpenLayers.Bounds(null, 0, 0, null),
          position: new OpenLayers.Pixel(-1238, -629)
        },
        {
          size: new OpenLayers.Size(81, 33),
          anchor: new OpenLayers.Bounds(null, null, 0, 0),
          position: new OpenLayers.Pixel(-101, -674)
        }
      ]
    },
    br: {
      offset: new OpenLayers.Pixel(-44, 0),
      padding: new OpenLayers.Bounds(8, 9, 8, 40),
      blocks: [
        {
          size: new OpenLayers.Size("auto", "auto"),
          anchor: new OpenLayers.Bounds(0, 21, 22, 32),
          position: new OpenLayers.Pixel(0, 0)
        },
        {
          size: new OpenLayers.Size(22, "auto"),
          anchor: new OpenLayers.Bounds(null, 21, 0, 32),
          position: new OpenLayers.Pixel(-1238, 0)
        },
        {
          size: new OpenLayers.Size("auto", 21),
          anchor: new OpenLayers.Bounds(0, 0, 22, null),
          position: new OpenLayers.Pixel(0, -629)
        },
        {
          size: new OpenLayers.Size(22, 21),
          anchor: new OpenLayers.Bounds(null, 0, 0, null),
          position: new OpenLayers.Pixel(-1238, -629)
        },
        {
          size: new OpenLayers.Size(81, 33),
          anchor: new OpenLayers.Bounds(0, null, null, 0),
          position: new OpenLayers.Pixel(-311, -674)
        }
      ]
    }
  },
  minSize: new OpenLayers.Size(105, 10),
  maxSize: new OpenLayers.Size(1200, 660),
  initialize: function(
    id,
    lonlat,
    contentSize,
    contentHTML,
    anchor,
    closeBox,
    closeBoxCallback
  ) {
    this.imageSrc = OpenLayers.Util.getImageLocation(
      "cloud-popup-relative.png"
    );
    OpenLayers.Popup.Framed.prototype.initialize.apply(this, arguments);
    this.contentDiv.className = this.contentDisplayClass;
  },
  CLASS_NAME: "OpenLayers.Popup.FramedCloud"
});
OpenLayers.Rule = OpenLayers.Class({
  id: null,
  name: null,
  title: null,
  description: null,
  context: null,
  filter: null,
  elseFilter: false,
  symbolizer: null,
  symbolizers: null,
  minScaleDenominator: null,
  maxScaleDenominator: null,
  initialize: function(options) {
    this.symbolizer = {};
    OpenLayers.Util.extend(this, options);
    if (this.symbolizers) {
      delete this.symbolizer;
    }
    this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_");
  },
  destroy: function() {
    for (var i in this.symbolizer) {
      this.symbolizer[i] = null;
    }
    this.symbolizer = null;
    delete this.symbolizers;
  },
  evaluate: function(feature) {
    var context = this.getContext(feature);
    var applies = true;
    if (this.minScaleDenominator || this.maxScaleDenominator) {
      var scale = feature.layer.map.getScale();
    }
    if (this.minScaleDenominator) {
      applies =
        scale >=
        OpenLayers.Style.createLiteral(this.minScaleDenominator, context);
    }
    if (applies && this.maxScaleDenominator) {
      applies =
        scale <
        OpenLayers.Style.createLiteral(this.maxScaleDenominator, context);
    }
    if (applies && this.filter) {
      if (this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") {
        applies = this.filter.evaluate(feature);
      } else {
        applies = this.filter.evaluate(context);
      }
    }
    return applies;
  },
  getContext: function(feature) {
    var context = this.context;
    if (!context) {
      context = feature.attributes || feature.data;
    }
    if (typeof this.context == "function") {
      context = this.context(feature);
    }
    return context;
  },
  clone: function() {
    var options = OpenLayers.Util.extend({}, this);
    if (this.symbolizers) {
      var len = this.symbolizers.length;
      options.symbolizers = new Array(len);
      for (var i = 0; i < len; ++i) {
        options.symbolizers[i] = this.symbolizers[i].clone();
      }
    } else {
      options.symbolizer = {};
      var value, type;
      for (var key in this.symbolizer) {
        value = this.symbolizer[key];
        type = typeof value;
        if (type === "object") {
          options.symbolizer[key] = OpenLayers.Util.extend({}, value);
        } else if (type === "string") {
          options.symbolizer[key] = value;
        }
      }
    }
    options.filter = this.filter && this.filter.clone();
    options.context = this.context && OpenLayers.Util.extend({}, this.context);
    return new OpenLayers.Rule(options);
  },
  CLASS_NAME: "OpenLayers.Rule"
});
OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
  xmlns: "urn:schemas-microsoft-com:vml",
  symbolCache: {},
  offset: null,
  initialize: function(containerID) {
    if (!this.supported()) {
      return;
    }
    if (!document.namespaces.olv) {
      document.namespaces.add("olv", this.xmlns);
      var style = document.createStyleSheet();
      var shapes = [
        "shape",
        "rect",
        "oval",
        "fill",
        "stroke",
        "imagedata",
        "group",
        "textbox"
      ];
      for (var i = 0, len = shapes.length; i < len; i++) {
        style.addRule(
          "olv\\:" + shapes[i],
          "behavior: url(#default#VML); " +
            "position: absolute; display: inline-block;"
        );
      }
    }
    OpenLayers.Renderer.Elements.prototype.initialize.apply(this, arguments);
  },
  supported: function() {
    return !!document.namespaces;
  },
  setExtent: function(extent, resolutionChanged) {
    var coordSysUnchanged = OpenLayers.Renderer.Elements.prototype.setExtent.apply(
      this,
      arguments
    );
    var resolution = this.getResolution();
    var left = (extent.left / resolution) | 0;
    var top = (extent.top / resolution - this.size.h) | 0;
    if (resolutionChanged || !this.offset) {
      this.offset = { x: left, y: top };
      left = 0;
      top = 0;
    } else {
      left = left - this.offset.x;
      top = top - this.offset.y;
    }
    var org = left - this.xOffset + " " + top;
    this.root.coordorigin = org;
    var roots = [this.root, this.vectorRoot, this.textRoot];
    var root;
    for (var i = 0, len = roots.length; i < len; ++i) {
      root = roots[i];
      var size = this.size.w + " " + this.size.h;
      root.coordsize = size;
    }
    this.root.style.flip = "y";
    return coordSysUnchanged;
  },
  setSize: function(size) {
    OpenLayers.Renderer.prototype.setSize.apply(this, arguments);
    var roots = [this.rendererRoot, this.root, this.vectorRoot, this.textRoot];
    var w = this.size.w + "px";
    var h = this.size.h + "px";
    var root;
    for (var i = 0, len = roots.length; i < len; ++i) {
      root = roots[i];
      root.style.width = w;
      root.style.height = h;
    }
  },
  getNodeType: function(geometry, style) {
    var nodeType = null;
    switch (geometry.CLASS_NAME) {
      case "OpenLayers.Geometry.Point":
        if (style.externalGraphic) {
          nodeType = "olv:rect";
        } else if (this.isComplexSymbol(style.graphicName)) {
          nodeType = "olv:shape";
        } else {
          nodeType = "olv:oval";
        }
        break;
      case "OpenLayers.Geometry.Rectangle":
        nodeType = "olv:rect";
        break;
      case "OpenLayers.Geometry.LineString":
      case "OpenLayers.Geometry.LinearRing":
      case "OpenLayers.Geometry.Polygon":
      case "OpenLayers.Geometry.Curve":
        nodeType = "olv:shape";
        break;
      default:
        break;
    }
    return nodeType;
  },
  setStyle: function(node, style, options, geometry) {
    style = style || node._style;
    options = options || node._options;
    var fillColor = style.fillColor;
    if (node._geometryClass === "OpenLayers.Geometry.Point") {
      if (style.externalGraphic) {
        options.isFilled = true;
        if (style.graphicTitle) {
          node.title = style.graphicTitle;
        }
        var width = style.graphicWidth || style.graphicHeight;
        var height = style.graphicHeight || style.graphicWidth;
        width = width ? width : style.pointRadius * 2;
        height = height ? height : style.pointRadius * 2;
        var resolution = this.getResolution();
        var xOffset =
          style.graphicXOffset != undefined
            ? style.graphicXOffset
            : -(0.5 * width);
        var yOffset =
          style.graphicYOffset != undefined
            ? style.graphicYOffset
            : -(0.5 * height);
        node.style.left =
          (((geometry.x - this.featureDx) / resolution -
            this.offset.x +
            xOffset) |
            0) +
          "px";
        node.style.top =
          ((geometry.y / resolution - this.offset.y - (yOffset + height)) | 0) +
          "px";
        node.style.width = width + "px";
        node.style.height = height + "px";
        node.style.flip = "y";
        fillColor = "none";
        options.isStroked = false;
      } else if (this.isComplexSymbol(style.graphicName)) {
        var cache = this.importSymbol(style.graphicName);
        node.path = cache.path;
        node.coordorigin = cache.left + "," + cache.bottom;
        var size = cache.size;
        node.coordsize = size + "," + size;
        this.drawCircle(node, geometry, style.pointRadius);
        node.style.flip = "y";
      } else {
        this.drawCircle(node, geometry, style.pointRadius);
      }
    }
    if (options.isFilled) {
      node.fillcolor = fillColor;
    } else {
      node.filled = "false";
    }
    var fills = node.getElementsByTagName("fill");
    var fill = fills.length == 0 ? null : fills[0];
    if (!options.isFilled) {
      if (fill) {
        node.removeChild(fill);
      }
    } else {
      if (!fill) {
        fill = this.createNode("olv:fill", node.id + "_fill");
      }
      fill.opacity = style.fillOpacity;
      if (
        node._geometryClass === "OpenLayers.Geometry.Point" &&
        style.externalGraphic
      ) {
        if (style.graphicOpacity) {
          fill.opacity = style.graphicOpacity;
        }
        fill.src = style.externalGraphic;
        fill.type = "frame";
        if (!(style.graphicWidth && style.graphicHeight)) {
          fill.aspect = "atmost";
        }
      }
      if (fill.parentNode != node) {
        node.appendChild(fill);
      }
    }
    var rotation = style.rotation;
    if (rotation !== undefined || node._rotation !== undefined) {
      node._rotation = rotation;
      if (style.externalGraphic) {
        this.graphicRotate(node, xOffset, yOffset, style);
        fill.opacity = 0;
      } else if (node._geometryClass === "OpenLayers.Geometry.Point") {
        node.style.rotation = rotation || 0;
      }
    }
    var strokes = node.getElementsByTagName("stroke");
    var stroke = strokes.length == 0 ? null : strokes[0];
    if (!options.isStroked) {
      node.stroked = false;
      if (stroke) {
        stroke.on = false;
      }
    } else {
      if (!stroke) {
        stroke = this.createNode("olv:stroke", node.id + "_stroke");
        node.appendChild(stroke);
      }
      stroke.on = true;
      stroke.color = style.strokeColor;
      stroke.weight = style.strokeWidth + "px";
      stroke.opacity = style.strokeOpacity;
      stroke.endcap =
        style.strokeLinecap == "butt" ? "flat" : style.strokeLinecap || "round";
      if (style.strokeDashstyle) {
        stroke.dashstyle = this.dashStyle(style);
      }
    }
    if (style.cursor != "inherit" && style.cursor != null) {
      node.style.cursor = style.cursor;
    }
    return node;
  },
  graphicRotate: function(node, xOffset, yOffset, style) {
    var style = style || node._style;
    var rotation = style.rotation || 0;
    var aspectRatio, size;
    if (!(style.graphicWidth && style.graphicHeight)) {
      var img = new Image();
      img.onreadystatechange = OpenLayers.Function.bind(function() {
        if (img.readyState == "complete" || img.readyState == "interactive") {
          aspectRatio = img.width / img.height;
          size = Math.max(
            style.pointRadius * 2,
            style.graphicWidth || 0,
            style.graphicHeight || 0
          );
          xOffset = xOffset * aspectRatio;
          style.graphicWidth = size * aspectRatio;
          style.graphicHeight = size;
          this.graphicRotate(node, xOffset, yOffset, style);
        }
      }, this);
      img.src = style.externalGraphic;
      return;
    } else {
      size = Math.max(style.graphicWidth, style.graphicHeight);
      aspectRatio = style.graphicWidth / style.graphicHeight;
    }
    var width = Math.round(style.graphicWidth || size * aspectRatio);
    var height = Math.round(style.graphicHeight || size);
    node.style.width = width + "px";
    node.style.height = height + "px";
    var image = document.getElementById(node.id + "_image");
    if (!image) {
      image = this.createNode("olv:imagedata", node.id + "_image");
      node.appendChild(image);
    }
    image.style.width = width + "px";
    image.style.height = height + "px";
    image.src = style.externalGraphic;
    image.style.filter =
      "progid:DXImageTransform.Microsoft.AlphaImageLoader(" +
      "src='', sizingMethod='scale')";
    var rot = (rotation * Math.PI) / 180;
    var sintheta = Math.sin(rot);
    var costheta = Math.cos(rot);
    var filter =
      "progid:DXImageTransform.Microsoft.Matrix(M11=" +
      costheta +
      ",M12=" +
      -sintheta +
      ",M21=" +
      sintheta +
      ",M22=" +
      costheta +
      ",SizingMethod='auto expand')\n";
    var opacity = style.graphicOpacity || style.fillOpacity;
    if (opacity && opacity != 1) {
      filter +=
        "progid:DXImageTransform.Microsoft.BasicImage(opacity=" +
        opacity +
        ")\n";
    }
    node.style.filter = filter;
    var centerPoint = new OpenLayers.Geometry.Point(-xOffset, -yOffset);
    var imgBox = new OpenLayers.Bounds(0, 0, width, height).toGeometry();
    imgBox.rotate(style.rotation, centerPoint);
    var imgBounds = imgBox.getBounds();
    node.style.left =
      Math.round(parseInt(node.style.left) + imgBounds.left) + "px";
    node.style.top =
      Math.round(parseInt(node.style.top) - imgBounds.bottom) + "px";
  },
  postDraw: function(node) {
    node.style.visibility = "visible";
    var fillColor = node._style.fillColor;
    var strokeColor = node._style.strokeColor;
    if (fillColor == "none" && node.fillcolor != fillColor) {
      node.fillcolor = fillColor;
    }
    if (strokeColor == "none" && node.strokecolor != strokeColor) {
      node.strokecolor = strokeColor;
    }
  },
  setNodeDimension: function(node, geometry) {
    var bbox = geometry.getBounds();
    if (bbox) {
      var resolution = this.getResolution();
      var scaledBox = new OpenLayers.Bounds(
        ((bbox.left - this.featureDx) / resolution - this.offset.x) | 0,
        (bbox.bottom / resolution - this.offset.y) | 0,
        ((bbox.right - this.featureDx) / resolution - this.offset.x) | 0,
        (bbox.top / resolution - this.offset.y) | 0
      );
      node.style.left = scaledBox.left + "px";
      node.style.top = scaledBox.top + "px";
      node.style.width = scaledBox.getWidth() + "px";
      node.style.height = scaledBox.getHeight() + "px";
      node.coordorigin = scaledBox.left + " " + scaledBox.top;
      node.coordsize = scaledBox.getWidth() + " " + scaledBox.getHeight();
    }
  },
  dashStyle: function(style) {
    var dash = style.strokeDashstyle;
    switch (dash) {
      case "solid":
      case "dot":
      case "dash":
      case "dashdot":
      case "longdash":
      case "longdashdot":
        return dash;
      default:
        var parts = dash.split(/[ ,]/);
        if (parts.length == 2) {
          if (1 * parts[0] >= 2 * parts[1]) {
            return "longdash";
          }
          return parts[0] == 1 || parts[1] == 1 ? "dot" : "dash";
        } else if (parts.length == 4) {
          return 1 * parts[0] >= 2 * parts[1] ? "longdashdot" : "dashdot";
        }
        return "solid";
    }
  },
  createNode: function(type, id) {
    var node = document.createElement(type);
    if (id) {
      node.id = id;
    }
    node.unselectable = "on";
    node.onselectstart = OpenLayers.Function.False;
    return node;
  },
  nodeTypeCompare: function(node, type) {
    var subType = type;
    var splitIndex = subType.indexOf(":");
    if (splitIndex != -1) {
      subType = subType.substr(splitIndex + 1);
    }
    var nodeName = node.nodeName;
    splitIndex = nodeName.indexOf(":");
    if (splitIndex != -1) {
      nodeName = nodeName.substr(splitIndex + 1);
    }
    return subType == nodeName;
  },
  createRenderRoot: function() {
    return this.nodeFactory(this.container.id + "_vmlRoot", "div");
  },
  createRoot: function(suffix) {
    return this.nodeFactory(this.container.id + suffix, "olv:group");
  },
  drawPoint: function(node, geometry) {
    return this.drawCircle(node, geometry, 1);
  },
  drawCircle: function(node, geometry, radius) {
    if (!isNaN(geometry.x) && !isNaN(geometry.y)) {
      var resolution = this.getResolution();
      node.style.left =
        (((geometry.x - this.featureDx) / resolution - this.offset.x) | 0) -
        radius +
        "px";
      node.style.top =
        ((geometry.y / resolution - this.offset.y) | 0) - radius + "px";
      var diameter = radius * 2;
      node.style.width = diameter + "px";
      node.style.height = diameter + "px";
      return node;
    }
    return false;
  },
  drawLineString: function(node, geometry) {
    return this.drawLine(node, geometry, false);
  },
  drawLinearRing: function(node, geometry) {
    return this.drawLine(node, geometry, true);
  },
  drawLine: function(node, geometry, closeLine) {
    this.setNodeDimension(node, geometry);
    var resolution = this.getResolution();
    var numComponents = geometry.components.length;
    var parts = new Array(numComponents);
    var comp, x, y;
    for (var i = 0; i < numComponents; i++) {
      comp = geometry.components[i];
      x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0;
      y = (comp.y / resolution - this.offset.y) | 0;
      parts[i] = " " + x + "," + y + " l ";
    }
    var end = closeLine ? " x e" : " e";
    node.path = "m" + parts.join("") + end;
    return node;
  },
  drawPolygon: function(node, geometry) {
    this.setNodeDimension(node, geometry);
    var resolution = this.getResolution();
    var path = [];
    var j, jj, points, area, first, second, i, ii, comp, pathComp, x, y;
    for (j = 0, jj = geometry.components.length; j < jj; j++) {
      path.push("m");
      points = geometry.components[j].components;
      area = j === 0;
      first = null;
      second = null;
      for (i = 0, ii = points.length; i < ii; i++) {
        comp = points[i];
        x = ((comp.x - this.featureDx) / resolution - this.offset.x) | 0;
        y = (comp.y / resolution - this.offset.y) | 0;
        pathComp = " " + x + "," + y;
        path.push(pathComp);
        if (i == 0) {
          path.push(" l");
        }
        if (!area) {
          if (!first) {
            first = pathComp;
          } else if (first != pathComp) {
            if (!second) {
              second = pathComp;
            } else if (second != pathComp) {
              area = true;
            }
          }
        }
      }
      path.push(area ? " x " : " ");
    }
    path.push("e");
    node.path = path.join("");
    return node;
  },
  drawRectangle: function(node, geometry) {
    var resolution = this.getResolution();
    node.style.left =
      (((geometry.x - this.featureDx) / resolution - this.offset.x) | 0) + "px";
    node.style.top = ((geometry.y / resolution - this.offset.y) | 0) + "px";
    node.style.width = ((geometry.width / resolution) | 0) + "px";
    node.style.height = ((geometry.height / resolution) | 0) + "px";
    return node;
  },
  drawText: function(featureId, style, location) {
    var label = this.nodeFactory(featureId + this.LABEL_ID_SUFFIX, "olv:rect");
    var textbox = this.nodeFactory(
      featureId + this.LABEL_ID_SUFFIX + "_textbox",
      "olv:textbox"
    );
    var resolution = this.getResolution();
    label.style.left =
      (((location.x - this.featureDx) / resolution - this.offset.x) | 0) + "px";
    label.style.top = ((location.y / resolution - this.offset.y) | 0) + "px";
    label.style.flip = "y";
    textbox.innerText = style.label;
    if (style.cursor != "inherit" && style.cursor != null) {
      textbox.style.cursor = style.cursor;
    }
    if (style.fontColor) {
      textbox.style.color = style.fontColor;
    }
    if (style.fontOpacity) {
      textbox.style.filter = "alpha(opacity=" + style.fontOpacity * 100 + ")";
    }
    if (style.fontFamily) {
      textbox.style.fontFamily = style.fontFamily;
    }
    if (style.fontSize) {
      textbox.style.fontSize = style.fontSize;
    }
    if (style.fontWeight) {
      textbox.style.fontWeight = style.fontWeight;
    }
    if (style.fontStyle) {
      textbox.style.fontStyle = style.fontStyle;
    }
    if (style.labelSelect === true) {
      label._featureId = featureId;
      textbox._featureId = featureId;
      textbox._geometry = location;
      textbox._geometryClass = location.CLASS_NAME;
    }
    textbox.style.whiteSpace = "nowrap";
    textbox.inset = "1px,0px,0px,0px";
    if (!label.parentNode) {
      label.appendChild(textbox);
      this.textRoot.appendChild(label);
    }
    var align = style.labelAlign || "cm";
    if (align.length == 1) {
      align += "m";
    }
    var xshift =
      textbox.clientWidth *
      OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(0, 1)];
    var yshift =
      textbox.clientHeight *
      OpenLayers.Renderer.VML.LABEL_SHIFT[align.substr(1, 1)];
    label.style.left = parseInt(label.style.left) - xshift - 1 + "px";
    label.style.top = parseInt(label.style.top) + yshift + "px";
  },
  moveRoot: function(renderer) {
    var layer = this.map.getLayer(renderer.container.id);
    if (layer instanceof OpenLayers.Layer.Vector.RootContainer) {
      layer = this.map.getLayer(this.container.id);
    }
    layer && layer.renderer.clear();
    OpenLayers.Renderer.Elements.prototype.moveRoot.apply(this, arguments);
    layer && layer.redraw();
  },
  importSymbol: function(graphicName) {
    var id = this.container.id + "-" + graphicName;
    var cache = this.symbolCache[id];
    if (cache) {
      return cache;
    }
    var symbol = OpenLayers.Renderer.symbol[graphicName];
    if (!symbol) {
      throw new Error(graphicName + " is not a valid symbol name");
    }
    var symbolExtent = new OpenLayers.Bounds(
      Number.MAX_VALUE,
      Number.MAX_VALUE,
      0,
      0
    );
    var pathitems = ["m"];
    for (var i = 0; i < symbol.length; i = i + 2) {
      var x = symbol[i];
      var y = symbol[i + 1];
      symbolExtent.left = Math.min(symbolExtent.left, x);
      symbolExtent.bottom = Math.min(symbolExtent.bottom, y);
      symbolExtent.right = Math.max(symbolExtent.right, x);
      symbolExtent.top = Math.max(symbolExtent.top, y);
      pathitems.push(x);
      pathitems.push(y);
      if (i == 0) {
        pathitems.push("l");
      }
    }
    pathitems.push("x e");
    var path = pathitems.join(" ");
    var diff = (symbolExtent.getWidth() - symbolExtent.getHeight()) / 2;
    if (diff > 0) {
      symbolExtent.bottom = symbolExtent.bottom - diff;
      symbolExtent.top = symbolExtent.top + diff;
    } else {
      symbolExtent.left = symbolExtent.left + diff;
      symbolExtent.right = symbolExtent.right - diff;
    }
    cache = {
      path: path,
      size: symbolExtent.getWidth(),
      left: symbolExtent.left,
      bottom: symbolExtent.bottom
    };
    this.symbolCache[id] = cache;
    return cache;
  },
  CLASS_NAME: "OpenLayers.Renderer.VML"
});
OpenLayers.Renderer.VML.LABEL_SHIFT = {
  l: 0,
  c: 0.5,
  r: 1,
  t: 0,
  m: 0.5,
  b: 1
};
OpenLayers.Protocol = OpenLayers.Class({
  format: null,
  options: null,
  autoDestroy: true,
  defaultFilter: null,
  initialize: function(options) {
    options = options || {};
    OpenLayers.Util.extend(this, options);
    this.options = options;
  },
  mergeWithDefaultFilter: function(filter) {
    var merged;
    if (filter && this.defaultFilter) {
      merged = new OpenLayers.Filter.Logical({
        type: OpenLayers.Filter.Logical.AND,
        filters: [this.defaultFilter, filter]
      });
    } else {
      merged = filter || this.defaultFilter || undefined;
    }
    return merged;
  },
  destroy: function() {
    this.options = null;
    this.format = null;
  },
  read: function(options) {
    options = options || {};
    options.filter = this.mergeWithDefaultFilter(options.filter);
  },
  create: function() {},
  update: function() {},
  delete: function() {},
  commit: function() {},
  abort: function(response) {},
  createCallback: function(method, response, options) {
    return OpenLayers.Function.bind(function() {
      method.apply(this, [response, options]);
    }, this);
  },
  CLASS_NAME: "OpenLayers.Protocol"
});
OpenLayers.Protocol.Response = OpenLayers.Class({
  code: null,
  requestType: null,
  last: true,
  features: null,
  data: null,
  reqFeatures: null,
  priv: null,
  error: null,
  initialize: function(options) {
    OpenLayers.Util.extend(this, options);
  },
  success: function() {
    return this.code > 0;
  },
  CLASS_NAME: "OpenLayers.Protocol.Response"
});
OpenLayers.Protocol.Response.SUCCESS = 1;
OpenLayers.Protocol.Response.FAILURE = 0;
OpenLayers.Protocol.HTTP = OpenLayers.Class(OpenLayers.Protocol, {
  url: null,
  headers: null,
  params: null,
  callback: null,
  scope: null,
  readWithPOST: false,
  updateWithPOST: false,
  deleteWithPOST: false,
  wildcarded: false,
  srsInBBOX: false,
  initialize: function(options) {
    options = options || {};
    this.params = {};
    this.headers = {};
    OpenLayers.Protocol.prototype.initialize.apply(this, arguments);
    if (!this.filterToParams && OpenLayers.Format.QueryStringFilter) {
      var format = new OpenLayers.Format.QueryStringFilter({
        wildcarded: this.wildcarded,
        srsInBBOX: this.srsInBBOX
      });
      this.filterToParams = function(filter, params) {
        return format.write(filter, params);
      };
    }
  },
  destroy: function() {
    this.params = null;
    this.headers = null;
    OpenLayers.Protocol.prototype.destroy.apply(this);
  },
  read: function(options) {
    OpenLayers.Protocol.prototype.read.apply(this, arguments);
    options = options || {};
    options.params = OpenLayers.Util.applyDefaults(
      options.params,
      this.options.params
    );
    options = OpenLayers.Util.applyDefaults(options, this.options);
    if (options.filter && this.filterToParams) {
      options.params = this.filterToParams(options.filter, options.params);
    }
    var readWithPOST =
      options.readWithPOST !== undefined
        ? options.readWithPOST
        : this.readWithPOST;
    var resp = new OpenLayers.Protocol.Response({ requestType: "read" });
    if (readWithPOST) {
      var headers = options.headers || {};
      headers["Content-Type"] = "application/x-www-form-urlencoded";
      resp.priv = OpenLayers.Request.POST({
        url: options.url,
        callback: this.createCallback(this.handleRead, resp, options),
        data: OpenLayers.Util.getParameterString(options.params),
        headers: headers
      });
    } else {
      resp.priv = OpenLayers.Request.GET({
        url: options.url,
        callback: this.createCallback(this.handleRead, resp, options),
        params: options.params,
        headers: options.headers
      });
    }
    return resp;
  },
  handleRead: function(resp, options) {
    this.handleResponse(resp, options);
  },
  create: function(features, options) {
    options = OpenLayers.Util.applyDefaults(options, this.options);
    var resp = new OpenLayers.Protocol.Response({
      reqFeatures: features,
      requestType: "create"
    });
    resp.priv = OpenLayers.Request.POST({
      url: options.url,
      callback: this.createCallback(this.handleCreate, resp, options),
      headers: options.headers,
      data: this.format.write(features)
    });
    return resp;
  },
  handleCreate: function(resp, options) {
    this.handleResponse(resp, options);
  },
  update: function(feature, options) {
    options = options || {};
    var url =
      options.url || feature.url || this.options.url + "/" + feature.fid;
    options = OpenLayers.Util.applyDefaults(options, this.options);
    var resp = new OpenLayers.Protocol.Response({
      reqFeatures: feature,
      requestType: "update"
    });
    var method = this.updateWithPOST ? "POST" : "PUT";
    resp.priv = OpenLayers.Request[method]({
      url: url,
      callback: this.createCallback(this.handleUpdate, resp, options),
      headers: options.headers,
      data: this.format.write(feature)
    });
    return resp;
  },
  handleUpdate: function(resp, options) {
    this.handleResponse(resp, options);
  },
  delete: function(feature, options) {
    options = options || {};
    var url =
      options.url || feature.url || this.options.url + "/" + feature.fid;
    options = OpenLayers.Util.applyDefaults(options, this.options);
    var resp = new OpenLayers.Protocol.Response({
      reqFeatures: feature,
      requestType: "delete"
    });
    var method = this.deleteWithPOST ? "POST" : "DELETE";
    var requestOptions = {
      url: url,
      callback: this.createCallback(this.handleDelete, resp, options),
      headers: options.headers
    };
    if (this.deleteWithPOST) {
      requestOptions.data = this.format.write(feature);
    }
    resp.priv = OpenLayers.Request[method](requestOptions);
    return resp;
  },
  handleDelete: function(resp, options) {
    this.handleResponse(resp, options);
  },
  handleResponse: function(resp, options) {
    var request = resp.priv;
    if (options.callback) {
      if (request.status >= 200 && request.status < 300) {
        if (resp.requestType != "delete") {
          resp.features = this.parseFeatures(request);
        }
        resp.code = OpenLayers.Protocol.Response.SUCCESS;
      } else {
        resp.code = OpenLayers.Protocol.Response.FAILURE;
      }
      options.callback.call(options.scope, resp);
    }
  },
  parseFeatures: function(request) {
    var doc = request.responseXML;
    if (!doc || !doc.documentElement) {
      doc = request.responseText;
    }
    if (!doc || doc.length <= 0) {
      return null;
    }
    return this.format.read(doc);
  },
  commit: function(features, options) {
    options = OpenLayers.Util.applyDefaults(options, this.options);
    var resp = [],
      nResponses = 0;
    var types = {};
    types[OpenLayers.State.INSERT] = [];
    types[OpenLayers.State.UPDATE] = [];
    types[OpenLayers.State.DELETE] = [];
    var feature,
      list,
      requestFeatures = [];
    for (var i = 0, len = features.length; i < len; ++i) {
      feature = features[i];
      list = types[feature.state];
      if (list) {
        list.push(feature);
        requestFeatures.push(feature);
      }
    }
    var nRequests =
      (types[OpenLayers.State.INSERT].length > 0 ? 1 : 0) +
      types[OpenLayers.State.UPDATE].length +
      types[OpenLayers.State.DELETE].length;
    var success = true;
    var finalResponse = new OpenLayers.Protocol.Response({
      reqFeatures: requestFeatures
    });
    function insertCallback(response) {
      var len = response.features ? response.features.length : 0;
      var fids = new Array(len);
      for (var i = 0; i < len; ++i) {
        fids[i] = response.features[i].fid;
      }
      finalResponse.insertIds = fids;
      callback.apply(this, [response]);
    }
    function callback(response) {
      this.callUserCallback(response, options);
      success = success && response.success();
      nResponses++;
      if (nResponses >= nRequests) {
        if (options.callback) {
          finalResponse.code = success
            ? OpenLayers.Protocol.Response.SUCCESS
            : OpenLayers.Protocol.Response.FAILURE;
          options.callback.apply(options.scope, [finalResponse]);
        }
      }
    }
    var queue = types[OpenLayers.State.INSERT];
    if (queue.length > 0) {
      resp.push(
        this.create(
          queue,
          OpenLayers.Util.applyDefaults(
            { callback: insertCallback, scope: this },
            options.create
          )
        )
      );
    }
    queue = types[OpenLayers.State.UPDATE];
    for (var i = queue.length - 1; i >= 0; --i) {
      resp.push(
        this.update(
          queue[i],
          OpenLayers.Util.applyDefaults(
            { callback: callback, scope: this },
            options.update
          )
        )
      );
    }
    queue = types[OpenLayers.State.DELETE];
    for (var i = queue.length - 1; i >= 0; --i) {
      resp.push(
        this["delete"](
          queue[i],
          OpenLayers.Util.applyDefaults(
            { callback: callback, scope: this },
            options["delete"]
          )
        )
      );
    }
    return resp;
  },
  abort: function(response) {
    if (response) {
      response.priv.abort();
    }
  },
  callUserCallback: function(resp, options) {
    var opt = options[resp.requestType];
    if (opt && opt.callback) {
      opt.callback.call(opt.scope, resp);
    }
  },
  CLASS_NAME: "OpenLayers.Protocol.HTTP"
});
OpenLayers.Control.LayerSwitcher = OpenLayers.Class(OpenLayers.Control, {
  roundedCorner: false,
  roundedCornerColor: "darkblue",
  layerStates: null,
  layersDiv: null,
  baseLayersDiv: null,
  baseLayers: null,
  dataLbl: null,
  dataLayersDiv: null,
  dataLayers: null,
  minimizeDiv: null,
  maximizeDiv: null,
  ascending: true,
  initialize: function(options) {
    OpenLayers.Control.prototype.initialize.apply(this, arguments);
    this.layerStates = [];
    if (this.roundedCorner) {
      OpenLayers.Console.warn("roundedCorner option is deprecated");
    }
  },
  destroy: function() {
    this.clearLayersArray("base");
    this.clearLayersArray("data");
    this.map.events.un({
      buttonclick: this.onButtonClick,
      addlayer: this.redraw,
      changelayer: this.redraw,
      removelayer: this.redraw,
      changebaselayer: this.redraw,
      scope: this
    });
    this.events.unregister("buttonclick", this, this.onButtonClick);
    OpenLayers.Control.prototype.destroy.apply(this, arguments);
  },
  setMap: function(map) {
    OpenLayers.Control.prototype.setMap.apply(this, arguments);
    this.map.events.on({
      addlayer: this.redraw,
      changelayer: this.redraw,
      removelayer: this.redraw,
      changebaselayer: this.redraw,
      scope: this
    });
    if (this.outsideViewport) {
      this.events.attachToElement(this.div);
      this.events.register("buttonclick", this, this.onButtonClick);
    } else {
      this.map.events.register("buttonclick", this, this.onButtonClick);
    }
  },
  draw: function() {
    OpenLayers.Control.prototype.draw.apply(this);
    this.loadContents();
    if (!this.outsideViewport) {
      this.minimizeControl();
    }
    this.redraw();
    return this.div;
  },
  onButtonClick: function(evt) {
    var button = evt.buttonElement;
    if (button === this.minimizeDiv) {
      this.minimizeControl();
    } else if (button === this.maximizeDiv) {
      this.maximizeControl();
    } else if (button._layerSwitcher === this.id) {
      if (button["for"]) {
        button = document.getElementById(button["for"]);
      }
      if (!button.disabled) {
        if (button.type == "radio") {
          button.checked = true;
          this.map.setBaseLayer(this.map.getLayer(button._layer));
        } else {
          button.checked = !button.checked;
          this.updateMap();
        }
      }
    }
  },
  clearLayersArray: function(layersType) {
    this[layersType + "LayersDiv"].innerHTML = "";
    this[layersType + "Layers"] = [];
  },
  checkRedraw: function() {
    var redraw = false;
    if (
      !this.layerStates.length ||
      this.map.layers.length != this.layerStates.length
    ) {
      redraw = true;
    } else {
      for (var i = 0, len = this.layerStates.length; i < len; i++) {
        var layerState = this.layerStates[i];
        var layer = this.map.layers[i];
        if (
          layerState.name != layer.name ||
          layerState.inRange != layer.inRange ||
          layerState.id != layer.id ||
          layerState.visibility != layer.visibility
        ) {
          redraw = true;
          break;
        }
      }
    }
    return redraw;
  },
  redraw: function() {
    if (!this.checkRedraw()) {
      return this.div;
    }
    this.clearLayersArray("base");
    this.clearLayersArray("data");
    var containsOverlays = false;
    var containsBaseLayers = false;
    var len = this.map.layers.length;
    this.layerStates = new Array(len);
    for (var i = 0; i < len; i++) {
      var layer = this.map.layers[i];
      this.layerStates[i] = {
        name: layer.name,
        visibility: layer.visibility,
        inRange: layer.inRange,
        id: layer.id
      };
    }
    var layers = this.map.layers.slice();
    if (!this.ascending) {
      layers.reverse();
    }
    for (var i = 0, len = layers.length; i < len; i++) {
      var layer = layers[i];
      var baseLayer = layer.isBaseLayer;
      if (layer.displayInLayerSwitcher) {
        if (baseLayer) {
          containsBaseLayers = true;
        } else {
          containsOverlays = true;
        }
        var checked = baseLayer
          ? layer == this.map.baseLayer
          : layer.getVisibility();
        var inputElem = document.createElement("input");
        inputElem.id = this.id + "_input_" + layer.name;
        inputElem.name = baseLayer ? this.id + "_baseLayers" : layer.name;
        inputElem.type = baseLayer ? "radio" : "checkbox";
        inputElem.value = layer.name;
        inputElem.checked = checked;
        inputElem.defaultChecked = checked;
        inputElem.className = "olButton";
        inputElem._layer = layer.id;
        inputElem._layerSwitcher = this.id;
        if (!baseLayer && !layer.inRange) {
          inputElem.disabled = true;
        }
        var labelSpan = document.createElement("label");
        labelSpan["for"] = inputElem.id;
        OpenLayers.Element.addClass(labelSpan, "labelSpan olButton");
        labelSpan._layer = layer.id;
        labelSpan._layerSwitcher = this.id;
        if (!baseLayer && !layer.inRange) {
          labelSpan.style.color = "gray";
        }
        labelSpan.innerHTML = layer.name;
        labelSpan.style.verticalAlign = baseLayer ? "bottom" : "baseline";
        var br = document.createElement("br");
        var groupArray = baseLayer ? this.baseLayers : this.dataLayers;
        groupArray.push({
          layer: layer,
          inputElem: inputElem,
          labelSpan: labelSpan
        });
        var groupDiv = baseLayer ? this.baseLayersDiv : this.dataLayersDiv;
        groupDiv.appendChild(inputElem);
        groupDiv.appendChild(labelSpan);
        groupDiv.appendChild(br);
      }
    }
    this.dataLbl.style.display = containsOverlays ? "" : "none";
    this.baseLbl.style.display = containsBaseLayers ? "" : "none";
    return this.div;
  },
  updateMap: function() {
    for (var i = 0, len = this.baseLayers.length; i < len; i++) {
      var layerEntry = this.baseLayers[i];
      if (layerEntry.inputElem.checked) {
        this.map.setBaseLayer(layerEntry.layer, false);
      }
    }
    for (var i = 0, len = this.dataLayers.length; i < len; i++) {
      var layerEntry = this.dataLayers[i];
      layerEntry.layer.setVisibility(layerEntry.inputElem.checked);
    }
  },
  maximizeControl: function(e) {
    this.div.style.width = "";
    this.div.style.height = "";
    this.showControls(false);
    if (e != null) {
      OpenLayers.Event.stop(e);
    }
  },
  minimizeControl: function(e) {
    this.div.style.width = "0px";
    this.div.style.height = "0px";
    this.showControls(true);
    if (e != null) {
      OpenLayers.Event.stop(e);
    }
  },
  showControls: function(minimize) {
    this.maximizeDiv.style.display = minimize ? "" : "none";
    this.minimizeDiv.style.display = minimize ? "none" : "";
    this.layersDiv.style.display = minimize ? "none" : "";
  },
  loadContents: function() {
    this.layersDiv = document.createElement("div");
    this.layersDiv.id = this.id + "_layersDiv";
    OpenLayers.Element.addClass(this.layersDiv, "layersDiv");
    this.baseLbl = document.createElement("div");
    this.baseLbl.innerHTML = OpenLayers.i18n("Base Layer");
    OpenLayers.Element.addClass(this.baseLbl, "baseLbl");
    this.baseLayersDiv = document.createElement("div");
    OpenLayers.Element.addClass(this.baseLayersDiv, "baseLayersDiv");
    this.dataLbl = document.createElement("div");
    this.dataLbl.innerHTML = OpenLayers.i18n("Overlays");
    OpenLayers.Element.addClass(this.dataLbl, "dataLbl");
    this.dataLayersDiv = document.createElement("div");
    OpenLayers.Element.addClass(this.dataLayersDiv, "dataLayersDiv");
    if (this.ascending) {
      this.layersDiv.appendChild(this.baseLbl);
      this.layersDiv.appendChild(this.baseLayersDiv);
      this.layersDiv.appendChild(this.dataLbl);
      this.layersDiv.appendChild(this.dataLayersDiv);
    } else {
      this.layersDiv.appendChild(this.dataLbl);
      this.layersDiv.appendChild(this.dataLayersDiv);
      this.layersDiv.appendChild(this.baseLbl);
      this.layersDiv.appendChild(this.baseLayersDiv);
    }
    this.div.appendChild(this.layersDiv);
    if (this.roundedCorner) {
      OpenLayers.Rico.Corner.round(this.div, {
        corners: "tl bl",
        bgColor: "transparent",
        color: this.roundedCornerColor,
        blend: false
      });
      OpenLayers.Rico.Corner.changeOpacity(this.layersDiv, 0.75);
    }
    var img = OpenLayers.Util.getImageLocation("layer-switcher-maximize.png");
    this.maximizeDiv = OpenLayers.Util.createAlphaImageDiv(
      "OpenLayers_Control_MaximizeDiv",
      null,
      null,
      img,
      "absolute"
    );
    OpenLayers.Element.addClass(this.maximizeDiv, "maximizeDiv olButton");
    this.maximizeDiv.style.display = "none";
    this.div.appendChild(this.maximizeDiv);
    var img = OpenLayers.Util.getImageLocation("layer-switcher-minimize.png");
    this.minimizeDiv = OpenLayers.Util.createAlphaImageDiv(
      "OpenLayers_Control_MinimizeDiv",
      null,
      null,
      img,
      "absolute"
    );
    OpenLayers.Element.addClass(this.minimizeDiv, "minimizeDiv olButton");
    this.minimizeDiv.style.display = "none";
    this.div.appendChild(this.minimizeDiv);
  },
  CLASS_NAME: "OpenLayers.Control.LayerSwitcher"
});