extjs-rails 4.1.0.alpha5 → 4.1.0.alpha6

data/app/assets/javascripts/src/PluginManager.js

@@ -1,110 +0,0 @@
-/**
- * @singleton
- *
- * Provides a registry of available Plugin classes indexed by a mnemonic code known as the Plugin's ptype.
- *
- * A plugin may be specified simply as a *config object* as long as the correct `ptype` is specified:
- *
- *     {
- *         ptype: 'gridviewdragdrop',
- *         dragText: 'Drag and drop to reorganize'
- *     }
- *
- * Or just use the ptype on its own:
- *
- *     'gridviewdragdrop'
- *
- * Alternatively you can instantiate the plugin with Ext.create:
- *
- *     Ext.create('Ext.view.plugin.AutoComplete', {
- *         ptype: 'gridviewdragdrop',
- *         dragText: 'Drag and drop to reorganize'
- *     })
- */
-Ext.define('Ext.PluginManager', {
-    extend: 'Ext.AbstractManager',
-    alternateClassName: 'Ext.PluginMgr',
-    singleton: true,
-    typeName: 'ptype',
-
-    /**
-     * Creates a new Plugin from the specified config object using the config object's ptype to determine the class to
-     * instantiate.
-     * @param {Object} config A configuration object for the Plugin you wish to create.
-     * @param {Function} defaultType (optional) The constructor to provide the default Plugin type if the config object does not
-     * contain a `ptype`. (Optional if the config contains a `ptype`).
-     * @return {Ext.Component} The newly instantiated Plugin.
-     */
-    create : function(config, defaultType){
-        if (config.init) {
-            return config;
-        } else {
-            return Ext.createByAlias('plugin.' + (config.ptype || defaultType), config);
-        }
-
-        // Prior system supported Singleton plugins.
-        //var PluginCls = this.types[config.ptype || defaultType];
-        //if (PluginCls.init) {
-        //    return PluginCls;
-        //} else {
-        //    return new PluginCls(config);
-        //}
-    },
-
-    //create: function(plugin, defaultType) {
-    //    if (plugin instanceof this) {
-    //        return plugin;
-    //    } else {
-    //        var type, config = {};
-    //
-    //        if (Ext.isString(plugin)) {
-    //            type = plugin;
-    //        }
-    //        else {
-    //            type = plugin[this.typeName] || defaultType;
-    //            config = plugin;
-    //        }
-    //
-    //        return Ext.createByAlias('plugin.' + type, config);
-    //    }
-    //},
-
-    /**
-     * Returns all plugins registered with the given type. Here, 'type' refers to the type of plugin, not its ptype.
-     * @param {String} type The type to search for
-     * @param {Boolean} defaultsOnly True to only return plugins of this type where the plugin's isDefault property is
-     * truthy
-     * @return {Ext.AbstractPlugin[]} All matching plugins
-     */
-    findByType: function(type, defaultsOnly) {
-        var matches = [],
-            types   = this.types,
-            name,
-            item;
-
-        for (name in types) {
-            if (!types.hasOwnProperty(name)) {
-                continue;
-            }
-            item = types[name];
-
-            if (item.type == type && (!defaultsOnly || (defaultsOnly === true && item.isDefault))) {
-                matches.push(item);
-            }
-        }
-
-        return matches;
-    }
-}, function() {
-    /**
-     * Shorthand for {@link Ext.PluginManager#registerType}
-     * @param {String} ptype The ptype mnemonic string by which the Plugin class
-     * may be looked up.
-     * @param {Function} cls The new Plugin class.
-     * @member Ext
-     * @method preg
-     */
-    Ext.preg = function() {
-        return Ext.PluginManager.registerType.apply(Ext.PluginManager, arguments);
-    };
-});

data/app/assets/javascripts/src/ProgressBar.js

@@ -1,336 +0,0 @@
-/**
- * An updateable progress bar component. The progress bar supports two different modes: manual and automatic.
- *
- * In manual mode, you are responsible for showing, updating (via {@link #updateProgress}) and clearing the progress bar
- * as needed from your own code. This method is most appropriate when you want to show progress throughout an operation
- * that has predictable points of interest at which you can update the control.
- *
- * In automatic mode, you simply call {@link #wait} and let the progress bar run indefinitely, only clearing it once the
- * operation is complete. You can optionally have the progress bar wait for a specific amount of time and then clear
- * itself. Automatic mode is most appropriate for timed operations or asynchronous operations in which you have no need
- * for indicating intermediate progress.
- *
- *     @example
- *     var p = Ext.create('Ext.ProgressBar', {
- *        renderTo: Ext.getBody(),
- *        width: 300
- *     });
- *
- *     // Wait for 5 seconds, then update the status el (progress bar will auto-reset)
- *     p.wait({
- *         interval: 500, //bar will move fast!
- *         duration: 50000,
- *         increment: 15,
- *         text: 'Updating...',
- *         scope: this,
- *         fn: function(){
- *             p.updateText('Done!');
- *         }
- *     });
- */
-Ext.define('Ext.ProgressBar', {
-    extend: 'Ext.Component',
-    alias: 'widget.progressbar',
-
-    requires: [
-        'Ext.Template',
-        'Ext.CompositeElement',
-        'Ext.TaskManager',
-        'Ext.layout.component.ProgressBar'
-    ],
-
-    uses: ['Ext.fx.Anim'],
-
-   /**
-    * @cfg {Number} [value=0]
-    * A floating point value between 0 and 1 (e.g., .5)
-    */
-
-   /**
-    * @cfg {String/HTMLElement/Ext.Element} textEl
-    * The element to render the progress text to (defaults to the progress bar's internal text element)
-    */
-
-   /**
-    * @cfg {String} id
-    * The progress bar element's id (defaults to an auto-generated id)
-    */
-
-   /**
-    * @cfg {String} [baseCls='x-progress']
-    * The base CSS class to apply to the progress bar's wrapper element.
-    */
-    baseCls: Ext.baseCSSPrefix + 'progress',
-
-    /**
-     * @cfg {Boolean} animate
-     * True to animate the progress bar during transitions.
-     */
-    animate: false,
-
-    /**
-     * @cfg {String} text
-     * The text shown in the progress bar.
-     */
-    text: '',
-
-    // private
-    waitTimer: null,
-
-    childEls: [
-        'bar'
-    ],
-
-    renderTpl: [
-        '<tpl if="internalText">',
-            '<div class="{baseCls}-text {baseCls}-text-back">{text}</div>',
-        '</tpl>',
-        '<div id="{id}-bar" class="{baseCls}-bar" style="width:{percentage}%">',
-            '<tpl if="internalText">',
-                '<div class="{baseCls}-text">',
-                    '<div>{text}</div>',
-                '</div>',
-            '</tpl>',
-        '</div>'
-    ],
-
-    componentLayout: 'progressbar',
-
-    // private
-    initComponent: function() {
-        this.callParent();
-
-        this.addEvents(
-            /**
-             * @event update
-             * Fires after each update interval
-             * @param {Ext.ProgressBar} this
-             * @param {Number} value The current progress value
-             * @param {String} text The current progress text
-             */
-            "update"
-        );
-    },
-
-    initRenderData: function() {
-        var me = this;
-        return Ext.apply(me.callParent(), {
-            internalText : !me.hasOwnProperty('textEl'),
-            text         : me.text || '&#160;',
-            percentage   : me.value ? me.value * 100 : 0
-        });
-    },
-
-    onRender : function() {
-        var me = this;
-
-        me.callParent(arguments);
-
-        // External text display
-        if (me.textEl) {
-            me.textEl = Ext.get(me.textEl);
-            me.updateText(me.text);
-        }
-        // Inline text display
-        else {
-            // This produces a composite w/2 el's (which is why we cannot use childEls or
-            // renderSelectors):
-            me.textEl = me.el.select('.' + me.baseCls + '-text');
-        }
-    },
-
-    /**
-     * Updates the progress bar value, and optionally its text. If the text argument is not specified, any existing text
-     * value will be unchanged. To blank out existing text, pass ''. Note that even if the progress bar value exceeds 1,
-     * it will never automatically reset -- you are responsible for determining when the progress is complete and
-     * calling {@link #reset} to clear and/or hide the control.
-     * @param {Number} [value=0] A floating point value between 0 and 1 (e.g., .5)
-     * @param {String} [text=''] The string to display in the progress text element
-     * @param {Boolean} [animate=false] Whether to animate the transition of the progress bar. If this value is not
-     * specified, the default for the class is used
-     * @return {Ext.ProgressBar} this
-     */
-    updateProgress: function(value, text, animate) {
-        var me = this,
-            oldValue = me.value;
-
-        me.value = value || 0;
-        if (text) {
-            me.updateText(text);
-        }
-        if (me.rendered && !me.isDestroyed) {
-            if (animate === true || (animate !== false && me.animate)) {
-                me.bar.stopAnimation();
-                me.bar.animate(Ext.apply({
-                    from: {
-                        width: (oldValue * 100) + '%'
-                    },
-                    to: {
-                        width: (me.value * 100) + '%'
-                    }
-                }, me.animate));
-            } else {
-                me.bar.setStyle('width', (me.value * 100) + '%');
-            }
-        }
-        me.fireEvent('update', me, me.value, text);
-        return me;
-    },
-
-    /**
-     * Updates the progress bar text. If specified, textEl will be updated, otherwise the progress bar itself will
-     * display the updated text.
-     * @param {String} [text=''] The string to display in the progress text element
-     * @return {Ext.ProgressBar} this
-     */
-    updateText: function(text) {
-        var me = this;
-        
-        me.text = text;
-        if (me.rendered) {
-            me.textEl.update(me.text);
-        }
-        return me;
-    },
-
-    applyText : function(text) {
-        this.updateText(text);
-    },
-    
-    getText: function(){
-        return this.text;    
-    },
-
-    /**
-     * Initiates an auto-updating progress bar. A duration can be specified, in which case the progress bar will
-     * automatically reset after a fixed amount of time and optionally call a callback function if specified. If no
-     * duration is passed in, then the progress bar will run indefinitely and must be manually cleared by calling
-     * {@link #reset}.
-     *
-     * Example usage:
-     *
-     *     var p = new Ext.ProgressBar({
-     *        renderTo: 'my-el'
-     *     });
-     *
-     *     //Wait for 5 seconds, then update the status el (progress bar will auto-reset)
-     *     var p = Ext.create('Ext.ProgressBar', {
-     *        renderTo: Ext.getBody(),
-     *        width: 300
-     *     });
-     *
-     *     //Wait for 5 seconds, then update the status el (progress bar will auto-reset)
-     *     p.wait({
-     *        interval: 500, //bar will move fast!
-     *        duration: 50000,
-     *        increment: 15,
-     *        text: 'Updating...',
-     *        scope: this,
-     *        fn: function(){
-     *           p.updateText('Done!');
-     *        }
-     *     });
-     *
-     *     //Or update indefinitely until some async action completes, then reset manually
-     *     p.wait();
-     *     myAction.on('complete', function(){
-     *         p.reset();
-     *         p.updateText('Done!');
-     *     });
-     *
-     * @param {Object} config (optional) Configuration options
-     * @param {Number} config.duration The length of time in milliseconds that the progress bar should
-     * run before resetting itself (defaults to undefined, in which case it will run indefinitely
-     * until reset is called)
-     * @param {Number} config.interval The length of time in milliseconds between each progress update
-     * (defaults to 1000 ms)
-     * @param {Boolean} config.animate Whether to animate the transition of the progress bar. If this
-     * value is not specified, the default for the class is used.
-     * @param {Number} config.increment The number of progress update segments to display within the
-     * progress bar (defaults to 10).  If the bar reaches the end and is still updating, it will
-     * automatically wrap back to the beginning.
-     * @param {String} config.text Optional text to display in the progress bar element (defaults to '').
-     * @param {Function} config.fn A callback function to execute after the progress bar finishes auto-
-     * updating.  The function will be called with no arguments.  This function will be ignored if
-     * duration is not specified since in that case the progress bar can only be stopped programmatically,
-     * so any required function should be called by the same code after it resets the progress bar.
-     * @param {Object} config.scope The scope that is passed to the callback function (only applies when
-     * duration and fn are both passed).
-     * @return {Ext.ProgressBar} this
-     */
-    wait: function(o) {
-        var me = this, scope;
-            
-        if (!me.waitTimer) {
-            scope = me;
-            o = o || {};
-            me.updateText(o.text);
-            me.waitTimer = Ext.TaskManager.start({
-                run: function(i){
-                    var inc = o.increment || 10;
-                    i -= 1;
-                    me.updateProgress(((((i+inc)%inc)+1)*(100/inc))*0.01, null, o.animate);
-                },
-                interval: o.interval || 1000,
-                duration: o.duration,
-                onStop: function(){
-                    if (o.fn) {
-                        o.fn.apply(o.scope || me);
-                    }
-                    me.reset();
-                },
-                scope: scope
-            });
-        }
-        return me;
-    },
-
-    /**
-     * Returns true if the progress bar is currently in a {@link #wait} operation
-     * @return {Boolean} True if waiting, else false
-     */
-    isWaiting: function(){
-        return this.waitTimer !== null;
-    },
-
-    /**
-     * Resets the progress bar value to 0 and text to empty string. If hide = true, the progress bar will also be hidden
-     * (using the {@link #hideMode} property internally).
-     * @param {Boolean} [hide=false] True to hide the progress bar.
-     * @return {Ext.ProgressBar} this
-     */
-    reset: function(hide){
-        var me = this;
-        
-        me.updateProgress(0);
-        me.clearTimer();
-        if (hide === true) {
-            me.hide();
-        }
-        return me;
-    },
-
-    // private
-    clearTimer: function(){
-        var me = this;
-        
-        if (me.waitTimer) {
-            me.waitTimer.onStop = null; //prevent recursion
-            Ext.TaskManager.stop(me.waitTimer);
-            me.waitTimer = null;
-        }
-    },
-
-    onDestroy: function(){
-        var me = this;
-        
-        me.clearTimer();
-        if (me.rendered) {
-            if (me.textEl.isComposite) {
-                me.textEl.clear();
-            }
-            Ext.destroyMembers(me, 'textEl', 'progressBar');
-        }
-        me.callParent();
-    }
-});

data/app/assets/javascripts/src/Shadow.js

@@ -1,233 +0,0 @@
-/**
- * Simple class that can provide a shadow effect for any element.  Note that the element
- * MUST be absolutely positioned, and the shadow does not provide any shimming.  This
- * should be used only in simple cases - for more advanced functionality that can also
- * provide the same shadow effect, see the {@link Ext.Layer} class.
- */
-Ext.define('Ext.Shadow', {
-    requires: ['Ext.ShadowPool'],
-
-    /**
-     * Creates new Shadow.
-     * @param {Object} config (optional) Config object.
-     */
-    constructor: function(config) {
-        var me = this,
-            adjusts,
-            offset,
-            rad;
-        
-        Ext.apply(me, config);
-        if (!Ext.isString(me.mode)) {
-            me.mode = me.defaultMode;
-        }
-        offset = me.offset;
-        rad = Math.floor(offset / 2);
-        me.opacity = 50;
-        switch (me.mode.toLowerCase()) {
-            // all this hideous nonsense calculates the various offsets for shadows
-            case "drop":
-                if (Ext.supports.CSS3BoxShadow) {
-                    adjusts = {
-                        t: offset,
-                        l: offset,
-                        h: -offset,
-                        w: -offset
-                    };
-                }
-                else {
-                    adjusts = {
-                        t: -rad,
-                        l: -rad,
-                        h: -rad,
-                        w: -rad
-                    };
-                }
-                break;
-            case "sides":
-                if (Ext.supports.CSS3BoxShadow) {
-                    adjusts = {
-                        t: offset,
-                        l: 0,
-                        h: -offset,
-                        w: 0
-                    };
-                }
-                else {
-                    adjusts = {
-                        t: - (1 + rad),
-                        l: 1 + rad - 2 * offset,
-                        h: -1,
-                        w: rad - 1
-                    };
-                }
-                break;
-            case "frame":
-                if (Ext.supports.CSS3BoxShadow) {
-                    adjusts = {
-                        t: 0,
-                        l: 0,
-                        h: 0,
-                        w: 0
-                    };
-                }
-                else {
-                    adjusts = {
-                        t: 1 + rad - 2 * offset,
-                        l: 1 + rad - 2 * offset,
-                        h: offset - rad - 1,
-                        w: offset - rad - 1
-                    };
-                }
-                break;
-        }
-        me.adjusts = adjusts;
-    },
-
-    /**
-     * @cfg {String} mode
-     * The shadow display mode.  Supports the following options:
-     *
-     * - sides : Shadow displays on both sides and bottom only</li>
-     * - frame : Shadow displays equally on all four sides</li>
-     * - drop : Traditional bottom-right drop shadow</li>
-     */
-
-    /**
-     * @cfg {Number} offset
-     * The number of pixels to offset the shadow from the element
-     */
-    offset: 4,
-
-    // private
-    defaultMode: "drop",
-
-    // private - CSS property to use to set the box shadow
-    boxShadowProperty: (function() {
-        var property = 'boxShadow',
-            style = document.documentElement.style;
-
-        if (!('boxShadow' in style)) {
-            if ('WebkitBoxShadow' in style) {
-                // Safari prior to version 5.1 and Chrome prior to version 10
-                property = 'WebkitBoxShadow';
-            }
-            else if ('MozBoxShadow' in style) {
-                // FF 3.5 & 3.6
-                property = 'MozBoxShadow';
-            }
-        }
-
-        return property;
-    }()),
-
-    /**
-     * Displays the shadow under the target element
-     * @param {String/HTMLElement/Ext.Element} targetEl The id or element under which the shadow should display
-     */
-    show: function(target) {
-        var me = this,
-            index;
-        
-        target = Ext.get(target);
-        if (!me.el) {
-            me.el = Ext.ShadowPool.pull();
-            if (me.el.dom.nextSibling != target.dom) {
-                me.el.insertBefore(target);
-            }
-        }
-        index = (parseInt(target.getStyle("z-index"), 10) - 1) || 0;
-        me.el.setStyle("z-index", me.zIndex || index);
-        if (Ext.isIE && !Ext.supports.CSS3BoxShadow) {
-            me.el.dom.style.filter = "progid:DXImageTransform.Microsoft.alpha(opacity=" + me.opacity + ") progid:DXImageTransform.Microsoft.Blur(pixelradius=" + (me.offset) + ")";
-        }
-        me.realign(
-            target.getLeft(true),
-            target.getTop(true),
-            target.dom.offsetWidth,
-            target.dom.offsetHeight
-        );
-        me.el.dom.style.display = "block";
-    },
-
-    /**
-     * Returns true if the shadow is visible, else false
-     */
-    isVisible: function() {
-        return this.el ? true: false;
-    },
-
-    /**
-     * Direct alignment when values are already available. Show must be called at least once before
-     * calling this method to ensure it is initialized.
-     * @param {Number} left The target element left position
-     * @param {Number} top The target element top position
-     * @param {Number} width The target element width
-     * @param {Number} height The target element height
-     */
-    realign: function(l, t, targetWidth, targetHeight) {
-        if (!this.el) {
-            return;
-        }
-        var adjusts = this.adjusts,
-            d = this.el.dom,
-            targetStyle = d.style,
-            shadowWidth,
-            shadowHeight,
-            sws,
-            shs;
-
-        targetStyle.left = (l + adjusts.l) + "px";
-        targetStyle.top = (t + adjusts.t) + "px";
-        shadowWidth = Math.max(targetWidth + adjusts.w, 0);
-        shadowHeight = Math.max(targetHeight + adjusts.h, 0);
-        sws = shadowWidth + "px";
-        shs = shadowHeight + "px";
-        if (targetStyle.width != sws || targetStyle.height != shs) {
-            targetStyle.width = sws;
-            targetStyle.height = shs;
-
-            if (Ext.supports.CSS3BoxShadow) {
-                targetStyle[this.boxShadowProperty] = '0 0 ' + this.offset + 'px #888';
-            }
-        }
-    },
-
-    /**
-     * Hides this shadow
-     */
-    hide: function() {
-        var me = this;
-        
-        if (me.el) {
-            me.el.dom.style.display = "none";
-            Ext.ShadowPool.push(me.el);
-            delete me.el;
-        }
-    },
-
-    /**
-     * Adjust the z-index of this shadow
-     * @param {Number} zindex The new z-index
-     */
-    setZIndex: function(z) {
-        this.zIndex = z;
-        if (this.el) {
-            this.el.setStyle("z-index", z);
-        }
-    },
-    
-    /**
-     * Sets the opacity of the shadow
-     * @param {Number} opacity The opacity
-     */
-    setOpacity: function(opacity){
-        if (this.el) {
-            if (Ext.isIE && !Ext.supports.CSS3BoxShadow) {
-                opacity = Math.floor(opacity * 100 / 2) / 100;
-            }
-            this.opacity = opacity;
-            this.el.setOpacity(opacity);
-        }
-    }
-});