docs/source/Browser.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-env-Browser'>/**
  19 </span> * @class Ext.env.Browser
  20  * @extends Ext.Base
  21  * Provide useful information about the current browser.
  22  * Should not be manually instantiated unless for unit-testing; access the global instance stored in Ext.browser instead. Example:
  23  * &lt;pre&gt;&lt;code&gt;
  24  * if (Ext.browser.is.IE) {
  25  *      // IE specific code here
  26  * }
  27  *
  28  * if (Ext.browser.is.WebKit) {
  29  *      // WebKit specific code here
  30  * }
  31  *
  32  * console.log(&quot;Version &quot; + Ext.browser.version);
  33  * &lt;/code&gt;&lt;/pre&gt;
  34  *
  35  * For a full list of supported values, refer to: {@link Ext.env.Browser#is}
  36  *
  37  * @borrows Ext.Base.extend
  38  */
  39 Ext.define('Ext.env.Browser', {
  40     statics: {
  41         browserNames: {
  42             ie: 'IE',
  43             firefox: 'Firefox',
  44             safari: 'Safari',
  45             chrome: 'Chrome',
  46             opera: 'Opera',
  47             other: 'Other'
  48         },
  49         engineNames: {
  50             webkit: 'WebKit',
  51             gecko: 'Gecko',
  52             presto: 'Presto',
  53             trident: 'Trident',
  54             other: 'Other'
  55         },
  56         enginePrefixes: {
  57             webkit: 'AppleWebKit/',
  58             gecko: 'Gecko/',
  59             presto: 'Presto/',
  60             trident: 'Trident/'
  61         },
  62         browserPrefixes: {
  63             ie: 'MSIE ',
  64             firefox: 'Firefox/',
  65             chrome: 'Chrome/',
  66             safari: 'Version/',
  67             opera: 'Opera/'
  68         }
  69     },
  70
  71 <span id='Ext-env-Browser-property-isSecure'>    /**
  72 </span>     * True if the page is running over SSL
  73      * @type Boolean
  74      */
  75     isSecure: false,
  76
  77 <span id='Ext-env-Browser-property-isStrict'>    /**
  78 </span>     * True if the document is in strict mode
  79      * @type Boolean
  80      */
  81     isStrict: false,
  82
  83 <span id='Ext-env-Browser-method-is'>    /**
  84 </span>     * A &quot;hybrid&quot; property, can be either accessed as a method call, i.e:
  85      * &lt;pre&gt;&lt;code&gt;
  86      * if (Ext.browser.is('IE')) { ... }
  87      * &lt;/code&gt;&lt;/pre&gt;
  88      *
  89      * or as an object with boolean properties, i.e:
  90      * &lt;pre&gt;&lt;code&gt;
  91      * if (Ext.browser.is.IE) { ... }
  92      * &lt;/code&gt;&lt;/pre&gt;
  93      *
  94      * Versions can be conveniently checked as well. For example:
  95      * &lt;pre&gt;&lt;code&gt;
  96      * if (Ext.browser.is.IE6) { ... } // Equivalent to (Ext.browser.is.IE &amp;&amp; Ext.browser.version.equals(6))
  97      * &lt;/code&gt;&lt;/pre&gt;
  98      *
  99      * Note that only {@link Ext.Version#getMajor major component}  and {@link Ext.Version#getShortVersion shortVersion}
 100      * value of the version are available via direct property checking.
 101      *
 102      * Supported values are: IE, Firefox, Safari, Chrome, Opera, WebKit, Gecko, Presto, Trident and Other
 103      *
 104      * @param {String} value The OS name to check
 105      * @return {Boolean}
 106      * @method
 107      */
 108     is: Ext.emptyFn,
 109
 110 <span id='Ext-env-Browser-property-name'>    /**
 111 </span>     * Read-only - the full name of the current browser
 112      * Possible values are: IE, Firefox, Safari, Chrome, Opera and Other
 113      * @type String
 114      */
 115     name: null,
 116
 117 <span id='Ext-env-Browser-property-version'>    /**
 118 </span>     * Read-only, refer to {@link Ext.Version}
 119      * @type Ext.Version
 120      */
 121     version: null,
 122
 123 <span id='Ext-env-Browser-property-engineName'>    /**
 124 </span>     * Read-only - the full name of the current browser's engine
 125      * Possible values are: WebKit, Gecko, Presto, Trident and Other
 126      * @type String
 127      */
 128     engineName: null,
 129
 130 <span id='Ext-env-Browser-property-engineVersion'>    /**
 131 </span>     * Read-only, refer to {@link Ext.Version}
 132      * @type Ext.Version
 133      */
 134     engineVersion: null,
 135
 136     constructor: function() {
 137         var userAgent = this.userAgent = Ext.global.navigator.userAgent,
 138             selfClass = this.statics(),
 139             browserMatch = userAgent.match(new RegExp('((?:' + Ext.Object.getValues(selfClass.browserPrefixes).join(')|(?:') + '))([\\d\\._]+)')),
 140             engineMatch = userAgent.match(new RegExp('((?:' + Ext.Object.getValues(selfClass.enginePrefixes).join(')|(?:') + '))([\\d\\._]+)')),
 141             browserName = selfClass.browserNames.other,
 142             browserVersion = '',
 143             engineName = selfClass.engineNames.other,
 144             engineVersion = '';
 145
 146         this.is = function(name) {
 147             return this.is[name] === true;
 148         };
 149
 150         if (browserMatch) {
 151             browserName = selfClass.browserNames[Ext.Object.getKey(selfClass.browserPrefixes, browserMatch[1])];
 152             browserVersion = browserMatch[2];
 153         }
 154
 155         if (engineMatch) {
 156             engineName = selfClass.engineNames[Ext.Object.getKey(selfClass.enginePrefixes, engineMatch[1])];
 157             engineVersion = engineMatch[2];
 158         }
 159
 160         Ext.apply(this, {
 161             engineName: engineName,
 162             engineVersion: new Ext.Version(engineVersion),
 163             name: browserName,
 164             version: new Ext.Version(browserVersion)
 165         });
 166
 167         this.is[this.name] = true;
 168         this.is[this.name + (this.version.getMajor() || '')] = true;
 169         this.is[this.name + this.version.getShortVersion()] = true;
 170         Ext.Object.each(selfClass.browserNames, function(key, name) {
 171             this.is[name] = (this.name === name);
 172         }, this);
 173
 174         this.is[this.name] = true;
 175         this.is[this.engineName + (this.engineVersion.getMajor() || '')] = true;
 176         this.is[this.engineName + this.engineVersion.getShortVersion()] = true;
 177         Ext.Object.each(selfClass.engineNames, function(key, name) {
 178             this.is[name] = (this.engineName === name);
 179         }, this);
 180
 181
 182         this.isSecure = /^https/i.test(Ext.global.location.protocol);
 183
 184         this.isStrict = Ext.global.document.compatMode === &quot;CSS1Compat&quot;;
 185
 186         return this;
 187     }
 188
 189 }, function() {
 190
 191     Ext.browser = new Ext.env.Browser();
 192
 193 });
 194 </pre>
 195 </body>
 196 </html>