extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/diag/layout/ContextItem.js

@@ -0,0 +1,179 @@
+/**
+ * This override adds diagnostics to the {@link Ext.layout.ContextItem} class.
+ */
+Ext.define('Ext.diag.layout.ContextItem', {
+
+    override: 'Ext.layout.ContextItem',
+
+    requires: [
+        'Ext.layout.Context',
+        'Ext.diag.layout.Context'
+    ],
+
+    addBlock: function (name, layout, propName) {
+        //Ext.log(this.id,'.',propName,' ',name,': ',this.getLayoutName(layout));
+        (layout.blockedBy || (layout.blockedBy = {}))[
+            this.id+'.'+propName+(name.substring(0,3)=='dom' ? ':dom' : '')] = 1;
+
+        return this.callParent(arguments);
+    },
+
+    addBoxChild: function (boxChildItem) {
+        var ret = this.callParent(arguments),
+            boxChildren = this.boxChildren,
+            boxParents;
+
+        if (boxChildren && boxChildren.length == 1) {
+            // the boxParent collection is created by the run override found in
+            // Ext.diag.layout.Context, but IE sometimes does not load that override, so
+            // we work around it for now
+            boxParents = this.context.boxParents ||
+                        (this.context.boxParents = new Ext.util.MixedCollection());
+            boxParents.add(this);
+        }
+
+        return ret;
+    },
+
+    addTrigger: function (propName, inDom) {
+        var layout = this.context.currentLayout,
+            triggers;
+
+        //Ext.log(this.id,'.',propName,' ',inDom ? ':dom' : '',' ',this.getLayoutName(layout));
+        this.callParent(arguments);
+
+        triggers = this.context.triggersByLayoutId;
+        (triggers[layout.id] || (triggers[layout.id] = {}))[
+            this.id+'.'+propName+(inDom ? ':dom' : '')] = {
+                item: this,
+                name: propName
+            };
+    },
+
+    checkAuthority: function (prop) {
+        var me = this,
+            model = me[prop + 'Model'], // not me.sizeModel[prop] since it is immutable
+            layout = me.context.currentLayout,
+            ok,
+            setBy;
+
+        if (layout == me.target.ownerLayout) {
+            // the ownerLayout is only allowed to set calculated dimensions
+            ok = model.calculated;
+        } else if (layout.isComponentLayout) {
+            // the component's componentLayout (normally) is only allowed to set auto or
+            // configured dimensions. The exception is when a component is run w/o its
+            // ownerLayout in the picture (isTopLevel), someone must publish the lastBox
+            // values and that lucky layout is the componentLayout (kinda had to be since
+            // the ownerLayout is not running)
+            ok = me.isTopLevel || model.auto || model.configured;
+        }
+
+        if (!ok) {
+            setBy = me.getLayoutName(layout);
+
+            Ext.log(setBy + ' cannot set ' + prop);
+        }
+    },
+
+    clearBlocks: function (name, propName) {
+        var collection = this[name],
+            blockedLayouts = collection && collection[propName],
+            key = this.id+'.'+propName+(name.substring(0,3)=='dom' ? ':dom' : ''),
+            layout, layoutId;
+
+        if (blockedLayouts) {
+            for (layoutId in blockedLayouts) {
+                layout = blockedLayouts[layoutId];
+                delete layout.blockedBy[key];
+            }
+        }
+        return this.callParent(arguments);
+    },
+
+    doInvalidate: function () {
+        if (this.context.logOn.doInvalidate) {
+            Ext.log('doInvalidate: ', this.id);
+        }
+        return this.callParent(arguments);
+    },
+
+    getEl: function (el) {
+        var child = this.callParent(arguments);
+        if (child && child !== this && child.parent !== this) {
+            Ext.Error.raise({
+                msg: 'Got element from wrong component'
+            });
+        }
+        return child;
+    },
+
+    init: function () {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (this.context.logOn.initItem) {
+            Ext.log(me.id, ' consumers: content=', me.consumersContentWidth,'/',me.consumersContentHeight,
+                ', container=', me.consumersContainerWidth,'/',me.consumersContainerHeight,
+                ', size=', me.consumersWidth,'/',me.consumersHeight);
+        }
+    },
+
+    invalidate: function () {
+        if (this.wrapsComponent) {
+            if (this.context.logOn.invalidate) {
+                Ext.log('invalidate: ', this.id);
+            }
+        } else {
+            Ext.Error.raise({
+                msg: 'Cannot invalidate an element contextItem'
+            });
+        }
+        return this.callParent(arguments);
+    },
+
+    setProp: function (propName, value, dirty) {
+        var me = this,
+            layout = me.context.currentLayout,
+            setBy = me.getLayoutName(layout),
+            fullName = me.id + '.' + propName,
+            setByProps;
+
+        if (value !== null) {
+            setByProps = me.setBy || (me.setBy = {});
+            if (!setByProps[propName]) {
+                setByProps[propName] = setBy;
+            } else if (setByProps[propName] != setBy) {
+                Ext.log({level: 'warn'}, 'BAD! ', fullName, ' set by ', setByProps[propName], ' and ', setBy);
+            }
+        }
+
+        if (me.context.logOn.setProp) {
+            if (typeof value != 'undefined' && !isNaN(value) && me.props[propName] !== value) {
+                Ext.log('set ', fullName, ' = ', value, ' (', dirty, ')');
+            }
+        }
+
+        return this.callParent(arguments);
+    },
+
+    setHeight: function (height, dirty, /* private */force) {
+        if (!force && this.wrapsComponent) {
+            this.checkAuthority('height');
+        }
+
+        return this.callParent(arguments);
+    },
+
+    setWidth: function (width, dirty, /* private */force) {
+        if (!force && this.wrapsComponent) {
+            this.checkAuthority('width');
+        }
+
+        return this.callParent(arguments);
+    }
+},
+function () {
+    this.prototype.getLayoutName = Ext.layout.Context.prototype.getLayoutName;
+});

data/app/assets/javascripts/extjs-rails/src/direct/Event.js

@@ -0,0 +1,35 @@
+/**
+ * @class Ext.direct.Event
+ * A base class for all Ext.direct events. An event is
+ * created after some kind of interaction with the server.
+ * The event class is essentially just a data structure
+ * to hold a Direct response.
+ */
+Ext.define('Ext.direct.Event', {
+
+    /* Begin Definitions */
+
+    alias: 'direct.event',
+
+    requires: ['Ext.direct.Manager'],
+
+    /* End Definitions */
+
+    status: true,
+
+    /**
+     * Creates new Event.
+     * @param {Object} config (optional) Config object.
+     */
+    constructor: function(config) {
+        Ext.apply(this, config);
+    },
+
+    /**
+     * Return the raw data for this event.
+     * @return {Object} The data from the event
+     */
+    getData: function(){
+        return this.data;
+    }
+});

data/app/assets/javascripts/extjs-rails/src/direct/ExceptionEvent.js

@@ -0,0 +1,16 @@
+/**
+ * @class Ext.direct.ExceptionEvent
+ * An event that is fired when an exception is received from a {@link Ext.direct.RemotingProvider}
+ */
+Ext.define('Ext.direct.ExceptionEvent', {
+    
+    /* Begin Definitions */
+   
+    extend: 'Ext.direct.RemotingEvent',
+    
+    alias: 'direct.exception',
+    
+    /* End Definitions */
+   
+   status: false
+});

data/app/assets/javascripts/extjs-rails/src/direct/JsonProvider.js

@@ -0,0 +1,82 @@
+/**
+ * @class Ext.direct.JsonProvider
+
+A base provider for communicating using JSON. This is an abstract class
+and should not be instanced directly.
+
+ * @markdown
+ * @abstract
+ */
+
+Ext.define('Ext.direct.JsonProvider', {
+
+    /* Begin Definitions */
+
+    extend: 'Ext.direct.Provider',
+
+    alias: 'direct.jsonprovider',
+
+    uses: ['Ext.direct.ExceptionEvent'],
+
+    /* End Definitions */
+
+   /**
+    * Parse the JSON response
+    * @private
+    * @param {Object} response The XHR response object
+    * @return {Object} The data in the response.
+    */
+   parseResponse: function(response){
+        if (!Ext.isEmpty(response.responseText)) {
+            if (Ext.isObject(response.responseText)) {
+                return response.responseText;
+            }
+            return Ext.decode(response.responseText);
+        }
+        return null;
+    },
+
+    /**
+     * Creates a set of events based on the XHR response
+     * @private
+     * @param {Object} response The XHR response
+     * @return {Ext.direct.Event[]} An array of Ext.direct.Event
+     */
+    createEvents: function(response){
+        var data = null,
+            events = [],
+            event,
+            i = 0,
+            len;
+
+        try{
+            data = this.parseResponse(response);
+        } catch(e) {
+            event = new Ext.direct.ExceptionEvent({
+                data: e,
+                xhr: response,
+                code: Ext.direct.Manager.self.exceptions.PARSE,
+                message: 'Error parsing json response: \n\n ' + data
+            });
+            return [event];
+        }
+
+        if (Ext.isArray(data)) {
+            for (len = data.length; i < len; ++i) {
+                events.push(this.createEvent(data[i]));
+            }
+        } else {
+            events.push(this.createEvent(data));
+        }
+        return events;
+    },
+
+    /**
+     * Create an event from a response object
+     * @param {Object} response The XHR response object
+     * @return {Ext.direct.Event} The event
+     */
+    createEvent: function(response){
+        return Ext.create('direct.' + response.type, response);
+    }
+});

data/app/assets/javascripts/extjs-rails/src/direct/Manager.js

@@ -0,0 +1,263 @@
+/**
+ * Ext.Direct aims to streamline communication between the client and server by providing a single interface that
+ * reduces the amount of common code typically required to validate data and handle returned data packets (reading data,
+ * error conditions, etc).
+ *
+ * The Ext.direct namespace includes several classes for a closer integration with the server-side. The Ext.data
+ * namespace also includes classes for working with Ext.data.Stores which are backed by data from an Ext.Direct method.
+ *
+ * # Specification
+ *
+ * For additional information consult the [Ext.Direct Specification][1].
+ *
+ * # Providers
+ *
+ * Ext.Direct uses a provider architecture, where one or more providers are used to transport data to and from the
+ * server. There are several providers that exist in the core at the moment:
+ *
+ * - {@link Ext.direct.JsonProvider JsonProvider} for simple JSON operations
+ * - {@link Ext.direct.PollingProvider PollingProvider} for repeated requests
+ * - {@link Ext.direct.RemotingProvider RemotingProvider} exposes server side on the client.
+ *
+ * A provider does not need to be invoked directly, providers are added via {@link Ext.direct.Manager}.{@link #addProvider}.
+ *
+ * # Router
+ *
+ * Ext.Direct utilizes a "router" on the server to direct requests from the client to the appropriate server-side
+ * method. Because the Ext.Direct API is completely platform-agnostic, you could completely swap out a Java based server
+ * solution and replace it with one that uses C# without changing the client side JavaScript at all.
+ *
+ * # Server side events
+ *
+ * Custom events from the server may be handled by the client by adding listeners, for example:
+ *
+ *     {"type":"event","name":"message","data":"Successfully polled at: 11:19:30 am"}
+ *
+ *     // add a handler for a 'message' event sent by the server
+ *     Ext.direct.Manager.on('message', function(e){
+ *         out.append(String.format('<p><i>{0}</i></p>', e.data));
+ *         out.el.scrollTo('t', 100000, true);
+ *     });
+ *
+ *    [1]: http://sencha.com/products/extjs/extdirect
+ *
+ * @singleton
+ * @alternateClassName Ext.Direct
+ */
+Ext.define('Ext.direct.Manager', {
+
+    /* Begin Definitions */
+    singleton: true,
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: ['Ext.util.MixedCollection'],
+
+    statics: {
+        exceptions: {
+            TRANSPORT: 'xhr',
+            PARSE: 'parse',
+            LOGIN: 'login',
+            SERVER: 'exception'
+        }
+    },
+
+    /* End Definitions */
+
+    constructor: function(){
+        var me = this;
+
+        me.addEvents(
+            /**
+             * @event event
+             * Fires after an event.
+             * @param {Ext.direct.Event} e The Ext.direct.Event type that occurred.
+             * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
+             */
+            'event',
+            /**
+             * @event exception
+             * Fires after an event exception.
+             * @param {Ext.direct.Event} e The event type that occurred.
+             */
+            'exception'
+        );
+        me.transactions = new Ext.util.MixedCollection();
+        me.providers = new Ext.util.MixedCollection();
+
+        me.mixins.observable.constructor.call(me);
+    },
+
+    /**
+     * Adds an Ext.Direct Provider and creates the proxy or stub methods to execute server-side methods. If the provider
+     * is not already connected, it will auto-connect.
+     *
+     *     var pollProv = new Ext.direct.PollingProvider({
+     *         url: 'php/poll2.php'
+     *     });
+     *
+     *     Ext.direct.Manager.addProvider({
+     *         "type":"remoting",       // create a {@link Ext.direct.RemotingProvider}
+     *         "url":"php\/router.php", // url to connect to the Ext.Direct server-side router.
+     *         "actions":{              // each property within the actions object represents a Class
+     *             "TestAction":[       // array of methods within each server side Class
+     *             {
+     *                 "name":"doEcho", // name of method
+     *                 "len":1
+     *             },{
+     *                 "name":"multiply",
+     *                 "len":1
+     *             },{
+     *                 "name":"doForm",
+     *                 "formHandler":true, // handle form on server with Ext.Direct.Transaction
+     *                 "len":1
+     *             }]
+     *         },
+     *         "namespace":"myApplication",// namespace to create the Remoting Provider in
+     *     },{
+     *         type: 'polling', // create a {@link Ext.direct.PollingProvider}
+     *         url:  'php/poll.php'
+     *     }, pollProv); // reference to previously created instance
+     *
+     * @param {Ext.direct.Provider/Object...} provider
+     * Accepts any number of Provider descriptions (an instance or config object for
+     * a Provider). Each Provider description instructs Ext.Directhow to create
+     * client-side stub methods.
+     */
+    addProvider : function(provider){
+        var me = this,
+            args = arguments,
+            i = 0,
+            len;
+
+        if (args.length > 1) {
+            for (len = args.length; i < len; ++i) {
+                me.addProvider(args[i]);
+            }
+            return;
+        }
+
+        // if provider has not already been instantiated
+        if (!provider.isProvider) {
+            provider = Ext.create('direct.' + provider.type + 'provider', provider);
+        }
+        me.providers.add(provider);
+        provider.on('data', me.onProviderData, me);
+
+
+        if (!provider.isConnected()) {
+            provider.connect();
+        }
+
+        return provider;
+    },
+
+    /**
+     * Retrieves a {@link Ext.direct.Provider provider} by the **{@link Ext.direct.Provider#id id}** specified when the
+     * provider is {@link #addProvider added}.
+     * @param {String/Ext.direct.Provider} id The id of the provider, or the provider instance.
+     */
+    getProvider : function(id){
+        return id.isProvider ? id : this.providers.get(id);
+    },
+
+    /**
+     * Removes the provider.
+     * @param {String/Ext.direct.Provider} provider The provider instance or the id of the provider.
+     * @return {Ext.direct.Provider} The provider, null if not found.
+     */
+    removeProvider : function(provider){
+        var me = this,
+            providers = me.providers;
+
+        provider = provider.isProvider ? provider : providers.get(provider);
+
+        if (provider) {
+            provider.un('data', me.onProviderData, me);
+            providers.remove(provider);
+            return provider;
+        }
+        return null;
+    },
+
+    /**
+     * Adds a transaction to the manager.
+     * @private
+     * @param {Ext.direct.Transaction} transaction The transaction to add
+     * @return {Ext.direct.Transaction} transaction
+     */
+    addTransaction: function(transaction){
+        this.transactions.add(transaction);
+        return transaction;
+    },
+
+    /**
+     * Removes a transaction from the manager.
+     * @private
+     * @param {String/Ext.direct.Transaction} transaction The transaction/id of transaction to remove
+     * @return {Ext.direct.Transaction} transaction
+     */
+    removeTransaction: function(transaction){
+        transaction = this.getTransaction(transaction);
+        this.transactions.remove(transaction);
+        return transaction;
+    },
+
+    /**
+     * Gets a transaction
+     * @private
+     * @param {String/Ext.direct.Transaction} transaction The transaction/id of transaction to get
+     * @return {Ext.direct.Transaction}
+     */
+    getTransaction: function(transaction){
+        return Ext.isObject(transaction) ? transaction : this.transactions.get(transaction);
+    },
+
+    onProviderData : function(provider, event){
+        var me = this,
+            i = 0,
+            len;
+
+        if (Ext.isArray(event)) {
+            for (len = event.length; i < len; ++i) {
+                me.onProviderData(provider, event[i]);
+            }
+            return;
+        }
+        if (event.name && event.name != 'event' && event.name != 'exception') {
+            me.fireEvent(event.name, event);
+        } else if (event.status === false) {
+            me.fireEvent('exception', event);
+        }
+        me.fireEvent('event', event, provider);
+    },
+    
+    /**
+     * Parses a direct function. It may be passed in a string format, for example:
+     * "MyApp.Person.read".
+     * @protected
+     * @param {String/Function} fn The direct function
+     * @return {Function} The function to use in the direct call. Null if not found
+     */
+    parseMethod: function(fn){
+        if (Ext.isString(fn)) {
+            var parts = fn.split('.'),
+                i = 0,
+                len = parts.length,
+                current = window;
+                
+            while (current && i < len) {
+                current = current[parts[i]];
+                ++i;
+            }
+            fn = Ext.isFunction(current) ? current : null;
+        }
+        return fn || null;
+    }
+    
+}, function(){
+    // Backwards compatibility
+    Ext.Direct = Ext.direct.Manager;
+});