compass_ae_sencha 2.0.0 → 2.2.0

data/app/assets/javascripts/extjs/Deferred.js

@@ -0,0 +1,106 @@
+/**
+ * @class Ext.ux.Deferred
+ * @author Vincenzo Ferrari <wilk3ert@gmail.com>
+ *
+ * Deferred for ExtJS and Sencha Touch
+ *
+ */
+Ext.define('Ext.ux.Deferred', {
+    requires: ['Ext.ux.Promise'],
+
+    /**
+     * internal promise needed from resolve and reject methods
+     * @private
+     */
+    internalPromise: null,
+
+    inheritableStatics: {
+        /**
+         * @method when
+         * It encapsulates the given promises in a new one that is returned.
+         * When the new promise is executed, the listeners attached will be notified.
+         * @param {Function/Ext.ux.Promise/Function[]/Ext.ux.Promise[]} args One or more Ext.ux.Promise or one or more Function that return an Ext.ux.Promise
+         * The returned promise will be solved or rejected after each given promise have finished
+         * @return {Ext.ux.Promise} The promise
+         * @static
+         */
+        when: function () {
+            var deferred = Ext.create('Ext.ux.Deferred'),
+                promises = arguments,
+                promisesLen = promises.length,
+                rejectedCounter = 0,
+                resolved = {},
+                rejected = {};
+
+            // Make a single promise for those passed
+            for (var i = 0; i < promises.length; i++) {
+                // Use a closure to work with the current one specified by index 'i'
+                (function (i) {
+                    var promise = promises[i];
+
+                    // This let 'when' to accept functions that return a promise invoking them afterwards
+                    if (typeof promise === 'function') promise = promise();
+
+                    if (promise instanceof Ext.ux.Promise) {
+                        promise.then(function () {
+                            promisesLen--;
+                            resolved[i] = arguments.length === 1 ? arguments[0] : arguments;
+
+                            // Execute the promise only if there's no other pending promise
+                            if (promisesLen === 0) {
+                                // If an error occurred or one of the promises has been rejected
+                                // reject the wrapping promise, even if it's the only rejected
+                                if (rejectedCounter > 0) deferred.reject(rejected);
+                                else deferred.resolve(resolved);
+                            }
+                        }, function () {
+                            promisesLen--;
+                            rejectedCounter++;
+                            rejected[i] = arguments.length === 1 ? arguments[0] : arguments;
+
+                            if (promisesLen === 0) {
+                                deferred.reject(rejected);
+                            }
+                        });
+                    }
+                })(i);
+            }
+
+            return deferred.promise();
+        }
+    },
+
+    /**
+     * @method resolve
+     * Solve the promise and launch the callback attached with then (or success or done) method.
+     * The given data is passed to the ballback
+     * @param {Object} args Data to pass to the attached function
+     * @return {Ext.ux.Deferred} this
+     */
+    resolve: function () {
+        return this.internalPromise.resolve.apply(this.internalPromise, arguments);
+    },
+
+    /**
+     * @method reject
+     * Reject the promise and launch the callback attached with then (or failure or fail) method.
+     * The given data is passed to the ballback
+     * @param {Object} args Data to pass to the attached function
+     * @return {Ext.ux.Deferred} this
+     */
+    reject: function () {
+        return this.internalPromise.reject.apply(this.internalPromise, arguments);
+    },
+
+    /**
+     * @method promise
+     * Provides a new instance of Ext.ux.Promise
+     * @return {Ext.ux.Promise} The promise
+     */
+    promise: function () {
+        var me = this;
+
+        if (me.internalPromise instanceof Ext.ux.Promise) return me.internalPromise;
+        else return me.internalPromise = Ext.create('Ext.ux.Promise');
+    }
+});

data/app/assets/javascripts/extjs/Ext.form.field.Month.js

@@ -0,0 +1,74 @@
+Ext.define('Ext.form.field.Month', {
+    extend: 'Ext.form.field.Date',
+    alias: 'widget.monthfield',
+    requires: ['Ext.picker.Month'],
+    alternateClassName: ['Ext.form.MonthField', 'Ext.form.Month'],
+    selectMonth: null,
+    createPicker: function() {
+        var me = this,
+            format = Ext.String.format;
+        return Ext.create('Ext.picker.Month', {
+            pickerField: me,
+            ownerCt: me.ownerCt,
+            renderTo: document.body,
+            floating: true,
+            hidden: true,
+            focusOnShow: true,
+            minDate: me.minValue,
+            maxDate: me.maxValue,
+            disabledDatesRE: me.disabledDatesRE,
+            disabledDatesText: me.disabledDatesText,
+            disabledDays: me.disabledDays,
+            disabledDaysText: me.disabledDaysText,
+            format: me.format,
+            showToday: me.showToday,
+            startDay: me.startDay,
+            minText: format(me.minText, me.formatDate(me.minValue)),
+            maxText: format(me.maxText, me.formatDate(me.maxValue)),
+            listeners: {
+                select: {
+                    scope: me,
+                    fn: me.onSelect
+                },
+                monthdblclick: {
+                    scope: me,
+                    fn: me.onOKClick
+                },
+                yeardblclick: {
+                    scope: me,
+                    fn: me.onOKClick
+                },
+                OkClick: {
+                    scope: me,
+                    fn: me.onOKClick
+                },
+                CancelClick: {
+                    scope: me,
+                    fn: me.onCancelClick
+                }
+            },
+            keyNavConfig: {
+                esc: function() {
+                    me.collapse();
+                }
+            }
+        });
+    },
+    onCancelClick: function() {
+        var me = this;
+        me.selectMonth = null;
+        me.collapse();
+    },
+    onOKClick: function() {
+        var me = this;
+        if (me.selectMonth) {
+            me.setValue(me.selectMonth);
+            me.fireEvent('select', me, me.selectMonth);
+        }
+        me.collapse();
+    },
+    onSelect: function(m, d) {
+        var me = this;
+        me.selectMonth = new Date((d[0] + 1) + '/1/' + d[1]);
+    }
+});

data/app/assets/javascripts/extjs/Promise.js

@@ -0,0 +1,251 @@
+/**
+ * @class Ext.ux.Promise
+ * @author Vincenzo Ferrari <wilk3ert@gmail.com>
+ *
+ * Promise for ExtJS and Sencha Touch
+ *
+ */
+Ext.define('Ext.ux.Promise', {
+    inheritableStatics: {
+        /**
+         * Pending state
+         * @type Number
+         * @static
+         */
+        PENDING: 0,
+
+        /**
+         * Fulfilled state
+         * @type Number
+         * @static
+         */
+        FULFILLED: 1,
+
+        /**
+         * Rejected state
+         * @type Number
+         * @static
+         */
+        REJECTED: 2
+    },
+
+    config: {
+        /**
+         * The promise state
+         * @property
+         */
+        state: 0
+    },
+
+    /**
+     * The internal deferred
+     * @private
+     */
+    deferred: null,
+
+    /**
+     * Internal success queue
+     * @private
+     */
+    successQueue: [],
+
+    /**
+     * Internal failure queue
+     * @private
+     */
+    failureQueue: [],
+
+    /**
+     * Creates a new promise
+     * @param {object} cfg The configuration options may be specified as follows:
+     *
+     *     // with a configuration set
+     *     var config = {
+     *       deferred: deferred // deferred is an instace of Ext.ux.Deferred
+     *     };
+     *
+     *     var promise = Ext.create('Ext.ux.Promise', config);
+     *
+     * @return {Ext.ux.Promise} An instance of Ext.ux.Promise or null if an error occurred.
+     */
+    constructor: function (cfg) {
+        var me = this;
+
+        me.initConfig(cfg);
+
+        // Reset internal configurations
+        me.successQueue = [];
+        me.failureQueue = [];
+        me.deferred = null;
+
+        return me;
+    },
+
+    /**
+     * @method
+     * Resolve the promise, called directly from the parent deferred
+     * @private
+     */
+    resolve: function () {
+        var me = this,
+            results = [],
+            errors = [],
+            args = Array.prototype.slice.call(arguments, 0);
+
+        me.setState(Ext.ux.Promise.FULFILLED);
+
+        // Resolve it only if it needed
+        if (me.successQueue.length > 0) {
+            while (me.successQueue.length > 0) {
+                var onSuccess = me.successQueue.shift();
+
+                if (typeof onSuccess === 'function') {
+                    try {
+                        var result = onSuccess.apply(null, arguments);
+                        if (result) results.push(result);
+                    }
+                    catch (err) {
+                        errors.push(err);
+                    }
+                }
+            }
+
+            // If there's an error, reject the associated deferred
+            if (errors.length > 0) me.deferred.reject(errors);
+            else {
+                // Otherwise resolve it with every result
+                results = args.concat(results);
+                me.deferred.resolve(results);
+            }
+        }
+    },
+
+    /**
+     * @method
+     * Reject the promise, called directly from the parent deferred
+     * @private
+     */
+    reject: function () {
+        var me = this,
+            results = [],
+            errors = [],
+            args = Array.prototype.slice.call(arguments, 0);
+
+        me.setState(Ext.ux.Promise.REJECTED);
+
+        if (me.failureQueue.length > 0) {
+            while (me.failureQueue.length > 0) {
+                var onFailure = me.failureQueue.shift();
+
+                if (typeof onFailure === 'function') {
+                    try {
+                        var result = onFailure.apply(null, arguments);
+                        if (result) results.push(result);
+                    }
+                    catch (err) {
+                        errors.push(err);
+                    }
+                }
+            }
+
+            if (errors.length > 0) me.deferred.reject(errors);
+            else {
+                results = args.concat(results);
+                me.deferred.reject(results);
+            }
+        }
+    },
+
+    /**
+     * @method then
+     * Attaches two callbacks to the deferred internal reference, one for success and one for failure.
+     * They are called by deferred.resolve and deferred.reject
+     * @param {Function} onSuccess Success callback, called by deferred.resolve
+     * @param {Function} onFailure Failure callback, called by deferred.reject
+     * @return {Ext.ux.Promise} this
+     */
+    then: function (onSuccess, onFailure) {
+        var me = this;
+
+        if (typeof onSuccess !== 'function' && typeof onFailure !== 'function') throw new Error('Ext.ux.Promise.then(): onSuccess or onFailure callback is needed');
+
+        if (!(me.deferred instanceof Ext.ux.Deferred)) me.deferred = Ext.create('Ext.ux.Deferred');
+
+        if (typeof onSuccess === 'function') me.successQueue.push(onSuccess);
+        if (typeof onFailure === 'function') me.failureQueue.push(onFailure);
+
+        return me.deferred.promise();
+    },
+
+    /**
+     * @method success
+     * Attaches the success callback to the promise
+     * @param {Function} onSuccess Callback successful promise
+     * @returns {Ext.ux.Promise} Return itself
+     */
+    success: function (onSuccess) {
+        this.then(onSuccess);
+
+        return this;
+    },
+
+    /**
+     * @method done
+     * Alias for success
+     * @param {Function} onSuccess Callback exectued after the promise is resolved
+     * @returns {Ext.ux.Promise} Return itself
+     */
+    done: function (onSuccess) {
+        this.then(onSuccess);
+
+        return this;
+    },
+
+    /**
+     * @method failure
+     * Attaches the failure callback to the promise
+     * @param {Function} onFailure Callback executed after the promise is rejected
+     * @returns {Ext.ux.Promise} Return itself
+     */
+    failure: function (onFailure) {
+        this.then(undefined, onFailure);
+
+        return this;
+    },
+
+    /**
+     * @method fail
+     * Alias for failure
+     * @param {Function} onFailure Callback executed after the promise is rejected
+     * @returns {Ext.ux.Promise} Return itself
+     */
+    fail: function (onFailure) {
+        this.then(undefined, onFailure);
+
+        return this;
+    },
+
+    /**
+     * Check if the promise is resolved or not
+     * @returns {boolean} true if the promise is resolved, false otherwise
+     */
+    resolved: function () {
+        return this.getState() === Ext.ux.Promise.FULFILLED;
+    },
+
+    /**
+     * Check if the promise is rejected or not
+     * @returns {boolean} true if the promise is rejected, false otherwise
+     */
+    rejected: function () {
+        return this.getState() === Ext.ux.Promise.REJECTED;
+    },
+
+    /**
+     * Check if the promise is pending or not
+     * @returns {boolean} true if the promise is pending, false otherwise
+     */
+    pending: function () {
+        return this.getState() === Ext.ux.Promise.PENDING;
+    }
+});

data/app/assets/javascripts/extjs/app-debug.js

@@ -0,0 +1,24 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require ./ext-all-debug
+//= require ./ext-theme-neptune
+//= require ./ext_ux_tab_close_menu
+//= require ./Ext.ux.form.MultiSelect
+//= require ./Ext.ux.CheckColumn
+//= require ./MultiCellSelectionModel
+//= require ./Ext.form.field.Month
+//= require ./helpQtip
+//= require ./Promise
+//= require ./Deferred
+//= require ./overrides
+//= require ./extensions