postrunner 0.0.10 → 0.0.11

data/misc/openlayers/lib/OpenLayers/Animation.js

@@ -1,102 +0,0 @@
-/* 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
- * @requires OpenLayers/Util/vendorPrefix.js
- */
-
-/**
- * Namespace: OpenLayers.Animation
- * A collection of utility functions for executing methods that repaint a 
- *     portion of the browser window.  These methods take advantage of the
- *     browser's scheduled repaints where requestAnimationFrame is available.
- */
-OpenLayers.Animation = (function(window) {
-    
-    /**
-     * Property: isNative
-     * {Boolean} true if a native requestAnimationFrame function is available
-     */
-    var requestAnimationFrame = OpenLayers.Util.vendorPrefix.js(window, "requestAnimationFrame");
-    var isNative = !!(requestAnimationFrame);
-    
-    /**
-     * Function: requestFrame
-     * Schedule a function to be called at the next available animation frame.
-     *     Uses the native method where available.  Where requestAnimationFrame is
-     *     not available, setTimeout will be called with a 16ms delay.
-     *
-     * Parameters:
-     * callback - {Function} The function to be called at the next animation frame.
-     * element - {DOMElement} Optional element that visually bounds the animation.
-     */
-    var requestFrame = (function() {
-        var request = window[requestAnimationFrame] ||
-            function(callback, element) {
-                window.setTimeout(callback, 16);
-            };
-        // bind to window to avoid illegal invocation of native function
-        return function(callback, element) {
-            request.apply(window, [callback, element]);
-        };
-    })();
-    
-    // private variables for animation loops
-    var counter = 0;
-    var loops = {};
-    
-    /**
-     * Function: start
-     * Executes a method with <requestFrame> in series for some 
-     *     duration.
-     *
-     * Parameters:
-     * callback - {Function} The function to be called at the next animation frame.
-     * duration - {Number} Optional duration for the loop.  If not provided, the
-     *     animation loop will execute indefinitely.
-     * element - {DOMElement} Optional element that visually bounds the animation.
-     *
-     * Returns:
-     * {Number} Identifier for the animation loop.  Used to stop animations with
-     *     <stop>.
-     */
-    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
-     * Terminates an animation loop started with <start>.
-     *
-     * Parameters:
-     * id - {Number} Identifier returned from <start>.
-     */
-    function stop(id) {
-        delete loops[id];
-    }
-    
-    return {
-        isNative: isNative,
-        requestFrame: requestFrame,
-        start: start,
-        stop: stop
-    };
-    
-})(window);

data/misc/openlayers/lib/OpenLayers/BaseTypes.js

@@ -1,463 +0,0 @@
-/* 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;
-    }
-    
-};