extjs-rails 4.1.0.alpha5 → 4.1.0.alpha6

data/app/assets/javascripts/src/util/Floating.js

@@ -1,321 +0,0 @@
-/**
- * A mixin to add floating capability to a Component.
- */
-Ext.define('Ext.util.Floating', {
-
-    uses: ['Ext.Layer', 'Ext.window.Window'],
-
-    /**
-     * @cfg {Boolean} focusOnToFront
-     * Specifies whether the floated component should be automatically {@link Ext.Component#method-focus focused} when
-     * it is {@link #toFront brought to the front}.
-     */
-    focusOnToFront: true,
-
-    /**
-     * @cfg {String/Boolean} shadow
-     * Specifies whether the floating component should be given a shadow. Set to true to automatically create an
-     * {@link Ext.Shadow}, or a string indicating the shadow's display {@link Ext.Shadow#mode}. Set to false to
-     * disable the shadow.
-     */
-    shadow: 'sides',
-
-    /**
-     * @cfg {String/Boolean} shadowOffset
-     * Number of pixels to offset the shadow.
-     */
-
-    constructor: function (dom) {
-        var me = this;
-
-        me.el = new Ext.Layer(Ext.apply({
-            hideMode     : me.hideMode,
-            hidden       : me.hidden,
-            shadow       : (typeof me.shadow != 'undefined') ? me.shadow : 'sides',
-            shadowOffset : me.shadowOffset,
-            constrain    : false,
-            shim         : (me.shim === false) ? false : undefined
-        }, me.floating), dom);
-
-        // release config object (if it was one)
-        me.floating = true;
-        
-        // Register with the configured ownerCt.
-        // With this we acquire a floatParent for relative positioning, and a zIndexParent which is an
-        // ancestor floater which provides zIndex management.
-        me.registerWithOwnerCt();
-    },
-
-    registerWithOwnerCt: function() {
-        var me = this;
-
-        if (me.zIndexParent) {
-            me.zIndexParent.unregisterFloatingItem(me);
-        }
-
-        // Acquire a zIndexParent by traversing the ownerCt axis for the nearest floating ancestor
-        me.zIndexParent = me.up('[floating]');
-        me.setFloatParent(me.ownerCt);
-        delete me.ownerCt;
-
-        if (me.zIndexParent) {
-            me.zIndexParent.registerFloatingItem(me);
-        } else {
-            Ext.WindowManager.register(me);
-        }
-    },
-
-    setFloatParent: function(floatParent) {
-        var me = this;
-
-        // Remove listeners from previous floatParent
-        if (me.floatParent) {
-            me.mun(me.floatParent, {
-                hide: me.onFloatParentHide,
-                show: me.onFloatParentShow,
-                scope: me
-            });
-        }
-
-        me.floatParent = floatParent;
-
-        // Floating Components as children of Containers must hide when their parent hides.
-        if (floatParent) {
-            me.mon(me.floatParent, {
-                hide: me.onFloatParentHide,
-                show: me.onFloatParentShow,
-                scope: me
-            });
-        }
-
-        // If a floating Component is configured to be constrained, but has no configured
-        // constrainTo setting, set its constrainTo to be it's ownerCt before rendering.
-        if ((me.constrain || me.constrainHeader) && !me.constrainTo) {
-            me.constrainTo = floatParent ? floatParent.getTargetEl() : me.container;
-        }
-    },
-    
-    onAfterFloatLayout: function(){
-        this.syncShadow();   
-    },
-
-    onFloatParentHide: function() {
-        var me = this;
-
-        if (me.hideOnParentHide !== false && me.isVisible()) {
-            me.hide();
-            me.showOnParentShow = true;
-        }
-    },
-
-    onFloatParentShow: function() {
-        if (this.showOnParentShow) {
-            delete this.showOnParentShow;
-            this.show();
-        }
-    },
-
-    // private
-    // z-index is managed by the zIndexManager and may be overwritten at any time.
-    // Returns the next z-index to be used.
-    // If this is a Container, then it will have rebased any managed floating Components,
-    // and so the next available z-index will be approximately 10000 above that.
-    setZIndex: function(index) {
-        var me = this;
-
-        me.el.setZIndex(index);
-
-        // Next item goes 10 above;
-        index += 10;
-
-        // When a Container with floating items has its z-index set, it rebases any floating items it is managing.
-        // The returned value is a round number approximately 10000 above the last z-index used.
-        if (me.floatingItems) {
-            index = Math.floor(me.floatingItems.setBase(index) / 100) * 100 + 10000;
-        }
-        return index;
-    },
-
-    /**
-     * Moves this floating Component into a constrain region.
-     *
-     * By default, this Component is constrained to be within the container it was added to, or the element it was
-     * rendered to.
-     *
-     * An alternative constraint may be passed.
-     * @param {String/HTMLElement/Ext.Element/Ext.util.Region} [constrainTo] The Element or {@link Ext.util.Region Region}
-     * into which this Component is to be constrained. Defaults to the element into which this floating Component
-     * was rendered.
-     */
-    doConstrain: function(constrainTo) {
-        var me = this,
-
-            // Calculate the constrain vector to coerce our position to within our
-            // constrainTo setting. getConstrainVector will provide a default constraint
-            // region if there is no explicit constrainTo, *and* there is no floatParent owner Component.
-            vector = me.getConstrainVector(constrainTo),
-            xy;
-
-        if (vector) {
-            xy = me.getPosition();
-            xy[0] += vector[0];
-            xy[1] += vector[1];
-            me.setPosition(xy);
-        }
-    },
-
-
-    /**
-     * Gets the x/y offsets to constrain this float
-     * @private
-     * @param {String/HTMLElement/Ext.Element/Ext.util.Region} [constrainTo] The Element or {@link Ext.util.Region Region}
-     * into which this Component is to be constrained.
-     * @return {Number[]} The x/y constraints
-     */
-    getConstrainVector: function(constrainTo){
-        var me = this;
-
-        if (me.constrain || me.constrainHeader) {
-            constrainTo = constrainTo || (me.floatParent && me.floatParent.getTargetEl()) || me.container || me.el.getScopeParent();
-            return (me.constrainHeader ? me.header.el : me.el).getConstrainVector(constrainTo);
-        }
-    },
-
-    /**
-     * Aligns this floating Component to the specified element
-     *
-     * @param {Ext.Component/Ext.Element/HTMLElement/String} element
-     * The element or {@link Ext.Component} to align to. If passing a component, it must be a
-     * component instance. If a string id is passed, it will be used as an element id.
-     * @param {String} [position="tl-bl?"] The position to align to
-     * (see {@link Ext.Element#alignTo} for more details).
-     * @param {Number[]} [offsets] Offset the positioning by [x, y]
-     * @return {Ext.Component} this
-     */
-    alignTo: function(element, position, offsets) {
-
-        // element may be a Component, so first attempt to use its el to align to.
-        // When aligning to an Element's X,Y position, we must use setPagePosition which disregards any floatParent
-        this.setPagePosition(this.el.getAlignToXY(element.el || element, position, offsets));
-        return this;
-    },
-
-    /**
-     * Brings this floating Component to the front of any other visible, floating Components managed by the same
-     * {@link Ext.ZIndexManager ZIndexManager}
-     *
-     * If this Component is modal, inserts the modal mask just below this Component in the z-index stack.
-     *
-     * @param {Boolean} [preventFocus=false] Specify `true` to prevent the Component from being focused.
-     * @return {Ext.Component} this
-     */
-    toFront: function(preventFocus) {
-        var me = this;
-
-        // Find the floating Component which provides the base for this Component's zIndexing.
-        // That must move to front to then be able to rebase its zIndex stack and move this to the front
-        if (me.zIndexParent && me.bringParentToFront !== false) {
-            me.zIndexParent.toFront(true);
-        }
-        
-        if (!Ext.isDefined(preventFocus)) {
-            preventFocus = !me.focusOnToFront;
-        }
-        
-        if (preventFocus) {
-            me.preventFocusOnActivate = true;
-        }
-        if (me.zIndexManager.bringToFront(me)) {    
-            if (!preventFocus) {
-                // Kick off a delayed focus request.
-                // If another floating Component is toFronted before the delay expires
-                // this will not receive focus.
-                me.focus(false, true);
-            }
-        }
-        delete me.preventFocusOnActivate;
-        return me;
-    },
-
-    /**
-     * This method is called internally by {@link Ext.ZIndexManager} to signal that a floating Component has either been
-     * moved to the top of its zIndex stack, or pushed from the top of its zIndex stack.
-     *
-     * If a _Window_ is superceded by another Window, deactivating it hides its shadow.
-     *
-     * This method also fires the {@link Ext.Component#activate activate} or
-     * {@link Ext.Component#deactivate deactivate} event depending on which action occurred.
-     *
-     * @param {Boolean} [active=false] True to activate the Component, false to deactivate it.
-     * @param {Ext.Component} [newActive] The newly active Component which is taking over topmost zIndex position.
-     */
-    setActive: function(active, newActive) {
-        var me = this;
-        
-        if (active) {
-            if (me.el.shadow && !me.maximized) {
-                me.el.enableShadow(true);
-            }
-            if (me.modal && !me.preventFocusOnActivate) {
-                me.focus(false, true);
-            }
-            me.fireEvent('activate', me);
-        } else {
-            // Only the *Windows* in a zIndex stack share a shadow. All other types of floaters
-            // can keep their shadows all the time
-            if (me.isWindow && (newActive && newActive.isWindow)) {
-                me.el.disableShadow();
-            }
-            me.fireEvent('deactivate', me);
-        }
-    },
-
-    /**
-     * Sends this Component to the back of (lower z-index than) any other visible windows
-     * @return {Ext.Component} this
-     */
-    toBack: function() {
-        this.zIndexManager.sendToBack(this);
-        return this;
-    },
-
-    /**
-     * Center this Component in its container.
-     * @return {Ext.Component} this
-     */
-    center: function() {
-        var me = this,
-            xy;
-            
-        if (me.isVisible()) {
-            xy = me.el.getAlignToXY(me.container, 'c-c');
-            me.setPagePosition(xy);
-        } else {
-            me.needsCenter = true;
-        }
-        return me;
-    },
-    
-    onFloatShow: function(){
-        if (this.needsCenter) {
-            this.center();    
-        }
-        delete this.needsCenter;
-    },
-
-    // private
-    syncShadow : function(){
-        if (this.floating) {
-            this.el.sync(true);
-        }
-    },
-
-    // private
-    fitContainer: function() {
-        var parent = this.floatParent,
-            container = parent ? parent.getTargetEl() : this.container,
-            size = container.getViewSize(false);
-
-        this.setSize(size);
-    }
-});

data/app/assets/javascripts/src/util/Grouper.js

@@ -1,26 +0,0 @@
-/**
- * @class Ext.util.Grouper
-
-Represents a single grouper that can be applied to a Store. The grouper works
-in the same fashion as the {@link Ext.util.Sorter}.
-
- * @markdown
- */
- 
-Ext.define('Ext.util.Grouper', {
-
-    /* Begin Definitions */
-
-    extend: 'Ext.util.Sorter',
-
-    /* End Definitions */
-
-    /**
-     * Returns the value for grouping to be used.
-     * @param {Ext.data.Model} instance The Model instance
-     * @return {String} The group string for this model
-     */
-    getGroupString: function(instance) {
-        return instance.get(this.property);
-    }
-});

data/app/assets/javascripts/src/util/HashMap.js

@@ -1,356 +0,0 @@
-/**
- * @class Ext.util.HashMap
- * <p>
- * Represents a collection of a set of key and value pairs. Each key in the HashMap
- * must be unique, the same key cannot exist twice. Access to items is provided via
- * the key only. Sample usage:
- * <pre><code>
-var map = new Ext.util.HashMap();
-map.add('key1', 1);
-map.add('key2', 2);
-map.add('key3', 3);
-
-map.each(function(key, value, length){
-    console.log(key, value, length);
-});
- * </code></pre>
- * </p>
- *
- * <p>The HashMap is an unordered class,
- * there is no guarantee when iterating over the items that they will be in any particular
- * order. If this is required, then use a {@link Ext.util.MixedCollection}.
- * </p>
- */
-Ext.define('Ext.util.HashMap', {
-    mixins: {
-        observable: 'Ext.util.Observable'
-    },
-
-    /**
-     * @cfg {Function} keyFn A function that is used to retrieve a default key for a passed object.
-     * A default is provided that returns the <b>id</b> property on the object. This function is only used
-     * if the add method is called with a single argument.
-     */
-
-    /**
-     * Creates new HashMap.
-     * @param {Object} config (optional) Config object.
-     */
-    constructor: function(config) {
-        config = config || {};
-
-        var me = this,
-            keyFn = config.keyFn;
-
-        me.addEvents(
-            /**
-             * @event add
-             * Fires when a new item is added to the hash
-             * @param {Ext.util.HashMap} this.
-             * @param {String} key The key of the added item.
-             * @param {Object} value The value of the added item.
-             */
-            'add',
-            /**
-             * @event clear
-             * Fires when the hash is cleared.
-             * @param {Ext.util.HashMap} this.
-             */
-            'clear',
-            /**
-             * @event remove
-             * Fires when an item is removed from the hash.
-             * @param {Ext.util.HashMap} this.
-             * @param {String} key The key of the removed item.
-             * @param {Object} value The value of the removed item.
-             */
-            'remove',
-            /**
-             * @event replace
-             * Fires when an item is replaced in the hash.
-             * @param {Ext.util.HashMap} this.
-             * @param {String} key The key of the replaced item.
-             * @param {Object} value The new value for the item.
-             * @param {Object} old The old value for the item.
-             */
-            'replace'
-        );
-
-        me.mixins.observable.constructor.call(me, config);
-        me.clear(true);
-
-        if (keyFn) {
-            me.getKey = keyFn;
-        }
-    },
-
-    /**
-     * Gets the number of items in the hash.
-     * @return {Number} The number of items in the hash.
-     */
-    getCount: function() {
-        return this.length;
-    },
-
-    /**
-     * Implementation for being able to extract the key from an object if only
-     * a single argument is passed.
-     * @private
-     * @param {String} key The key
-     * @param {Object} value The value
-     * @return {Array} [key, value]
-     */
-    getData: function(key, value) {
-        // if we have no value, it means we need to get the key from the object
-        if (value === undefined) {
-            value = key;
-            key = this.getKey(value);
-        }
-
-        return [key, value];
-    },
-
-    /**
-     * Extracts the key from an object. This is a default implementation, it may be overridden
-     * @param {Object} o The object to get the key from
-     * @return {String} The key to use.
-     */
-    getKey: function(o) {
-        return o.id;
-    },
-
-    /**
-     * Adds an item to the collection. Fires the {@link #event-add} event when complete.
-     * @param {String} key <p>The key to associate with the item, or the new item.</p>
-     * <p>If a {@link #getKey} implementation was specified for this HashMap,
-     * or if the key of the stored items is in a property called <tt><b>id</b></tt>,
-     * the HashMap will be able to <i>derive</i> the key for the new item.
-     * In this case just pass the new item in this parameter.</p>
-     * @param {Object} o The item to add.
-     * @return {Object} The item added.
-     */
-    add: function(key, value) {
-        var me = this;
-
-        if (value === undefined) {
-            value = key;
-            key = me.getKey(value);
-        }
-
-        if (me.containsKey(key)) {
-            return me.replace(key, value);
-        }
-
-        me.map[key] = value;
-        ++me.length;
-        if (me.hasListeners.add) {
-            me.fireEvent('add', me, key, value);
-        }
-        return value;
-    },
-
-    /**
-     * Replaces an item in the hash. If the key doesn't exist, the
-     * {@link #method-add} method will be used.
-     * @param {String} key The key of the item.
-     * @param {Object} value The new value for the item.
-     * @return {Object} The new value of the item.
-     */
-    replace: function(key, value) {
-        var me = this,
-            map = me.map,
-            old;
-
-        if (value === undefined) {
-            value = key;
-            key = me.getKey(value);
-        }
-
-        if (!me.containsKey(key)) {
-            me.add(key, value);
-        }
-        old = map[key];
-        map[key] = value;
-        if (me.hasListeners.replace) {
-            me.fireEvent('replace', me, key, value, old);
-        }
-        return value;
-    },
-
-    /**
-     * Remove an item from the hash.
-     * @param {Object} o The value of the item to remove.
-     * @return {Boolean} True if the item was successfully removed.
-     */
-    remove: function(o) {
-        var key = this.findKey(o);
-        if (key !== undefined) {
-            return this.removeAtKey(key);
-        }
-        return false;
-    },
-
-    /**
-     * Remove an item from the hash.
-     * @param {String} key The key to remove.
-     * @return {Boolean} True if the item was successfully removed.
-     */
-    removeAtKey: function(key) {
-        var me = this,
-            value;
-
-        if (me.containsKey(key)) {
-            value = me.map[key];
-            delete me.map[key];
-            --me.length;
-            if (me.hasListeners.remove) {
-                me.fireEvent('remove', me, key, value);
-            }
-            return true;
-        }
-        return false;
-    },
-
-    /**
-     * Retrieves an item with a particular key.
-     * @param {String} key The key to lookup.
-     * @return {Object} The value at that key. If it doesn't exist, <tt>undefined</tt> is returned.
-     */
-    get: function(key) {
-        return this.map[key];
-    },
-
-    /**
-     * Removes all items from the hash.
-     * @return {Ext.util.HashMap} this
-     */
-    clear: function(/* private */ initial) {
-        var me = this;
-        me.map = {};
-        me.length = 0;
-        if (initial !== true && me.hasListeners.clear) {
-            me.fireEvent('clear', me);
-        }
-        return me;
-    },
-
-    /**
-     * Checks whether a key exists in the hash.
-     * @param {String} key The key to check for.
-     * @return {Boolean} True if they key exists in the hash.
-     */
-    containsKey: function(key) {
-        return this.map[key] !== undefined;
-    },
-
-    /**
-     * Checks whether a value exists in the hash.
-     * @param {Object} value The value to check for.
-     * @return {Boolean} True if the value exists in the dictionary.
-     */
-    contains: function(value) {
-        return this.containsKey(this.findKey(value));
-    },
-
-    /**
-     * Return all of the keys in the hash.
-     * @return {Array} An array of keys.
-     */
-    getKeys: function() {
-        return this.getArray(true);
-    },
-
-    /**
-     * Return all of the values in the hash.
-     * @return {Array} An array of values.
-     */
-    getValues: function() {
-        return this.getArray(false);
-    },
-
-    /**
-     * Gets either the keys/values in an array from the hash.
-     * @private
-     * @param {Boolean} isKey True to extract the keys, otherwise, the value
-     * @return {Array} An array of either keys/values from the hash.
-     */
-    getArray: function(isKey) {
-        var arr = [],
-            key,
-            map = this.map;
-        for (key in map) {
-            if (map.hasOwnProperty(key)) {
-                arr.push(isKey ? key: map[key]);
-            }
-        }
-        return arr;
-    },
-
-    /**
-     * Executes the specified function once for each item in the hash.
-     * Returning false from the function will cease iteration.
-     *
-     * The paramaters passed to the function are:
-     * <div class="mdetail-params"><ul>
-     * <li><b>key</b> : String<p class="sub-desc">The key of the item</p></li>
-     * <li><b>value</b> : Number<p class="sub-desc">The value of the item</p></li>
-     * <li><b>length</b> : Number<p class="sub-desc">The total number of items in the hash</p></li>
-     * </ul></div>
-     * @param {Function} fn The function to execute.
-     * @param {Object} scope The scope to execute in. Defaults to <tt>this</tt>.
-     * @return {Ext.util.HashMap} this
-     */
-    each: function(fn, scope) {
-        // copy items so they may be removed during iteration.
-        var items = Ext.apply({}, this.map),
-            key,
-            length = this.length;
-
-        scope = scope || this;
-        for (key in items) {
-            if (items.hasOwnProperty(key)) {
-                if (fn.call(scope, key, items[key], length) === false) {
-                    break;
-                }
-            }
-        }
-        return this;
-    },
-
-    /**
-     * Performs a shallow copy on this hash.
-     * @return {Ext.util.HashMap} The new hash object.
-     */
-    clone: function() {
-        var hash = new this.self(),
-            map = this.map,
-            key;
-
-        hash.suspendEvents();
-        for (key in map) {
-            if (map.hasOwnProperty(key)) {
-                hash.add(key, map[key]);
-            }
-        }
-        hash.resumeEvents();
-        return hash;
-    },
-
-    /**
-     * @private
-     * Find the key for a value.
-     * @param {Object} value The value to find.
-     * @return {Object} The value of the item. Returns <tt>undefined</tt> if not found.
-     */
-    findKey: function(value) {
-        var key,
-            map = this.map;
-
-        for (key in map) {
-            if (map.hasOwnProperty(key) && map[key] === value) {
-                return key;
-            }
-        }
-        return undefined;
-    }
-});