extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/toolbar/Separator.js

@@ -0,0 +1,23 @@
+/**
+ * A simple class that adds a vertical separator bar between toolbar items (css class: 'x-toolbar-separator').
+ *
+ *     @example
+ *     Ext.create('Ext.panel.Panel', {
+ *         title: 'Toolbar Separator Example',
+ *         width: 300,
+ *         height: 200,
+ *         tbar : [
+ *             'Item 1',
+ *             { xtype: 'tbseparator' },
+ *             'Item 2'
+ *         ],
+ *         renderTo: Ext.getBody()
+ *     });
+ */
+Ext.define('Ext.toolbar.Separator', {
+    extend: 'Ext.toolbar.Item',
+    alias: 'widget.tbseparator',
+    alternateClassName: 'Ext.Toolbar.Separator',
+    baseCls: Ext.baseCSSPrefix + 'toolbar-separator',
+    focusable: false
+});

data/app/assets/javascripts/extjs-rails/src/toolbar/Spacer.js

@@ -0,0 +1,33 @@
+/**
+ * A simple element that adds extra horizontal space between items in a toolbar.
+ * By default a 2px wide space is added via CSS specification:
+ *
+ *     .x-toolbar .x-toolbar-spacer {
+ *         width: 2px;
+ *     }
+ *
+ * Example:
+ *
+ *     @example
+ *     Ext.create('Ext.panel.Panel', {
+ *         title: 'Toolbar Spacer Example',
+ *         width: 300,
+ *         height: 200,
+ *         tbar : [
+ *             'Item 1',
+ *             { xtype: 'tbspacer' }, // or ' '
+ *             'Item 2',
+ *             // space width is also configurable via javascript
+ *             { xtype: 'tbspacer', width: 50 }, // add a 50px space
+ *             'Item 3'
+ *         ],
+ *         renderTo: Ext.getBody()
+ *     });
+ */
+Ext.define('Ext.toolbar.Spacer', {
+    extend: 'Ext.Component',
+    alias: 'widget.tbspacer',
+    alternateClassName: 'Ext.Toolbar.Spacer',
+    baseCls: Ext.baseCSSPrefix + 'toolbar-spacer',
+    focusable: false
+});

data/app/assets/javascripts/extjs-rails/src/toolbar/TextItem.js

@@ -0,0 +1,57 @@
+/**
+ * A simple class that renders text directly into a toolbar.
+ *
+ *     @example
+ *     Ext.create('Ext.panel.Panel', {
+ *         title: 'Panel with TextItem',
+ *         width: 300,
+ *         height: 200,
+ *         tbar: [
+ *             { xtype: 'tbtext', text: 'Sample Text Item' }
+ *         ],
+ *         renderTo: Ext.getBody()
+ *     });
+ *
+ * @constructor
+ * Creates a new TextItem
+ * @param {Object} text A text string, or a config object containing a #text property
+ */
+Ext.define('Ext.toolbar.TextItem', {
+    extend: 'Ext.toolbar.Item',
+    requires: ['Ext.XTemplate'],
+    alias: 'widget.tbtext',
+    alternateClassName: 'Ext.Toolbar.TextItem',
+
+    /**
+     * @cfg {String} text
+     * The text to be used as innerHTML (html tags are accepted).
+     */
+    text: '',
+
+    renderTpl: '{text}',
+    //
+    baseCls: Ext.baseCSSPrefix + 'toolbar-text',
+
+    beforeRender : function() {
+        var me = this;
+
+        me.callParent();
+
+        Ext.apply(me.renderData, {
+            text: me.text
+        });
+    },
+
+    /**
+     * Updates this item's text, setting the text to be used as innerHTML.
+     * @param {String} t The text to display (html accepted).
+     */
+    setText : function(t) {
+        if (this.rendered) {
+            this.el.update(t);
+            this.ownerCt.doLayout(); // In case an empty text item (centered at zero height) receives new text.
+        } else {
+            this.text = t;
+        }
+    }
+});

data/app/assets/javascripts/extjs-rails/src/toolbar/Toolbar-legacy.js

@@ -0,0 +1,123 @@
+// backwards compat
+Ext.toolbar.Toolbar.Button = Ext.extend(Ext.button.Button, {});
+Ext.toolbar.Toolbar.SplitButton = Ext.extend(Ext.button.Split, {});
+Ext.reg('tbbutton', Ext.toolbar.Toolbar.Button);
+Ext.reg('tbsplit', Ext.toolbar.Toolbar.SplitButton);
+
+// Exclude from documentation
+Ext.toolbar.Toolbar.override({
+    /*
+     * Adds text to the toolbar
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {String} text The text to add
+     * @return {Ext.toolbar.Item} The element's item
+     */
+    addText : function(text){
+        return this.addItem(new Ext.Toolbar.TextItem(text));
+    },
+
+    /*
+     * Adds a new element to the toolbar from the passed {@link Ext.DomHelper} config
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {Object} config
+     * @return {Ext.toolbar.Item} The element's item
+     */
+    addDom : function(config){
+        return this.add(new Ext.Toolbar.Item({autoEl: config}));
+    },
+
+    /*
+     * Adds a dynamically rendered Ext.form field (Text, ComboBox, etc). Note: the field should not have
+     * been rendered yet. For a field that has already been rendered, use {@link #addElement}.
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {Ext.form.field.Field} field
+     * @return {Ext.toolbar.Item}
+     */
+    addField : function(field){
+        return this.add(field);
+    },
+
+    /*
+     * Inserts any {@link Ext.toolbar.Item}/{@link Ext.button.Button} at the specified index.
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {Number} index The index where the item is to be inserted
+     * @param {Object/Ext.toolbar.Item/Ext.button.Button/Object[]} item The button, or button config object to be
+     * inserted, or an array of buttons/configs.
+     * @return {Ext.button.Button/Ext.toolbar.Item}
+     */
+    insertButton : function(index, item){
+        if(Ext.isArray(item)){
+            var buttons = [],
+                i, len;
+            for(i = 0, len = item.length; i < len; i++) {
+               buttons.push(this.insertButton(index + i, item[i]));
+            }
+            return buttons;
+        }
+        return Ext.toolbar.Toolbar.superclass.insert.call(this, index, item);
+    },
+
+    /*
+     * Adds a separator
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @return {Ext.toolbar.Item} The separator {@link Ext.toolbar.Item item}
+     */
+    addSeparator : function(){
+        return this.add(new Ext.toolbar.Separator());
+    },
+
+    /*
+     * Adds a spacer element
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @return {Ext.toolbar.Spacer} The spacer item
+     */
+    addSpacer : function(){
+        return this.add(new Ext.Toolbar.Spacer());
+    },
+
+    /*
+     * Forces subsequent additions into the float:right toolbar
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     */
+    addFill : function(){
+        this.add(new Ext.Toolbar.Fill());
+    },
+
+    /*
+     * Adds any standard HTML element to the toolbar
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {String/HTMLElement/Ext.Element} el The element or id of the element to add
+     * @return {Ext.toolbar.Item} The element's item
+     */
+    addElement : function(el){
+        return this.addItem(new Ext.Toolbar.Item({el:el}));
+    },
+
+    /*
+     * Adds any Toolbar.Item or subclass
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {Ext.toolbar.Item} item
+     * @return {Ext.toolbar.Item} The item
+     */
+    addItem : function(item){
+        return this.add.apply(this, arguments);
+    },
+
+    /*
+     * Adds a button (or buttons). See {@link Ext.button.Button} for more info on the config.
+     * <br><p><b>Note</b>: See the notes within {@link Ext.container.Container#add}.</p>
+     * @param {Object/Object[]} config A button config or array of configs
+     * @return {Ext.button.Button/Ext.button.Button[]}
+     */
+    addButton : function(config){
+        if(Ext.isArray(config)){
+            var buttons = [],
+                i, len;
+            for(i = 0, len = config.length; i < len; i++) {
+                buttons.push(this.addButton(config[i]));
+            }
+            return buttons;
+        }
+        return this.add(this.constructButton(config));
+    }
+});

data/app/assets/javascripts/extjs-rails/src/toolbar/Toolbar.js

@@ -0,0 +1,447 @@
+/**
+ * Basic Toolbar class. Although the {@link Ext.container.Container#defaultType defaultType} for
+ * Toolbar is {@link Ext.button.Button button}, Toolbar elements (child items for the Toolbar container)
+ * may be virtually any type of Component. Toolbar elements can be created explicitly via their
+ * constructors, or implicitly via their xtypes, and can be {@link #method-add}ed dynamically.
+ *
+ * ## Some items have shortcut strings for creation:
+ *
+ * | Shortcut | xtype         | Class                         | Description
+ * |:---------|:--------------|:------------------------------|:---------------------------------------------------
+ * | `->`     | `tbfill`      | {@link Ext.toolbar.Fill}      | begin using the right-justified button container
+ * | `-`      | `tbseparator` | {@link Ext.toolbar.Separator} | add a vertical separator bar between toolbar items
+ * | ` `      | `tbspacer`    | {@link Ext.toolbar.Spacer}    | add horiztonal space between elements
+ *
+ *     @example
+ *     Ext.create('Ext.toolbar.Toolbar', {
+ *         renderTo: document.body,
+ *         width   : 500,
+ *         items: [
+ *             {
+ *                 // xtype: 'button', // default for Toolbars
+ *                 text: 'Button'
+ *             },
+ *             {
+ *                 xtype: 'splitbutton',
+ *                 text : 'Split Button'
+ *             },
+ *             // begin using the right-justified button container
+ *             '->', // same as { xtype: 'tbfill' }
+ *             {
+ *                 xtype    : 'textfield',
+ *                 name     : 'field1',
+ *                 emptyText: 'enter search term'
+ *             },
+ *             // add a vertical separator bar between toolbar items
+ *             '-', // same as {xtype: 'tbseparator'} to create Ext.toolbar.Separator
+ *             'text 1', // same as {xtype: 'tbtext', text: 'text1'} to create Ext.toolbar.TextItem
+ *             { xtype: 'tbspacer' },// same as ' ' to create Ext.toolbar.Spacer
+ *             'text 2',
+ *             { xtype: 'tbspacer', width: 50 }, // add a 50px space
+ *             'text 3'
+ *         ]
+ *     });
+ *
+ * Toolbars have {@link #method-enable} and {@link #method-disable} methods which when called, will
+ * enable/disable all items within your toolbar.
+ *
+ *     @example
+ *     Ext.create('Ext.toolbar.Toolbar', {
+ *         renderTo: document.body,
+ *         width   : 400,
+ *         items: [
+ *             {
+ *                 text: 'Button'
+ *             },
+ *             {
+ *                 xtype: 'splitbutton',
+ *                 text : 'Split Button'
+ *             },
+ *             '->',
+ *             {
+ *                 xtype    : 'textfield',
+ *                 name     : 'field1',
+ *                 emptyText: 'enter search term'
+ *             }
+ *         ]
+ *     });
+ *
+ * Example
+ *
+ *     @example
+ *     var enableBtn = Ext.create('Ext.button.Button', {
+ *         text    : 'Enable All Items',
+ *         disabled: true,
+ *         scope   : this,
+ *         handler : function() {
+ *             //disable the enable button and enable the disable button
+ *             enableBtn.disable();
+ *             disableBtn.enable();
+ *
+ *             //enable the toolbar
+ *             toolbar.enable();
+ *         }
+ *     });
+ *
+ *     var disableBtn = Ext.create('Ext.button.Button', {
+ *         text    : 'Disable All Items',
+ *         scope   : this,
+ *         handler : function() {
+ *             //enable the enable button and disable button
+ *             disableBtn.disable();
+ *             enableBtn.enable();
+ *
+ *             //disable the toolbar
+ *             toolbar.disable();
+ *         }
+ *     });
+ *
+ *     var toolbar = Ext.create('Ext.toolbar.Toolbar', {
+ *         renderTo: document.body,
+ *         width   : 400,
+ *         margin  : '5 0 0 0',
+ *         items   : [enableBtn, disableBtn]
+ *     });
+ *
+ * Adding items to and removing items from a toolbar is as simple as calling the {@link #method-add}
+ * and {@link #method-remove} methods. There is also a {@link #removeAll} method
+ * which remove all items within the toolbar.
+ *
+ *     @example
+ *     var toolbar = Ext.create('Ext.toolbar.Toolbar', {
+ *         renderTo: document.body,
+ *         width   : 700,
+ *         items: [
+ *             {
+ *                 text: 'Example Button'
+ *             }
+ *         ]
+ *     });
+ *
+ *     var addedItems = [];
+ *
+ *     Ext.create('Ext.toolbar.Toolbar', {
+ *         renderTo: document.body,
+ *         width   : 700,
+ *         margin  : '5 0 0 0',
+ *         items   : [
+ *             {
+ *                 text   : 'Add a button',
+ *                 scope  : this,
+ *                 handler: function() {
+ *                     var text = prompt('Please enter the text for your button:');
+ *                     addedItems.push(toolbar.add({
+ *                         text: text
+ *                     }));
+ *                 }
+ *             },
+ *             {
+ *                 text   : 'Add a text item',
+ *                 scope  : this,
+ *                 handler: function() {
+ *                     var text = prompt('Please enter the text for your item:');
+ *                     addedItems.push(toolbar.add(text));
+ *                 }
+ *             },
+ *             {
+ *                 text   : 'Add a toolbar separator',
+ *                 scope  : this,
+ *                 handler: function() {
+ *                     addedItems.push(toolbar.add('-'));
+ *                 }
+ *             },
+ *             {
+ *                 text   : 'Add a toolbar spacer',
+ *                 scope  : this,
+ *                 handler: function() {
+ *                     addedItems.push(toolbar.add('->'));
+ *                 }
+ *             },
+ *             '->',
+ *             {
+ *                 text   : 'Remove last inserted item',
+ *                 scope  : this,
+ *                 handler: function() {
+ *                     if (addedItems.length) {
+ *                         toolbar.remove(addedItems.pop());
+ *                     } else if (toolbar.items.length) {
+ *                         toolbar.remove(toolbar.items.last());
+ *                     } else {
+ *                         alert('No items in the toolbar');
+ *                     }
+ *                 }
+ *             },
+ *             {
+ *                 text   : 'Remove all items',
+ *                 scope  : this,
+ *                 handler: function() {
+ *                     toolbar.removeAll();
+ *                 }
+ *             }
+ *         ]
+ *     });
+ *
+ * @constructor
+ * Creates a new Toolbar
+ * @param {Object/Object[]} config A config object or an array of buttons to {@link #method-add}
+ * @docauthor Robert Dougan <rob@sencha.com>
+ */
+Ext.define('Ext.toolbar.Toolbar', {
+    extend: 'Ext.container.Container',
+    requires: [
+        'Ext.toolbar.Fill',
+        'Ext.layout.container.HBox',
+        'Ext.layout.container.VBox'
+    ],
+    uses: [
+        'Ext.toolbar.Separator'
+    ],
+    alias: 'widget.toolbar',
+    alternateClassName: 'Ext.Toolbar',
+
+    /**
+     * @property {Boolean} isToolbar
+     * `true` in this class to identify an object as an instantiated Toolbar, or subclass thereof.
+     */
+    isToolbar: true,
+    baseCls  : Ext.baseCSSPrefix + 'toolbar',
+    ariaRole : 'toolbar',
+
+    defaultType: 'button',
+
+    /**
+     * @cfg {Boolean} vertical
+     * Set to `true` to make the toolbar vertical. The layout will become a `vbox`.
+     */
+    vertical: false,
+
+    /**
+     * @cfg {String/Object} layout
+     * This class assigns a default layout (`layout: 'hbox'`).
+     * Developers _may_ override this configuration option if another layout
+     * is required (the constructor must be passed a configuration object in this
+     * case instead of an array).
+     * See {@link Ext.container.Container#layout} for additional information.
+     */
+
+    /**
+     * @cfg {Boolean} enableOverflow
+     * Configure true to make the toolbar provide a button which activates a dropdown Menu to show
+     * items which overflow the Toolbar's width.
+     */
+    enableOverflow: false,
+
+    /**
+     * @cfg {String} menuTriggerCls
+     * Configure the icon class of the overflow button.
+     */
+    menuTriggerCls: Ext.baseCSSPrefix + 'toolbar-more-icon',
+    
+    // private
+    trackMenus: true,
+
+    itemCls: Ext.baseCSSPrefix + 'toolbar-item',
+
+    statics: {
+        shortcuts: {
+            '-' : 'tbseparator',
+            ' ' : 'tbspacer'
+        },
+
+        shortcutsHV: {
+            // horizontal
+            0: {
+                '->': { xtype: 'tbfill', height: 0 }
+            },
+            // vertical
+            1: {
+                '->': { xtype: 'tbfill', width: 0 }
+            }
+        }
+    },
+
+    initComponent: function() {
+        var me = this,
+            keys;
+
+        // check for simplified (old-style) overflow config:
+        if (!me.layout && me.enableOverflow) {
+            me.layout = { overflowHandler: 'Menu' };
+        }
+
+        if (me.dock === 'right' || me.dock === 'left') {
+            me.vertical = true;
+        }
+
+        me.layout = Ext.applyIf(Ext.isString(me.layout) ? {
+            type: me.layout
+        } : me.layout || {}, {
+            type: me.vertical ? 'vbox' : 'hbox',
+            align: me.vertical ? 'stretchmax' : 'middle'
+        });
+
+        if (me.vertical) {
+            me.addClsWithUI('vertical');
+        }
+
+        // @TODO: remove this hack and implement a more general solution
+        if (me.ui === 'footer') {
+            me.ignoreBorderManagement = true;
+        }
+
+        me.callParent();
+
+        /**
+         * @event overflowchange
+         * Fires after the overflow state has changed.
+         * @param {Object} c The Container
+         * @param {Boolean} lastOverflow overflow state
+         */
+        me.addEvents('overflowchange');
+    },
+
+    getRefItems: function(deep) {
+        var me = this,
+            items = me.callParent(arguments),
+            layout = me.layout,
+            handler;
+
+        if (deep && me.enableOverflow) {
+            handler = layout.overflowHandler;
+            if (handler && handler.menu) {
+                items = items.concat(handler.menu.getRefItems(deep));
+            }
+        }
+        return items;
+    },
+
+    /**
+     * Adds element(s) to the toolbar -- this function takes a variable number of
+     * arguments of mixed type and adds them to the toolbar.
+     *
+     * **Note**: See the notes within {@link Ext.container.Container#method-add}.
+     *
+     * @param {Object...} args The following types of arguments are all valid:
+     *
+     *  - `{@link Ext.button.Button config}`: A valid button config object
+     *  - `HtmlElement`: Any standard HTML element
+     *  - `Field`: Any form field
+     *  - `Item`: Any subclass of {@link Ext.toolbar.Item}
+     *  - `String`: Any generic string (gets wrapped in a {@link Ext.toolbar.TextItem}).
+     *
+     *    Note that there are a few special strings that are treated differently as explained next:
+     *
+     *      - `'-'`: Creates a separator element
+     *      - `' '`: Creates a spacer element
+     *      - `'->'`: Creates a fill element
+     *
+     * @method add
+     */
+
+    // private
+    lookupComponent: function(c) {
+        if (typeof c == 'string') {
+            var T = Ext.toolbar.Toolbar,
+                shortcut = T.shortcutsHV[this.vertical ? 1 : 0][c] || T.shortcuts[c];
+
+            if (typeof shortcut == 'string') {
+                c = {
+                    xtype: shortcut
+                };
+            } else if (shortcut) {
+                c = Ext.apply({}, shortcut);
+            } else {
+                c = {
+                    xtype: 'tbtext',
+                    text: c
+                };
+            }
+
+            this.applyDefaults(c);
+        }
+
+        return this.callParent(arguments);
+    },
+
+    // private
+    applyDefaults: function(c) {
+        if (!Ext.isString(c)) {
+            c = this.callParent(arguments);
+            var d = this.internalDefaults;
+            if (c.events) {
+                Ext.applyIf(c.initialConfig, d);
+                Ext.apply(c, d);
+            } else {
+                Ext.applyIf(c, d);
+            }
+        }
+        return c;
+    },
+
+    // private
+    trackMenu: function(item, remove) {
+        if (this.trackMenus && item.menu) {
+            var method = remove ? 'mun' : 'mon',
+                me = this;
+
+            me[method](item, 'mouseover', me.onButtonOver, me);
+            me[method](item, 'menushow', me.onButtonMenuShow, me);
+            me[method](item, 'menuhide', me.onButtonMenuHide, me);
+        }
+    },
+
+    // private
+    constructButton: function(item) {
+        return item.events ? item
+                : Ext.widget(item.split ? 'splitbutton' : this.defaultType, item);
+    },
+
+    // private
+    onBeforeAdd: function(component) {
+        if (component.is('field') || (component.is('button') && this.ui != 'footer')) {
+            component.ui = component.ui + '-toolbar';
+        }
+
+        // Any separators needs to know if is vertical or not
+        if (component instanceof Ext.toolbar.Separator) {
+            component.setUI((this.vertical) ? 'vertical' : 'horizontal');
+        }
+
+        this.callParent(arguments);
+    },
+
+    // private
+    onAdd: function(component) {
+        this.callParent(arguments);
+        this.trackMenu(component);
+    },
+    
+    // private
+    onRemove: function(c) {
+        this.callParent(arguments);
+        this.trackMenu(c, true);
+    },
+    
+    getChildItemsToDisable: function() {
+        return this.items.getRange();   
+    },
+
+    // private
+    onButtonOver: function(btn){
+        if (this.activeMenuBtn && this.activeMenuBtn != btn) {
+            this.activeMenuBtn.hideMenu();
+            btn.showMenu();
+            this.activeMenuBtn = btn;
+        }
+    },
+
+    // private
+    onButtonMenuShow: function(btn) {
+        this.activeMenuBtn = btn;
+    },
+
+    // private
+    onButtonMenuHide: function(btn) {
+        delete this.activeMenuBtn;
+    }
+});