Metacat

    <script src="<%=STYLE_COMMON_URL%>/spatial/OpenLayers-2.13.1/OpenLayers.js"></script>

    <script src="<%=STYLE_COMMON_URL%>/spatial/OpenLayers-2.13.1/OpenLayers.js"></script>

/*

  OpenLayers.js -- OpenLayers Map Viewer Library

  Copyright (c) 2006-2013 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.

 */

/* ======================================================================

    OpenLayers/SingleFile.js

   ====================================================================== */

/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for

 * full list of contributors). Published under the 2-clause BSD license.

 * See license.txt in the OpenLayers distribution or repository for the

 * full text of the license. */

var OpenLayers = {

    /**

     * Constant: VERSION_NUMBER

     */

    VERSION_NUMBER: "Release 2.13.1",

    /**

     * Constant: singleFile

     * TODO: remove this in 3.0 when we stop supporting build profiles that

     * include OpenLayers.js

     */

    singleFile: true,

    /**

     * Method: _getScriptLocation

     * Return the path to this script. This is also implemented in

     * OpenLayers.js

     *

     * Returns:

     * {String} Path to this script

     */

    _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; });

    })(),

    /**

     * Property: ImgPath

     * {String} Set this to the path where control images are stored, a path  

     * given here must end with a slash. If set to '' (which is the default) 

     * OpenLayers will use its script location + "img/".

     * 

     * You will need to set this property when you have a singlefile build of 

     * OpenLayers that either is not named "OpenLayers.js" or if you move

     * the file in a way such that the image directory cannot be derived from 

     * the script location.

     * 

     * If your custom OpenLayers build is named "my-custom-ol.js" and the images

     * of OpenLayers are in a folder "/resources/external/images/ol" a correct

     * way of including OpenLayers in your HTML would be:

     * 

     * (code)

     *   <script src="/path/to/my-custom-ol.js" type="text/javascript"></script>

     *   <script type="text/javascript">

     *      // tell OpenLayers where the control images are

     *      // remember the trailing slash

     *      OpenLayers.ImgPath = "/resources/external/images/ol/";

     *   </script>

     * (end code)

     * 

     * Please remember that when your OpenLayers script is not named 

     * "OpenLayers.js" you will have to make sure that the default theme is 

     * loaded into the page by including an appropriate <link>-tag, 

     * e.g.:

     * 

     * (code)

     *   <link rel="stylesheet" href="/path/to/default/style.css"  type="text/css">

     * (end code)

     */

    ImgPath : ''

};

/* ======================================================================

    OpenLayers/BaseTypes/Class.js

   ====================================================================== */

/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for

 * full list of contributors). Published under the 2-clause BSD license.

 * See license.txt in the OpenLayers distribution or repository for the

 * full text of the license. */

/**

 * @requires OpenLayers/SingleFile.js

 */

/**

 * Constructor: OpenLayers.Class

 * Base class used to construct all other classes. Includes support for 

 *     multiple inheritance. 

 *     

 * This constructor is new in OpenLayers 2.5.  At OpenLayers 3.0, the old 

 *     syntax for creating classes and dealing with inheritance 

 *     will be removed.

 * 

 * To create a new OpenLayers-style class, use the following syntax:

 * (code)

 *     var MyClass = OpenLayers.Class(prototype);

 * (end)

 *

 * To create a new OpenLayers-style class with multiple inheritance, use the

 *     following syntax:

 * (code)

 *     var MyClass = OpenLayers.Class(Class1, Class2, prototype);

 * (end)

 * 

 * Note that instanceof reflection will only reveal Class1 as superclass.

 *

 */

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;

};

/**

 * Function: OpenLayers.inherit

 *

 * Parameters:

 * C - {Object} the class that inherits

 * P - {Object} the superclass to inherit from

 *

 * In addition to the mandatory C and P parameters, an arbitrary number of

 * objects can be passed, which will extend 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);

   }

};

/**

 * APIFunction: extend

 * Copy all properties of a source object to a destination object.  Modifies

 *     the passed in destination object.  Any properties on the source object

 *     that are set to undefined will not be (re)set on the destination object.

 *

 * Parameters:

 * destination - {Object} The object that will be modified

 * source - {Object} The object with properties to be set on the destination

 *

 * Returns:

 * {Object} The destination object.

 */

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;

            }

        }

        /**

         * IE doesn't include the toString property when iterating over an object's

         * properties with the for(property in object) syntax.  Explicitly check if

         * the source has its own toString property.

         */

        /*

         * FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative

         * prototype object" when calling hawOwnProperty if the source object

         * is an instance of window.Event.

         */

        var sourceIsEvt = typeof window.Event == "function"

                          && source instanceof window.Event;

        if (!sourceIsEvt

           && source.hasOwnProperty && source.hasOwnProperty("toString")) {

            destination.toString = source.toString;

        }

    }

    return destination;

};

/* ======================================================================

    OpenLayers/BaseTypes.js

   ====================================================================== */

/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for

 * full list of contributors). Published under the 2-clause BSD license.

 * See license.txt in the OpenLayers distribution or repository for the

 * full text of the license. */

/**

 * @requires OpenLayers/SingleFile.js

 */

/** 

 * Header: OpenLayers Base Types

 * OpenLayers custom string, number and function functions are described here.

 */

/**

 * Namespace: OpenLayers.String

 * Contains convenience functions for string manipulation.

 */

OpenLayers.String = {

    /**

     * APIFunction: startsWith

     * Test whether a string starts with another string. 

     * 

     * Parameters:

     * str - {String} The string to test.

     * sub - {String} The substring to look for.

     *  

     * Returns:

     * {Boolean} The first string starts with the second.

     */

    startsWith: function(str, sub) {

        return (str.indexOf(sub) == 0);

    },

    /**

     * APIFunction: contains

     * Test whether a string contains another string.

     * 

     * Parameters:

     * str - {String} The string to test.

     * sub - {String} The substring to look for.

     * 

     * Returns:

     * {Boolean} The first string contains the second.

     */

    contains: function(str, sub) {

        return (str.indexOf(sub) != -1);

    },

    /**

     * APIFunction: trim

     * Removes leading and trailing whitespace characters from a string.

     * 

     * Parameters:

     * str - {String} The (potentially) space padded string.  This string is not

     *     modified.

     * 

     * Returns:

     * {String} A trimmed version of the string with all leading and 

     *     trailing spaces removed.

     */

    trim: function(str) {

        return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');

    },

    /**

     * APIFunction: camelize

     * Camel-case a hyphenated string. 

     *     Ex. "chicken-head" becomes "chickenHead", and

     *     "-chicken-head" becomes "ChickenHead".

     *

     * Parameters:

     * str - {String} The string to be camelized.  The original is not modified.

     * 

     * Returns:

     * {String} The string, camelized

     */

    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;

    },

    /**

     * APIFunction: format

     * Given a string with tokens in the form ${token}, return a string

     *     with tokens replaced with properties from the given context

     *     object.  Represent a literal "${" by doubling it, e.g. "${${".

     *

     * Parameters:

     * template - {String} A string with tokens to be replaced.  A template

     *     has the form "literal ${token}" where the token will be replaced

     *     by the value of context["token"].

     * context - {Object} An optional object with properties corresponding

     *     to the tokens in the format string.  If no context is sent, the

     *     window object will be used.

     * args - {Array} Optional arguments to pass to any functions found in

     *     the context.  If a context property is a function, the token

     *     will be replaced by the return from the function called with

     *     these arguments.

     *

     * Returns:

     * {String} A string with tokens replaced from the context object.

     */

    format: function(template, context, args) {

        if(!context) {

            context = window;

        }

        // Example matching: 

        // str   = ${foo.bar}

        // match = foo.bar

        var replacer = function(str, match) {

            var replacement;

            // Loop through all subs. Example: ${a.b.c}

            // 0 -> replacement = context[a];

            // 1 -> replacement = context[a][b];

            // 2 -> replacement = context[a][b][c];

            var subs = match.split(/\.+/);

            for (var i=0; i< subs.length; i++) {

                if (i == 0) {

                    replacement = context;

                }

                if (replacement === undefined) {

                    break;

                }

                replacement = replacement[subs[i]];

            }

            if(typeof replacement == "function") {

                replacement = args ?

                    replacement.apply(null, args) :

                    replacement();

            }

            // If replacement is undefined, return the string 'undefined'.

            // This is a workaround for a bugs in browsers not properly 

            // dealing with non-participating groups in regular expressions:

            // http://blog.stevenlevithan.com/archives/npcg-javascript

            if (typeof replacement == 'undefined') {

                return 'undefined';

            } else {

                return replacement; 

            }

        };

        return template.replace(OpenLayers.String.tokenRegEx, replacer);

    },

    /**

     * Property: tokenRegEx

     * Used to find tokens in a string.

     * Examples: ${a}, ${a.b.c}, ${a-b}, ${5}

     */

    tokenRegEx:  /\$\{([\w.]+?)\}/g,

    /**

     * Property: numberRegEx

     * Used to test strings as numbers.

     */

    numberRegEx: /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/,

    /**

     * APIFunction: isNumeric

     * Determine whether a string contains only a numeric value.

     *

     * Examples:

     * (code)

     * OpenLayers.String.isNumeric("6.02e23") // true

     * OpenLayers.String.isNumeric("12 dozen") // false

     * OpenLayers.String.isNumeric("4") // true

     * OpenLayers.String.isNumeric(" 4 ") // false

     * (end)

     *

     * Returns:

     * {Boolean} String contains only a number.

     */

    isNumeric: function(value) {

        return OpenLayers.String.numberRegEx.test(value);

    },

    /**

     * APIFunction: numericIf

     * Converts a string that appears to be a numeric value into a number.

     * 

     * Parameters:

     * value - {String}

     * trimWhitespace - {Boolean}

     *

     * Returns:

     * {Number|String} a Number if the passed value is a number, a String

     *     otherwise. 

     */

    numericIf: function(value, trimWhitespace) {

        var originalValue = value;

        if (trimWhitespace === true && value != null && value.replace) {

            value = value.replace(/^\s*|\s*$/g, "");

        }

        return OpenLayers.String.isNumeric(value) ? parseFloat(value) : originalValue;

    }

};

/**

 * Namespace: OpenLayers.Number

 * Contains convenience functions for manipulating numbers.

 */

OpenLayers.Number = {

    /**

     * Property: decimalSeparator

     * Decimal separator to use when formatting numbers.

     */

    decimalSeparator: ".",

    /**

     * Property: thousandsSeparator

     * Thousands separator to use when formatting numbers.

     */

    thousandsSeparator: ",",

    /**

     * APIFunction: limitSigDigs

     * Limit the number of significant digits on a float.

     * 

     * Parameters:

     * num - {Float}

     * sig - {Integer}

     * 

     * Returns:

     * {Float} The number, rounded to the specified number of significant

     *     digits.

     */

    limitSigDigs: function(num, sig) {

        var fig = 0;

        if (sig > 0) {

            fig = parseFloat(num.toPrecision(sig));

        }

        return fig;

    },

    /**

     * APIFunction: format

     * Formats a number for output.

     * 

     * Parameters:

     * num  - {Float}

     * dec  - {Integer} Number of decimal places to round to.

     *        Defaults to 0. Set to null to leave decimal places unchanged.

     * tsep - {String} Thousands separator.

     *        Default is ",".

     * dsep - {String} Decimal separator.

     *        Default is ".".

     *

     * Returns:

     * {String} A string representing the formatted number.

     */

    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) {

            // integer where we do not want to touch the decimals

            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;

    },

    /**

     * Method: zeroPad

     * Create a zero padded string optionally with a radix for casting numbers.

     *

     * Parameters:

     * num - {Number} The number to be zero padded.

     * len - {Number} The length of the string to be returned.

     * radix - {Number} An integer between 2 and 36 specifying the base to use

     *     for representing numeric values.

     */

    zeroPad: function(num, len, radix) {

        var str = num.toString(radix || 10);

        while (str.length < len) {

            str = "0" + str;

        }

        return str;

    }    

};

/**

 * Namespace: OpenLayers.Function

 * Contains convenience functions for function manipulation.

 */

OpenLayers.Function = {

    /**

     * APIFunction: bind

     * Bind a function to an object.  Method to easily create closures with

     *     'this' altered.

     * 

     * Parameters:

     * func - {Function} Input function.

     * object - {Object} The object to bind to the input function (as this).

     * 

     * Returns:

     * {Function} A closure with 'this' set to the passed in object.

     */

    bind: function(func, object) {

        // create a reference to all arguments past the second one

        var args = Array.prototype.slice.apply(arguments, [2]);

        return function() {

            // Push on any additional arguments from the actual function call.

            // These will come after those sent to the bind call.

            var newArgs = args.concat(

                Array.prototype.slice.apply(arguments, [0])

            );

            return func.apply(object, newArgs);

        };

    },

    /**

     * APIFunction: bindAsEventListener

     * Bind a function to an object, and configure it to receive the event

     *     object as first parameter when called. 

     * 

     * Parameters:

     * func - {Function} Input function to serve as an event listener.

     * object - {Object} A reference to this.

     * 

     * Returns:

     * {Function}

     */

    bindAsEventListener: function(func, object) {

        return function(event) {

            return func.call(object, event || window.event);

        };

    },

    /**

     * APIFunction: False

     * A simple function to that just does "return false". We use this to 

     * avoid attaching anonymous functions to DOM event handlers, which 

     * causes "issues" on IE<8.

     * 

     * Usage:

     * document.onclick = OpenLayers.Function.False;

     * 

     * Returns:

     * {Boolean}

     */

    False : function() {

        return false;

    },

    /**

     * APIFunction: True

     * A simple function to that just does "return true". We use this to 

     * avoid attaching anonymous functions to DOM event handlers, which 

     * causes "issues" on IE<8.

     * 

     * Usage:

     * document.onclick = OpenLayers.Function.True;

     * 

     * Returns:

     * {Boolean}

     */

    True : function() {

        return true;

    },

    /**

     * APIFunction: Void

     * A reusable function that returns ``undefined``.

     *

     * Returns:

     * {undefined}

     */

    Void: function() {}

};

/**

 * Namespace: OpenLayers.Array

 * Contains convenience functions for array manipulation.

 */

OpenLayers.Array = {

    /**

     * APIMethod: filter

     * Filter an array.  Provides the functionality of the

     *     Array.prototype.filter extension to the ECMA-262 standard.  Where

     *     available, Array.prototype.filter will be used.

     *

     * Based on well known example from http://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Array/filter

     *

     * Parameters:

     * array - {Array} The array to be filtered.  This array is not mutated.

     *     Elements added to this array by the callback will not be visited.

     * callback - {Function} A function that is called for each element in

     *     the array.  If this function returns true, the element will be

     *     included in the return.  The function will be called with three

     *     arguments: the element in the array, the index of that element, and

     *     the array itself.  If the optional caller parameter is specified

     *     the callback will be called with this set to caller.

     * caller - {Object} Optional object to be set as this when the callback

     *     is called.

     *

     * Returns:

     * {Array} An array of elements from the passed in array for which the

     *     callback returns true.

     */

    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/BaseTypes/Bounds.js

   ====================================================================== */

/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for

 * full list of contributors). Published under the 2-clause BSD license.

 * See license.txt in the OpenLayers distribution or repository for the

 * full text of the license. */

/**

 * @requires OpenLayers/BaseTypes/Class.js

 */

/**

 * Class: OpenLayers.Bounds

 * Instances of this class represent bounding boxes.  Data stored as left,

 * bottom, right, top floats. All values are initialized to null, however,

 * you should make sure you set them before using the bounds for anything.

 * 

 * Possible use case:

 * (code)

 *     bounds = new OpenLayers.Bounds();

 *     bounds.extend(new OpenLayers.LonLat(4,5));

 *     bounds.extend(new OpenLayers.LonLat(5,6));

 *     bounds.toBBOX(); // returns 4,5,5,6

 * (end)

 */

OpenLayers.Bounds = OpenLayers.Class({

    /**

     * Property: left

     * {Number} Minimum horizontal coordinate.

     */

    left: null,

    /**

     * Property: bottom

     * {Number} Minimum vertical coordinate.

     */

    bottom: null,

    /**

     * Property: right

     * {Number} Maximum horizontal coordinate.

     */

    right: null,

    /**

     * Property: top

     * {Number} Maximum vertical coordinate.

     */

    top: null,

    /**

     * Property: centerLonLat

     * {<OpenLayers.LonLat>} A cached center location.  This should not be

     *     accessed directly.  Use <getCenterLonLat> instead.

     */

    centerLonLat: null,

    /**

     * Constructor: OpenLayers.Bounds

     * Construct a new bounds object. Coordinates can either be passed as four

     * arguments, or as a single argument.

     *

     * Parameters (four arguments):

     * left - {Number} The left bounds of the box.  Note that for width

     *        calculations, this is assumed to be less than the right value.

     * bottom - {Number} The bottom bounds of the box.  Note that for height

     *          calculations, this is assumed to be less than the top value.

     * right - {Number} The right bounds.

     * top - {Number} The top bounds.

     *

     * Parameters (single argument):

     * bounds - {Array(Number)} [left, bottom, right, top]

     */

    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);

        }

    },

    /**

     * Method: clone

     * Create a cloned instance of this bounds.

     *

     * Returns:

     * {<OpenLayers.Bounds>} A fresh copy of the bounds

     */

    clone:function() {

        return new OpenLayers.Bounds(this.left, this.bottom, 

                                     this.right, this.top);

    },

    /**

     * Method: equals

     * Test a two bounds for equivalence.

     *

     * Parameters:

     * bounds - {<OpenLayers.Bounds>}

     *

     * Returns:

     * {Boolean} The passed-in bounds object has the same left,

     *           right, top, bottom components as this.  Note that if bounds 

     *           passed in is null, returns false.

     */

    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;

    },

    /** 

     * APIMethod: toString

     * Returns a string representation of the bounds object.

     * 

     * Returns:

     * {String} String representation of bounds object. 

     */

    toString:function() {

        return [this.left, this.bottom, this.right, this.top].join(",");

    },

    /**

     * APIMethod: toArray

     * Returns an array representation of the bounds object.

     *

     * Returns an array of left, bottom, right, top properties, or -- when the

     *     optional parameter is true -- an array of the  bottom, left, top,

     *     right properties.

     *

     * Parameters:

     * reverseAxisOrder - {Boolean} Should we reverse the axis order?

     *

     * Returns:

     * {Array} array of left, bottom, right, top

     */

    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];

        }

    },    

    /** 

     * APIMethod: toBBOX

     * Returns a boundingbox-string representation of the bounds object.

     * 

     * Parameters:

     * decimal - {Integer} How many significant digits in the bbox coords?

     *                     Default is 6

     * reverseAxisOrder - {Boolean} Should we reverse the axis order?

     * 

     * Returns:

     * {String} Simple String representation of bounds object.

     *          (e.g. "5,42,10,45")

     */

    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;

        }

    },

    /**

     * APIMethod: toGeometry

     * Create a new polygon geometry based on this bounds.

     *

     * Returns:

     * {<OpenLayers.Geometry.Polygon>} A new polygon with the coordinates

     *     of this bounds.

     */

    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)

            ])

        ]);

    },

    /**

     * APIMethod: getWidth

     * Returns the width of the bounds.

     * 

     * Returns:

     * {Float} The width of the bounds (right minus left).

     */

    getWidth:function() {

        return (this.right - this.left);

    },

    /**

     * APIMethod: getHeight

     * Returns the height of the bounds.

     * 

     * Returns:

     * {Float} The height of the bounds (top minus bottom).

     */

    getHeight:function() {

        return (this.top - this.bottom);

    },

    /**

     * APIMethod: getSize

     * Returns an <OpenLayers.Size> object of the bounds.

     * 

     * Returns:

     * {<OpenLayers.Size>} The size of the bounds.

     */

    getSize:function() {

        return new OpenLayers.Size(this.getWidth(), this.getHeight());

    },

    /**

     * APIMethod: getCenterPixel

     * Returns the <OpenLayers.Pixel> object which represents the center of the

     *     bounds.

     * 

     * Returns:

     * {<OpenLayers.Pixel>} The center of the bounds in pixel space.

     */

    getCenterPixel:function() {

        return new OpenLayers.Pixel( (this.left + this.right) / 2,

                                     (this.bottom + this.top) / 2);

    },

    /**

     * APIMethod: getCenterLonLat

     * Returns the <OpenLayers.LonLat> object which represents the center of the

     *     bounds.

     *

     * Returns:

     * {<OpenLayers.LonLat>} The center of the bounds in map space.

     */

    getCenterLonLat:function() {

        if(!this.centerLonLat) {

            this.centerLonLat = new OpenLayers.LonLat(

                (this.left + this.right) / 2, (this.bottom + this.top) / 2

            );

        }

        return this.centerLonLat;

    },

    /**

     * APIMethod: scale

     * Scales the bounds around a pixel or lonlat. Note that the new 

     *     bounds may return non-integer properties, even if a pixel

     *     is passed. 

     * 

     * Parameters:

     * ratio - {Float} 

     * origin - {<OpenLayers.Pixel> or <OpenLayers.LonLat>}

     *          Default is center.

     *

     * Returns:

     * {<OpenLayers.Bounds>} A new bounds that is scaled by ratio

     *                      from origin.

     */

    scale: function(ratio, origin){

        if(origin == null){

            origin = this.getCenterLonLat();

        }

        var origx,origy;

        // get origin coordinates

        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);

    },

    /**

     * APIMethod: add

     * Shifts the coordinates of the bound by the given horizontal and vertical

     *     deltas.

     *

     * (start code)

     * var bounds = new OpenLayers.Bounds(0, 0, 10, 10);

     * bounds.toString();

     * // => "0,0,10,10"

     *

     * bounds.add(-1.5, 4).toString();

     * // => "-1.5,4,8.5,14"

     * (end)

     *

     * This method will throw a TypeError if it is passed null as an argument.

     *

     * Parameters:

     * x - {Float} horizontal delta

     * y - {Float} vertical delta

     *

     * Returns:

     * {<OpenLayers.Bounds>} A new bounds whose coordinates are the same as

     *     this, but shifted by the passed-in x and y values.

     */

    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);

    },

    /**

     * APIMethod: extend

     * Extend the bounds to include the <OpenLayers.LonLat>,

     *     <OpenLayers.Geometry.Point> or <OpenLayers.Bounds> specified.

     *

     * Please note that this function assumes that left < right and

     *     bottom < top.

     *

     * Parameters:

     * object - {<OpenLayers.LonLat>, <OpenLayers.Geometry.Point> or

     *     <OpenLayers.Bounds>} The object to be included in the new bounds

     *     object.

     */

    extend:function(object) {

        if (object) {

            switch(object.CLASS_NAME) {

                case "OpenLayers.LonLat":

                    this.extendXY(object.lon, object.lat);

                    break;

                case "OpenLayers.Geometry.Point":

                    this.extendXY(object.x, object.y);

                    break;

                case "OpenLayers.Bounds":

                    // clear cached center location

                    this.centerLonLat = null;

                    if ( (this.left == null) || (object.left < this.left)) {

                        this.left = object.left;

                    }

                    if ( (this.bottom == null) || (object.bottom < this.bottom) ) {

                        this.bottom = object.bottom;

                    }

                    if ( (this.right == null) || (object.right > this.right) ) {

                        this.right = object.right;

                    }

                    if ( (this.top == null) || (object.top > this.top) ) {

                        this.top = object.top;

                    }

                    break;

            }

        }

    },

    /**

     * APIMethod: extendXY

     * Extend the bounds to include the XY coordinate specified.

     *

     * Parameters:

     * x - {number} The X part of the the coordinate.

     * y - {number} The Y part of the the coordinate.

     */

    extendXY:function(x, y) {

        // clear cached center location

        this.centerLonLat = null;

        if ((this.left == null) || (x < this.left)) {

            this.left = x;

        }

        if ((this.bottom == null) || (y < this.bottom)) {

            this.bottom = y;

        }

        if ((this.right == null) || (x > this.right)) {

            this.right = x;

        }

        if ((this.top == null) || (y > this.top)) {

            this.top = y;

        }

    },

    /**

     * APIMethod: containsLonLat

     * Returns whether the bounds object contains the given <OpenLayers.LonLat>.

     * 

     * Parameters:

     * ll - {<OpenLayers.LonLat>|Object} OpenLayers.LonLat or an

     *     object with a 'lon' and 'lat' properties.

     * options - {Object} Optional parameters

     *

     * Acceptable options:

     * inclusive - {Boolean} Whether or not to include the border.

     *     Default is true.

     * worldBounds - {<OpenLayers.Bounds>} If a worldBounds is provided, the

     *     ll will be considered as contained if it exceeds the world bounds,

     *     but can be wrapped around the dateline so it is contained by this

     *     bounds.

     *

     * Returns:

     * {Boolean} The passed-in lonlat is within this bounds.

     */

    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;

    },

    /**

     * APIMethod: containsPixel

     * Returns whether the bounds object contains the given <OpenLayers.Pixel>.

     * 

     * Parameters:

     * px - {<OpenLayers.Pixel>}

     * inclusive - {Boolean} Whether or not to include the border. Default is

     *     true.

     *

     * Returns:

     * {Boolean} The passed-in pixel is within this bounds.

     */

    containsPixel:function(px, inclusive) {

        return this.contains(px.x, px.y, inclusive);

    },

    /**

     * APIMethod: contains

     * Returns whether the bounds object contains the given x and y.

     * 

     * Parameters:

     * x - {Float}

     * y - {Float}

     * inclusive - {Boolean} Whether or not to include the border. Default is

     *     true.

     *

     * Returns:

     * {Boolean} Whether or not the passed-in coordinates are within this

     *     bounds.

     */

    contains:function(x, y, inclusive) {

        //set default

        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;

    },

    /**

     * APIMethod: intersectsBounds

     * Determine whether the target bounds intersects this bounds.  Bounds are

     *     considered intersecting if any of their edges intersect or if one

     *     bounds contains the other.

     * 

     * Parameters:

     * bounds - {<OpenLayers.Bounds>} The target bounds.

     * options - {Object} Optional parameters.

     * 

     * Acceptable options:

     * inclusive - {Boolean} Treat coincident borders as intersecting.  Default

     *     is true.  If false, bounds that do not overlap but only touch at the

     *     border will not be considered as intersecting.

     * worldBounds - {<OpenLayers.Bounds>} If a worldBounds is provided, two

     *     bounds will be considered as intersecting if they intersect when 

     *     shifted to within the world bounds.  This applies only to bounds that

     *     cross or are completely outside the world bounds.

     *

     * Returns:

     * {Boolean} The passed-in bounds object intersects this bounds.

     */

    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 the two bounds only touch at an edge, and inclusive is false,

        // then the bounds don't *really* intersect.

        if (options.inclusive || !mightTouch) {

            // otherwise, if one of the boundaries even partially contains another,

            // inclusive of the edges, then they do intersect.

            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));

        }

        // document me

        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;

    },

    /**

     * APIMethod: containsBounds

     * Returns whether the bounds object contains the given <OpenLayers.Bounds>.

     * 

     * bounds - {<OpenLayers.Bounds>} The target bounds.

     * partial - {Boolean} If any of the target corners is within this bounds

     *     consider the bounds contained.  Default is false.  If false, the

     *     entire target bounds must be contained within this bounds.

     * inclusive - {Boolean} Treat shared edges as contained.  Default is

     *     true.

     *

     * Returns:

     * {Boolean} The passed-in bounds object is contained within this bounds. 

     */

    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);

    },

    /** 

     * APIMethod: determineQuadrant

     * Returns the the quadrant ("br", "tr", "tl", "bl") in which the given

     *     <OpenLayers.LonLat> lies.

     *

     * Parameters:

     * lonlat - {<OpenLayers.LonLat>}

     *

     * Returns:

     * {String} The quadrant ("br" "tr" "tl" "bl") of the bounds in which the

     *     coordinate lies.

     */

    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; 

    },

    /**

     * APIMethod: transform

     * Transform the Bounds object from source to dest. 

     *

     * Parameters: 

     * source - {<OpenLayers.Projection>} Source projection. 

     * dest   - {<OpenLayers.Projection>} Destination projection. 

     *

     * Returns:

     * {<OpenLayers.Bounds>} Itself, for use in chaining operations.

     */

    transform: function(source, dest) {

        // clear cached center location

        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;

    },

    /**

     * APIMethod: wrapDateLine

     * Wraps the bounds object around the dateline.

     *  

     * Parameters:

     * maxExtent - {<OpenLayers.Bounds>}

     * options - {Object} Some possible options are:

     *

     * Allowed Options:

     *                    leftTolerance - {float} Allow for a margin of error 

     *                                            with the 'left' value of this 

     *                                            bound.

     *                                            Default is 0.

     *                    rightTolerance - {float} Allow for a margin of error 

     *                                             with the 'right' value of 

     *                                             this bound.

     *                                             Default is 0.

     * 

     * Returns:

     * {<OpenLayers.Bounds>} A copy of this bounds, but wrapped around the 

     *                       "dateline" (as specified by the borders of 

     *                       maxExtent). Note that this function only returns 

     *                       a different bounds value if this bounds is 

     *                       *entirely* outside of the maxExtent. If this 

     *                       bounds straddles the dateline (is part in/part 

     *                       out of maxExtent), the returned bounds will always 

     *                       cross the left edge of the given maxExtent.

     *.

     */

    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();

            //shift right?

            while (newBounds.left < maxExtent.left && 

                   newBounds.right - rightTolerance <= maxExtent.left ) { 

                newBounds = newBounds.add(width, 0);

            }

            //shift left?

            while (newBounds.left + leftTolerance >= maxExtent.right && 

                   newBounds.right > maxExtent.right ) { 

                newBounds = newBounds.add(-width, 0);

            }

            // crosses right only? force left

            var newLeft = newBounds.left + leftTolerance;

            if (newLeft < maxExtent.right && newLeft > maxExtent.left && 

                   newBounds.right - rightTolerance > maxExtent.right) {

                newBounds = newBounds.add(-width, 0);

            }

        }

        return newBounds;

    },