simpletool 0.0.3 → 0.0.4

data/lib/support/phpmyadmin/phpmyadmin/js/openlayers/src/openlayers/lib/OpenLayers/Strategy/Filter.js

@@ -1,164 +0,0 @@
-/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for 
- * full list of contributors). Published under the Clear BSD license.  
- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Strategy.js
- * @requires OpenLayers/Filter.js
- */
-
-/**
- * Class: OpenLayers.Strategy.Filter
- * Strategy for limiting features that get added to a layer by 
- *     evaluating a filter.  The strategy maintains a cache of
- *     all features until removeFeatures is called on the layer.
- *
- * Inherits from:
- *  - <OpenLayers.Strategy>
- */
-OpenLayers.Strategy.Filter = OpenLayers.Class(OpenLayers.Strategy, {
-    
-    /**
-     * APIProperty: filter
-     * {<OpenLayers.Filter>}  Filter for limiting features sent to the layer.
-     *     Use the <setFilter> method to update this filter after construction.
-     */
-    filter: null,
-    
-    /**
-     * Property: cache
-     * {Array(<OpenLayers.Feature.Vector>)} List of currently cached
-     *     features.
-     */
-    cache: null,
-    
-    /**
-     * Property: caching
-     * {Boolean} The filter is currently caching features.
-     */
-    caching: false,
-    
-    /**
-     * Constructor: OpenLayers.Strategy.Filter
-     * Create a new filter strategy.
-     *
-     * Parameters:
-     * options - {Object} Optional object whose properties will be set on the
-     *     instance.  Strategy must be constructed with at least a <filter> 
-     *     property.
-     */
-    initialize: function(options) {
-        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
-        if (!this.filter || !(this.filter instanceof OpenLayers.Filter)) {
-            throw new Error("Filter strategy must be constructed with a filter");
-        }
-    },
-
-    /**
-     * APIMethod: activate
-     * Activate the strategy.  Register any listeners, do appropriate setup.
-     *     By default, this strategy automatically activates itself when a layer
-     *     is added to a map.
-     *
-     * Returns:
-     * {Boolean} True if the strategy was successfully activated or false if
-     *      the strategy was already active.
-     */
-    activate: function() {
-        var activated = OpenLayers.Strategy.prototype.activate.apply(this, arguments);
-        if (activated) {
-            this.cache = [];
-            this.layer.events.on({
-                "beforefeaturesadded": this.handleAdd,
-                "beforefeaturesremoved": this.handleRemove,
-                scope: this
-            });
-        }
-        return activated;
-    },
-    
-    /**
-     * APIMethod: deactivate
-     * Deactivate the strategy.  Clear the feature cache.
-     *
-     * Returns:
-     * {Boolean} True if the strategy was successfully deactivated or false if
-     *      the strategy was already inactive.
-     */
-    deactivate: function() {
-        this.cache = null;
-        if (this.layer && this.layer.events) {
-            this.layer.events.un({
-                "beforefeaturesadded": this.handleAdd,
-                "beforefeaturesremoved": this.handleRemove,
-                scope: this
-            });            
-        }
-        return OpenLayers.Strategy.prototype.deactivate.apply(this, arguments);
-    },
-    
-    /**
-     * Method: handleAdd
-     */
-    handleAdd: function(event) {
-        if (!this.caching) {
-            var features = event.features;
-            event.features = [];
-            var feature;
-            for (var i=0, ii=features.length; i<ii; ++i) {
-                feature = features[i];
-                if (this.filter.evaluate(feature)) {
-                    event.features.push(feature);
-                } else {
-                    this.cache.push(feature);
-                }
-            }
-        }
-    },
-    
-    /**
-     * Method: handleRemove
-     */
-    handleRemove: function(event) {
-        if (!this.caching) {
-            this.cache = [];
-        }
-    },
-
-    /** 
-     * APIMethod: setFilter
-     * Update the filter for this strategy.  This will re-evaluate
-     *     any features on the layer and in the cache.  Only features
-     *     for which filter.evalute(feature) returns true will be
-     *     added to the layer.  Others will be cached by the strategy.
-     *
-     * Parameters:
-     * filter - <OpenLayers.Filter> A filter for evaluating features.
-     */
-    setFilter: function(filter) {
-        this.filter = filter;
-        var previousCache = this.cache;
-        this.cache = [];
-        // look through layer for features to remove from layer
-        this.handleAdd({features: this.layer.features});
-        // cache now contains features to remove from layer
-        if (this.cache.length > 0) {
-            this.caching = true;
-            this.layer.removeFeatures(this.cache.slice(), {silent: true});
-            this.caching = false;
-        }
-        // now look through previous cache for features to add to layer
-        if (previousCache.length > 0) {
-            var event = {features: previousCache};
-            this.handleAdd(event);
-            // event has features to add to layer
-            this.caching = true;
-            this.layer.addFeatures(event.features, {silent: true});
-            this.caching = false;
-        }
-    },
-
-    CLASS_NAME: "OpenLayers.Strategy.Filter"
-
-});

data/lib/support/phpmyadmin/phpmyadmin/js/openlayers/src/openlayers/lib/OpenLayers/Strategy/Fixed.js

@@ -1,138 +0,0 @@
-/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for 
- * full list of contributors). Published under the Clear BSD license.  
- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Strategy.js
- */
-
-/**
- * Class: OpenLayers.Strategy.Fixed
- * A simple strategy that requests features once and never requests new data.
- *
- * Inherits from:
- *  - <OpenLayers.Strategy>
- */
-OpenLayers.Strategy.Fixed = OpenLayers.Class(OpenLayers.Strategy, {
-    
-    /**
-     * APIProperty: preload
-     * {Boolean} Load data before layer made visible. Enabling this may result
-     *   in considerable overhead if your application loads many data layers
-     *   that are not visible by default. Default is false.
-     */
-    preload: false,
-
-    /**
-     * Constructor: OpenLayers.Strategy.Fixed
-     * Create a new Fixed strategy.
-     *
-     * Parameters:
-     * options - {Object} Optional object whose properties will be set on the
-     *     instance.
-     */
-    initialize: function(options) {
-        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
-    },
-
-    /**
-     * APIMethod: destroy
-     * Clean up the strategy.
-     */
-    destroy: function() {
-        OpenLayers.Strategy.prototype.destroy.apply(this, arguments);
-    },
-
-    /**
-     * Method: activate
-     * Activate the strategy: load data or add listener to load when visible
-     *
-     * Returns:
-     * {Boolean} True if the strategy was successfully activated or false if
-     *      the strategy was already active.
-     */
-    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;
-    },
-    
-    /**
-     * Method: deactivate
-     * Deactivate the strategy.  Undo what is done in <activate>.
-     * 
-     * Returns:
-     * {Boolean} The strategy was successfully deactivated.
-     */
-    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;
-    },
-
-    /**
-     * Method: load
-     * Tells protocol to load data and unhooks the visibilitychanged event
-     *
-     * Parameters:
-     * options - {Object} options to pass to protocol read.
-     */
-    load: function(options) {
-        this.layer.events.triggerEvent("loadstart");
-        this.layer.protocol.read(OpenLayers.Util.applyDefaults({
-            callback: this.merge,
-            filter: this.layer.filter,
-            scope: this
-        }, options));
-        this.layer.events.un({
-            "visibilitychanged": this.load,
-            scope: this
-        });
-    },
-
-    /**
-     * Method: merge
-     * Add all features to the layer.
-     */
-    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.layer.events.triggerEvent("loadend");
-    },
-
-    CLASS_NAME: "OpenLayers.Strategy.Fixed"
-});

data/lib/support/phpmyadmin/phpmyadmin/js/openlayers/src/openlayers/lib/OpenLayers/Strategy/Paging.js

@@ -1,236 +0,0 @@
-/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for 
- * full list of contributors). Published under the Clear BSD license.  
- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Strategy.js
- */
-
-/**
- * Class: OpenLayers.Strategy.Paging
- * Strategy for vector feature paging
- *
- * Inherits from:
- *  - <OpenLayers.Strategy>
- */
-OpenLayers.Strategy.Paging = OpenLayers.Class(OpenLayers.Strategy, {
-    
-    /**
-     * Property: features
-     * {Array(<OpenLayers.Feature.Vector>)} Cached features.
-     */
-    features: null,
-    
-    /**
-     * Property: length
-     * {Integer} Number of features per page.  Default is 10.
-     */
-    length: 10,
-    
-    /**
-     * Property: num
-     * {Integer} The currently displayed page number.
-     */
-    num: null,
-    
-    /**
-     * Property: paging
-     * {Boolean} The strategy is currently changing pages.
-     */
-    paging: false,
-
-    /**
-     * Constructor: OpenLayers.Strategy.Paging
-     * Create a new paging strategy.
-     *
-     * Parameters:
-     * options - {Object} Optional object whose properties will be set on the
-     *     instance.
-     */
-    initialize: function(options) {
-        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
-    },
-    
-    /**
-     * APIMethod: activate
-     * Activate the strategy.  Register any listeners, do appropriate setup.
-     * 
-     * Returns:
-     * {Boolean} The strategy was successfully activated.
-     */
-    activate: function() {
-        var activated = OpenLayers.Strategy.prototype.activate.call(this);
-        if(activated) {
-            this.layer.events.on({
-                "beforefeaturesadded": this.cacheFeatures,
-                scope: this
-            });
-        }
-        return activated;
-    },
-    
-    /**
-     * APIMethod: deactivate
-     * Deactivate the strategy.  Unregister any listeners, do appropriate
-     *     tear-down.
-     * 
-     * Returns:
-     * {Boolean} The strategy was successfully deactivated.
-     */
-    deactivate: function() {
-        var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
-        if(deactivated) {
-            this.clearCache();
-            this.layer.events.un({
-                "beforefeaturesadded": this.cacheFeatures,
-                scope: this
-            });
-        }
-        return deactivated;
-    },
-    
-    /**
-     * Method: cacheFeatures
-     * Cache features before they are added to the layer.
-     *
-     * Parameters:
-     * event - {Object} The event that this was listening for.  This will come
-     *     with a batch of features to be paged.
-     */
-    cacheFeatures: function(event) {
-        if(!this.paging) {
-            this.clearCache();
-            this.features = event.features;
-            this.pageNext(event);
-        }
-    },
-    
-    /**
-     * Method: clearCache
-     * Clear out the cached features.  This destroys features, assuming
-     *     nothing else has a reference.
-     */
-    clearCache: function() {
-        if(this.features) {
-            for(var i=0; i<this.features.length; ++i) {
-                this.features[i].destroy();
-            }
-        }
-        this.features = null;
-        this.num = null;
-    },
-    
-    /**
-     * APIMethod: pageCount
-     * Get the total count of pages given the current cache of features.
-     *
-     * Returns:
-     * {Integer} The page count.
-     */
-    pageCount: function() {
-        var numFeatures = this.features ? this.features.length : 0;
-        return Math.ceil(numFeatures / this.length);
-    },
-
-    /**
-     * APIMethod: pageNum
-     * Get the zero based page number.
-     *
-     * Returns:
-     * {Integer} The current page number being displayed.
-     */
-    pageNum: function() {
-        return this.num;
-    },
-
-    /**
-     * APIMethod: pageLength
-     * Gets or sets page length.
-     *
-     * Parameters:
-     * newLength: {Integer} Optional length to be set.
-     *
-     * Returns:
-     * {Integer} The length of a page (number of features per page).
-     */
-    pageLength: function(newLength) {
-        if(newLength && newLength > 0) {
-            this.length = newLength;
-        }
-        return this.length;
-    },
-
-    /**
-     * APIMethod: pageNext
-     * Display the next page of features.
-     *
-     * Returns:
-     * {Boolean} A new page was displayed.
-     */
-    pageNext: function(event) {
-        var changed = false;
-        if(this.features) {
-            if(this.num === null) {
-                this.num = -1;
-            }
-            var start = (this.num + 1) * this.length;
-            changed = this.page(start, event);
-        }
-        return changed;
-    },
-
-    /**
-     * APIMethod: pagePrevious
-     * Display the previous page of features.
-     *
-     * Returns:
-     * {Boolean} A new page was displayed.
-     */
-    pagePrevious: function() {
-        var changed = false;
-        if(this.features) {
-            if(this.num === null) {
-                this.num = this.pageCount();
-            }
-            var start = (this.num - 1) * this.length;
-            changed = this.page(start);
-        }
-        return changed;
-    },
-    
-    /**
-     * Method: page
-     * Display the page starting at the given index from the cache.
-     *
-     * Returns:
-     * {Boolean} A new page was displayed.
-     */
-    page: function(start, event) {
-        var changed = false;
-        if(this.features) {
-            if(start >= 0 && start < this.features.length) {
-                var num = Math.floor(start / this.length);
-                if(num != this.num) {
-                    this.paging = true;
-                    var features = this.features.slice(start, start + this.length);
-                    this.layer.removeFeatures(this.layer.features);
-                    this.num = num;
-                    // modify the event if any
-                    if(event && event.features) {
-                        // this.was called by an event listener
-                        event.features = features;
-                    } else {
-                        // this was called directly on the strategy
-                        this.layer.addFeatures(features);
-                    }
-                    this.paging = false;
-                    changed = true;
-                }
-            }
-        }
-        return changed;
-    },
-    
-    CLASS_NAME: "OpenLayers.Strategy.Paging" 
-});

data/lib/support/phpmyadmin/phpmyadmin/js/openlayers/src/openlayers/lib/OpenLayers/Strategy/Refresh.js

@@ -1,140 +0,0 @@
-/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for 
- * full list of contributors). Published under the Clear BSD license.  
- * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
- * full text of the license. */
-
-/**
- * @requires OpenLayers/Strategy.js
- */
-
-/**
- * Class: OpenLayers.Strategy.Refresh
- * A strategy that refreshes the layer. By default the strategy waits for a
- *     call to <refresh> before refreshing.  By configuring the strategy with 
- *     the <interval> option, refreshing can take place automatically.
- *
- * Inherits from:
- *  - <OpenLayers.Strategy>
- */
-OpenLayers.Strategy.Refresh = OpenLayers.Class(OpenLayers.Strategy, {
-    
-    /**
-     * Property: force
-     * {Boolean} Force a refresh on the layer. Default is false.
-     */
-    force: false,
-
-    /**
-     * Property: interval
-     * {Number} Auto-refresh. Default is 0.  If > 0, layer will be refreshed 
-     *     every N milliseconds.
-     */
-    interval: 0,
-    
-    /**
-     * Property: timer
-     * {Number} The id of the timer.
-     */
-    timer: null,
-
-    /**
-     * Constructor: OpenLayers.Strategy.Refresh
-     * Create a new Refresh strategy.
-     *
-     * Parameters:
-     * options - {Object} Optional object whose properties will be set on the
-     *     instance.
-     */
-    initialize: function(options) {
-        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
-    },
-   
-    /**
-     * APIMethod: activate
-     * Activate the strategy. Register any listeners, do appropriate setup.
-     * 
-     * Returns:
-     * {Boolean} True if the strategy was successfully activated.
-     */
-    activate: function() {
-        var activated = OpenLayers.Strategy.prototype.activate.call(this);
-        if(activated) {
-            if(this.layer.visibility === true) {
-                this.start();
-            } 
-            this.layer.events.on({
-                "visibilitychanged": this.reset,
-                scope: this
-            });
-        }
-        return activated;
-    },
-    
-    /**
-     * APIMethod: deactivate
-     * Deactivate the strategy. Unregister any listeners, do appropriate
-     *     tear-down.
-     * 
-     * Returns:
-     * {Boolean} True if the strategy was successfully deactivated.
-     */
-    deactivate: function() {
-        var deactivated = OpenLayers.Strategy.prototype.deactivate.call(this);
-        if(deactivated) {
-            this.stop();
-        }
-        return deactivated;
-    },
-    
-    /**
-     * Method: reset
-     * Start or cancel the refresh interval depending on the visibility of 
-     *     the layer.
-     */
-    reset: function() {
-        if(this.layer.visibility === true) {
-            this.start();
-        } else {
-            this.stop();
-        }
-    },
-    
-    /**
-     * Method: start
-     * Start the refresh interval. 
-     */
-    start: function() {
-        if(this.interval && typeof this.interval === "number" && 
-            this.interval > 0) {
-
-            this.timer = window.setInterval(
-                OpenLayers.Function.bind(this.refresh, this),
-                this.interval);
-        }
-    },
-    
-    /**
-     * APIMethod: refresh
-     * Tell the strategy to refresh which will refresh the layer.
-     */
-    refresh: function() {
-        if (this.layer && this.layer.refresh && 
-            typeof this.layer.refresh == "function") {
-
-            this.layer.refresh({force: this.force});
-        }
-    },
-   
-    /**
-     * Method: stop
-     * Cancels the refresh interval. 
-     */
-    stop: function() {
-        if(this.timer !== null) {
-            window.clearInterval(this.timer);
-            this.timer = null;
-        }
-    },
-    
-    CLASS_NAME: "OpenLayers.Strategy.Refresh" 
-});