extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/core/src/env/Browser.js

@@ -0,0 +1,186 @@
+/**
+ * Provides useful information about the current browser.
+ * Should not be manually instantiated unless for unit-testing; access the global instance
+ * stored in {@link Ext#browser} instead. Example:
+ *
+ *     if (Ext.browser.is.IE) {
+ *          // IE specific code here
+ *     }
+ *
+ *     if (Ext.browser.is.WebKit) {
+ *          // WebKit specific code here
+ *     }
+ *
+ *     console.log("Version " + Ext.browser.version);
+ *
+ * For a full list of supported values, refer to: {@link Ext.env.Browser#is}
+ */
+Ext.define('Ext.env.Browser', {
+    statics: {
+        browserNames: {
+            ie: 'IE',
+            firefox: 'Firefox',
+            safari: 'Safari',
+            chrome: 'Chrome',
+            opera: 'Opera',
+            other: 'Other'
+        },
+        engineNames: {
+            webkit: 'WebKit',
+            gecko: 'Gecko',
+            presto: 'Presto',
+            trident: 'Trident',
+            other: 'Other'
+        },
+        enginePrefixes: {
+            webkit: 'AppleWebKit/',
+            gecko: 'Gecko/',
+            presto: 'Presto/',
+            trident: 'Trident/'
+        },
+        browserPrefixes: {
+            ie: 'MSIE ',
+            firefox: 'Firefox/',
+            chrome: 'Chrome/',
+            safari: 'Version/',
+            opera: 'Opera/'
+        }
+    },
+
+    /**
+     * @property {Boolean} isSecure
+     * True if the page is running over SSL
+     */
+    isSecure: false,
+
+    /**
+     * @property {Boolean} isStrict
+     * True if the document is in strict mode
+     */
+    isStrict: false,
+
+    /**
+     * A "hybrid" property, can be either accessed as a method call, i.e:
+     *
+     *     if (Ext.browser.is('IE')) { ... }
+     *
+     * or as an object with boolean properties, i.e:
+     *
+     *     if (Ext.browser.is.IE) { ... }
+     *
+     * Versions can be conveniently checked as well. For example:
+     *
+     *     if (Ext.browser.is.IE6) { ... } // Equivalent to (Ext.browser.is.IE && Ext.browser.version.equals(6))
+     *
+     * Note that only {@link Ext.Version#getMajor major component}  and {@link Ext.Version#getShortVersion shortVersion}
+     * value of the version are available via direct property checking.
+     *
+     * Supported values are: IE, Firefox, Safari, Chrome, Opera, WebKit, Gecko, Presto, Trident and Other
+     *
+     * @param {String} value The OS name to check
+     * @return {Boolean}
+     * @method
+     */
+    is: Ext.emptyFn,
+
+    /**
+     * @property {String} name
+     * The full name of the current browser
+     * Possible values are: IE, Firefox, Safari, Chrome, Opera and Other.
+     * @readonly
+     */
+    name: null,
+
+    /**
+     * @property {Ext.Version} version
+     * Refer to {@link Ext.Version}.
+     * @readonly
+     */
+    version: null,
+
+    /**
+     * @property {String} engineName
+     * The full name of the current browser's engine.
+     * Possible values are: WebKit, Gecko, Presto, Trident and Other.
+     * @readonly
+     */
+    engineName: null,
+
+    /**
+     * @property {String} engineVersion
+     * Refer to {@link Ext.Version}.
+     * @readonly
+     */
+    engineVersion: null,
+
+    constructor: function() {
+        var userAgent      = this.userAgent = Ext.global.navigator.userAgent,
+            selfClass      = this.statics(),
+            browserMatch   = userAgent.match(new RegExp('((?:' + Ext.Object.getValues(selfClass.browserPrefixes).join(')|(?:') + '))([\\d\\._]+)')),
+            engineMatch    = userAgent.match(new RegExp('((?:' + Ext.Object.getValues(selfClass.enginePrefixes).join(')|(?:') + '))([\\d\\._]+)')),
+            browserName    = selfClass.browserNames.other,
+            browserVersion = '',
+            engineName     = selfClass.engineNames.other,
+            engineVersion  = '',
+            key, value;
+
+        this.is = function(name) {
+            return this.is[name] === true;
+        };
+
+        if (browserMatch) {
+            browserName = selfClass.browserNames[Ext.Object.getKey(selfClass.browserPrefixes, browserMatch[1])];
+            browserVersion = browserMatch[2];
+        }
+
+        if (engineMatch) {
+            engineName = selfClass.engineNames[Ext.Object.getKey(selfClass.enginePrefixes, engineMatch[1])];
+            engineVersion = engineMatch[2];
+        }
+
+        Ext.apply(this, {
+            engineName: engineName,
+            engineVersion: new Ext.Version(engineVersion),
+            name: browserName,
+            version: new Ext.Version(browserVersion)
+        });
+
+        this.is[this.name] = true;
+        this.is[this.name + (this.version.getMajor() || '')] = true;
+        this.is[this.name + this.version.getShortVersion()] = true;
+
+        for (key in selfClass.browserNames) {
+            if (selfClass.browserNames.hasOwnProperty(key)) {
+                value = selfClass.browserNames[key];
+                this.is[value] = (this.name === value);
+            }
+        }
+
+        this.is[this.name] = true;
+        this.is[this.engineName + (this.engineVersion.getMajor() || '')] = true;
+        this.is[this.engineName + this.engineVersion.getShortVersion()] = true;
+
+        for (key in selfClass.engineNames) {
+            if (selfClass.engineNames.hasOwnProperty(key)) {
+                value = selfClass.engineNames[key];
+                this.is[value] = (this.engineNames === value);
+            }
+        }
+
+        this.isSecure = /^https/i.test(Ext.global.location.protocol);
+
+        this.isStrict = Ext.global.document.compatMode === "CSS1Compat";
+
+        return this;
+    }
+
+}, function() {
+
+    /**
+     * @property {Ext.env.Browser} browser
+     * @member Ext
+     * Global convenient instance of {@link Ext.env.Browser}.
+     */
+    Ext.browser = new Ext.env.Browser();
+
+});

data/app/assets/javascripts/extjs-rails/src/core/src/env/FeatureDetector.js

@@ -0,0 +1,274 @@
+/**
+ * Provides useful information about the current browser features.
+ * Don't instantiate directly, but use the {@link Ext#features} property instead.
+ */
+Ext.define('Ext.env.FeatureDetector', {
+
+    statics: {
+        defaultTests: {
+            /**
+             * @property {Boolean}
+             * True if canvas element supported.
+             */
+            Canvas: function() {
+                var element = this.getTestElement('canvas');
+                return !!(element && element.getContext && element.getContext('2d'));
+            },
+            /**
+             * @property {Boolean}
+             * True if SVG supported.
+             */
+            SVG: function() {
+                var doc = Ext.global.document;
+
+                return !!(doc.createElementNS && !!doc.createElementNS("http:/" + "/www.w3.org/2000/svg", "svg").createSVGRect);
+            },
+            /**
+             * @property {Boolean}
+             * True if VML supported.
+             */
+            VML: function() {
+                var element = this.getTestElement(),
+                    ret = false;
+
+                element.innerHTML = "<!--[if vml]><br/><br/><![endif]-->";
+                ret = (element.childNodes.length === 2);
+                element.innerHTML = "";
+
+                return ret;
+            },
+            /**
+             * @property {Boolean}
+             * True if we're in Sencha Touch environment.
+             */
+            Touch: function() {
+                return ('ontouchstart' in Ext.global) && !(Ext.platform && Ext.platform.name.match(/Windows|MacOSX|Linux/));
+            },
+            /**
+             * @property {Boolean}
+             * True if orientation API supported.
+             */
+            Orientation: function() {
+                return ('orientation' in Ext.global);
+            },
+            /**
+             * @property {Boolean}
+             * True if geolocation API supported.
+             */
+            Geolocation: function() {
+                return !!Ext.global.navigator.geolocation;
+            },
+            /**
+             * @property {Boolean}
+             * True if openDatabase API supported.
+             */
+            SqlDatabase: function() {
+                return !!Ext.global.openDatabase;
+            },
+            /**
+             * @property {Boolean}
+             * True if WebSocket API supported.
+             */
+            Websockets: function() {
+                return 'WebSocket' in Ext.global;
+            },
+            /**
+             * @property {Boolean}
+             * True if history.pushState supported.
+             */
+            History: function() {
+                return !!(Ext.global.history && Ext.global.history.pushState);
+            },
+            /**
+             * @property {Boolean}
+             * True if CSS transforms supported.
+             */
+            CSSTransforms: function() {
+                return this.isStyleSupported('transform');
+            },
+            /**
+             * @property {Boolean}
+             * True if CSS 3D transforms supported.
+             */
+            CSS3DTransforms: function() {
+                return this.has('csstransforms') && this.isStyleSupported('perspective');
+            },
+            /**
+             * @property {Boolean}
+             * True if CSS animations supported.
+             */
+            CSSAnimations: function() {
+                return this.isStyleSupported('animationName');
+            },
+            /**
+             * @property {Boolean}
+             * True if CSS transitions supported.
+             */
+            CSSTransitions: function() {
+                return this.isStyleSupported('transitionProperty');
+            },
+            /**
+             * @property {Boolean}
+             * True if audio element supported.
+             */
+            Audio: function() {
+                return !!this.getTestElement('audio').canPlayType;
+            },
+            /**
+             * @property {Boolean}
+             * True if video element supported.
+             */
+            Video: function() {
+                return !!this.getTestElement('video').canPlayType;
+            }
+        },
+
+        stylePrefixes: ['Webkit', 'Moz', 'O', 'ms']
+    },
+
+    constructor: function() {
+        this.tests = {};
+
+        this.testElements = {};
+
+        this.registerTests(this.self.defaultTests, true);
+
+        return this;
+    },
+
+    has: function(name) {
+        if (!this.hasTest(name)) {
+            return false;
+        }
+        else if (this.has.hasOwnProperty(name)) {
+            return this.has[name];
+        }
+        else {
+            return this.getTestResult(name);
+        }
+    },
+
+    getTestResult: function(name) {
+        return !!this.getTest(name).call(this);
+    },
+
+    getTestElement: function(tag) {
+        if (!tag) {
+            tag = 'div';
+        }
+
+        if (!this.testElements[tag]) {
+            this.testElements[tag] = Ext.global.document.createElement(tag);
+        }
+
+        return this.testElements[tag];
+    },
+
+    registerTest: function(name, fn, isDefault) {
+        //<debug>
+        if (this.hasTest(name)) {
+            Ext.Error.raise({
+                sourceClass: "Ext.env.FeatureDetector",
+                sourceMethod: "registerTest",
+                msg: "Test name " + name + " has already been registered"
+            });
+        }
+        //<debug>
+
+        this.tests[name] = fn;
+
+        if (isDefault) {
+            this.has[name] = this.getTestResult(name);
+        }
+
+        return this;
+    },
+
+    registerTests: function(tests, isDefault) {
+        var key;
+
+        for (key in tests) {
+            if (tests.hasOwnProperty(key)) {
+                this.registerTest(key, tests[key], isDefault);
+            }
+        }
+
+        return this;
+    },
+
+    hasTest: function(name) {
+        return this.tests.hasOwnProperty(name);
+    },
+
+    getTest: function(name) {
+        //<debug>
+        if (!this.hasTest(name)) {
+            Ext.Error.raise({
+                sourceClass: "Ext.env.FeatureDetector",
+                sourceMethod: "getTest",
+                msg: "Test name " + name + " does not exist"
+            });
+        }
+        //<debug>
+
+        return this.tests[name];
+    },
+
+    getTests: function() {
+        return this.tests;
+    },
+
+    isStyleSupported: function(name, tag) {
+        var elementStyle = this.getTestElement(tag).style,
+            cName = Ext.String.capitalize(name),
+            i = this.self.stylePrefixes.length;
+
+        if (elementStyle[name] !== undefined) {
+            return true;
+        }
+
+        while (i--) {
+            if (elementStyle[this.self.stylePrefixes[i] + cName] !== undefined) {
+                return true;
+            }
+        }
+
+        return false;
+    },
+
+    isEventSupported: function(name, tag) {
+        var element = this.getTestElement(tag),
+            eventName = 'on' + name,
+            isSupported = false;
+
+        // When using `setAttribute`, IE skips "unload", WebKit skips
+        // "unload" and "resize", whereas `in` "catches" those
+        isSupported = (eventName in element);
+
+        if (!isSupported) {
+            if (element.setAttribute && element.removeAttribute) {
+                element.setAttribute(eventName, '');
+                isSupported = typeof element[eventName] === 'function';
+
+                // If property was created, "remove it" (by setting value to `undefined`)
+                if (typeof element[eventName] !== 'undefined') {
+                    element[eventName] = undefined;
+                }
+
+                element.removeAttribute(eventName);
+            }
+        }
+
+        return isSupported;
+    }
+
+}, function() {
+
+    /**
+     * @property {Ext.env.FeatureDetector} features
+     * @member Ext
+     * Global convenient instance of {@link Ext.env.FeatureDetector}.
+     */
+    Ext.features = new Ext.env.FeatureDetector();
+
+});